bool GraphicsContext3D::getActiveUniform(Platform3DObject program, GC3Duint index, ActiveInfo& info) { if (!program) { synthesizeGLError(INVALID_VALUE); return false; } makeContextCurrent(); GLint maxUniformSize = 0; ::glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxUniformSize); OwnArrayPtr<GLchar> name = adoptArrayPtr(new GLchar[maxUniformSize]); // GL_ACTIVE_UNIFORM_MAX_LENGTH includes null termination. GLsizei nameLength = 0; GLint size = 0; GLenum type = 0; ::glGetActiveUniform(program, index, maxUniformSize, &nameLength, &size, &type, name.get()); if (!nameLength) return false; info.name = String(name.get(), nameLength); info.type = type; info.size = size; return true; }
ScriptValue ScriptFunctionCall::call(bool& hadException, bool reportExceptions) { ScriptScope scope(m_scriptState, reportExceptions); v8::Local<v8::Object> thisObject = m_thisObject.v8Object(); v8::Local<v8::Value> value = thisObject->Get(v8String(m_name)); if (!scope.success()) { hadException = true; return ScriptValue(); } ASSERT(value->IsFunction()); v8::Local<v8::Function> function(v8::Function::Cast(*value)); OwnArrayPtr<v8::Handle<v8::Value> > args = adoptArrayPtr(new v8::Handle<v8::Value>[m_arguments.size()]); for (size_t i = 0; i < m_arguments.size(); ++i) args[i] = m_arguments[i].v8Value(); v8::Local<v8::Value> result; { V8RecursionScope innerScope(getScriptExecutionContext()); result = function->Call(thisObject, m_arguments.size(), args.get()); } if (!scope.success()) { hadException = true; return ScriptValue(); } return ScriptValue(result); }
void GraphicsContext3D::paintRenderingResultsToCanvas(ImageBuffer* imageBuffer, DrawingBuffer*) { int rowBytes = m_currentWidth * 4; int totalBytes = rowBytes * m_currentHeight; OwnArrayPtr<unsigned char> pixels = adoptArrayPtr(new unsigned char[totalBytes]); if (!pixels) return; readRenderingResults(pixels.get(), totalBytes); if (!m_attrs.premultipliedAlpha) { for (int i = 0; i < totalBytes; i += 4) { // Premultiply alpha. pixels[i + 0] = std::min(255, pixels[i + 0] * pixels[i + 3] / 255); pixels[i + 1] = std::min(255, pixels[i + 1] * pixels[i + 3] / 255); pixels[i + 2] = std::min(255, pixels[i + 2] * pixels[i + 3] / 255); } } #if PLATFORM(BLACKBERRY) paintToCanvas(pixels.get(), m_currentWidth, m_currentHeight, imageBuffer->internalSize().width(), imageBuffer->internalSize().height(), imageBuffer->context()); #else paintToCanvas(pixels.get(), m_currentWidth, m_currentHeight, imageBuffer->internalSize().width(), imageBuffer->internalSize().height(), imageBuffer->context()->platformContext()); #endif }
static String jsStringRefToWebCoreString(JSStringRef str) { size_t strArrSize = JSStringGetMaximumUTF8CStringSize(str); OwnArrayPtr<char> strArr = adoptArrayPtr(new char[strArrSize]); JSStringGetUTF8CString(str, strArr.get(), strArrSize); return String::fromUTF8(strArr.get()); }
static inline void initializeWithUserDefault(WTFLogChannel& channel) { DWORD length = GetEnvironmentVariableA(channel.defaultName, 0, 0); if (!length) return; OwnArrayPtr<char> buffer = adoptArrayPtr(new char[length]); if (!GetEnvironmentVariableA(channel.defaultName, buffer.get(), length)) return; String variableValue(buffer.get()); static const String& hexadecimalPrefix = *new String("0x"); if (variableValue.length() < 3 || !variableValue.startsWith(hexadecimalPrefix, false)) { LOG_ERROR("Unable to parse hex value for %s (%s), logging is off", channel.defaultName, buffer.get()); return; } String unprefixedValue = variableValue.substring(2); // Now parse the unprefixed string as a hexadecimal number. bool parsedSuccessfully = false; unsigned logLevel = unprefixedValue.toUIntStrict(&parsedSuccessfully, 16); if (!parsedSuccessfully) { LOG_ERROR("Unable to parse hex value for %s (%s), logging is off", channel.defaultName, buffer.get()); return; } if ((logLevel & channel.mask) == channel.mask) channel.state = WTFLogChannelOn; else channel.state = WTFLogChannelOff; }
bool ANGLEWebKitBridge::getUniforms(ShShaderType shaderType, Vector<ANGLEShaderSymbol> &symbols) { const ShHandle compiler = (shaderType == SH_VERTEX_SHADER ? m_vertexCompiler : m_fragmentCompiler); int numUniforms = getValidationResultValue(compiler, SH_ACTIVE_UNIFORMS); if (numUniforms < 0) return false; if (!numUniforms) return true; int maxNameLength = getValidationResultValue(compiler, SH_ACTIVE_UNIFORM_MAX_LENGTH); if (maxNameLength <= 1) return false; OwnArrayPtr<char> nameBuffer = adoptArrayPtr(new char[maxNameLength]); for (int i = 0; i < numUniforms; ++i) { ANGLEShaderSymbol symbol; symbol.symbolType = SHADER_SYMBOL_TYPE_UNIFORM; int nameLength = -1; ShGetActiveUniform(compiler, i, &nameLength, &symbol.size, &symbol.dataType, nameBuffer.get(), 0); if (nameLength <= 0) return false; symbol.name = String::fromUTF8(nameBuffer.get(), nameLength); symbols.append(symbol); } return true; }
void GraphicsContext3D::paintRenderingResultsToCanvas(CanvasRenderingContext* context, DrawingBuffer*) { HTMLCanvasElement* canvas = context->canvas(); ImageBuffer* imageBuffer = canvas->buffer(); int rowBytes = m_currentWidth * 4; int totalBytes = rowBytes * m_currentHeight; OwnArrayPtr<unsigned char> pixels = adoptArrayPtr(new unsigned char[totalBytes]); if (!pixels) return; readRenderingResults(pixels.get(), totalBytes); if (!m_attrs.premultipliedAlpha) { for (int i = 0; i < totalBytes; i += 4) { // Premultiply alpha. pixels[i + 0] = std::min(255, pixels[i + 0] * pixels[i + 3] / 255); pixels[i + 1] = std::min(255, pixels[i + 1] * pixels[i + 3] / 255); pixels[i + 2] = std::min(255, pixels[i + 2] * pixels[i + 3] / 255); } } paintToCanvas(pixels.get(), m_currentWidth, m_currentHeight, canvas->width(), canvas->height(), imageBuffer->context()->platformContext()); }
void ContextMenu::getContextMenuItems(HMENU menu, Vector<ContextMenuItem>& items) { #if OS(WINCE) notImplemented(); #else int count = ::GetMenuItemCount(menu); if (count <= 0) return; for (int i = 0; i < count; ++i) { MENUITEMINFO info = {0}; info.cbSize = sizeof(MENUITEMINFO); info.fMask = MIIM_FTYPE | MIIM_ID | MIIM_STRING | MIIM_STATE | MIIM_SUBMENU; if (!::GetMenuItemInfo(menu, i, TRUE, &info)) continue; if (info.fType == MFT_SEPARATOR) { items.append(ContextMenuItem(SeparatorType, ContextMenuItemTagNoAction, String())); continue; } int menuStringLength = info.cch + 1; OwnArrayPtr<WCHAR> menuString = adoptArrayPtr(new WCHAR[menuStringLength]); info.dwTypeData = menuString.get(); info.cch = menuStringLength; if (::GetMenuItemInfo(menu, i, TRUE, &info)) items.append(ContextMenuItem(info)); } #endif }
string WebViewHost::pathToLocalResource(const string& url) { #if OS(WINDOWS) if (!url.find("/tmp/")) { // We want a temp file. const unsigned tempPrefixLength = 5; size_t bufferSize = MAX_PATH; OwnArrayPtr<WCHAR> tempPath = adoptArrayPtr(new WCHAR[bufferSize]); DWORD tempLength = ::GetTempPathW(bufferSize, tempPath.get()); if (tempLength + url.length() - tempPrefixLength + 1 > bufferSize) { bufferSize = tempLength + url.length() - tempPrefixLength + 1; tempPath = adoptArrayPtr(new WCHAR[bufferSize]); tempLength = GetTempPathW(bufferSize, tempPath.get()); ASSERT(tempLength < bufferSize); } string resultPath(WebString(tempPath.get(), tempLength).utf8()); resultPath.append(url.substr(tempPrefixLength)); return resultPath; } #endif // Some layout tests use file://// which we resolve as a UNC path. Normalize // them to just file:///. string lowerUrl = url; string result = url; transform(lowerUrl.begin(), lowerUrl.end(), lowerUrl.begin(), ::tolower); while (!lowerUrl.find("file:////")) { result = result.substr(0, 8) + result.substr(9); lowerUrl = lowerUrl.substr(0, 8) + lowerUrl.substr(9); } return webkit_support::RewriteLayoutTestsURL(result).spec(); }
PassOwnArrayPtr<Length> newLengthArray(const String& string, int& len) { RefPtr<StringImpl> str = string.impl()->simplifyWhiteSpace(); if (!str->length()) { len = 1; return nullptr; } len = countCharacter(str->characters(), str->length(), ',') + 1; OwnArrayPtr<Length> r = adoptArrayPtr(new Length[len]); int i = 0; unsigned pos = 0; size_t pos2; while ((pos2 = str->find(',', pos)) != notFound) { r[i++] = parseLength(str->characters() + pos, pos2 - pos); pos = pos2+1; } ASSERT(i == len - 1); // IE Quirk: If the last comma is the last char skip it and reduce len by one. if (str->length()-pos > 0) r[i] = parseLength(str->characters() + pos, str->length() - pos); else len--; return r.release(); }
static const PassRefPtr<KeyEventInfo> keyPadName(WKStringRef keyRef) { if (WKStringIsEqualToUTF8CString(keyRef, "leftArrow")) return adoptRef(new KeyEventInfo("KP_Left", "")); if (WKStringIsEqualToUTF8CString(keyRef, "rightArrow")) return adoptRef(new KeyEventInfo("KP_Right", "")); if (WKStringIsEqualToUTF8CString(keyRef, "upArrow")) return adoptRef(new KeyEventInfo("KP_Up", "")); if (WKStringIsEqualToUTF8CString(keyRef, "downArrow")) return adoptRef(new KeyEventInfo("KP_Down", "")); if (WKStringIsEqualToUTF8CString(keyRef, "pageUp")) return adoptRef(new KeyEventInfo("KP_Prior", "")); if (WKStringIsEqualToUTF8CString(keyRef, "pageDown")) return adoptRef(new KeyEventInfo("KP_Next", "")); if (WKStringIsEqualToUTF8CString(keyRef, "home")) return adoptRef(new KeyEventInfo("KP_Home", "")); if (WKStringIsEqualToUTF8CString(keyRef, "end")) return adoptRef(new KeyEventInfo("KP_End", "")); if (WKStringIsEqualToUTF8CString(keyRef, "insert")) return adoptRef(new KeyEventInfo("KP_Insert", "")); if (WKStringIsEqualToUTF8CString(keyRef, "delete")) return adoptRef(new KeyEventInfo("KP_Delete", "")); size_t bufferSize = WKStringGetMaximumUTF8CStringSize(keyRef); OwnArrayPtr<char> buffer = adoptArrayPtr(new char[bufferSize]); WKStringGetUTF8CString(keyRef, buffer.get(), bufferSize); return adoptRef(new KeyEventInfo(buffer.get(), buffer.get())); }
std::string toSTD(WKStringRef string) { size_t bufferSize = WKStringGetMaximumUTF8CStringSize(string); OwnArrayPtr<char> buffer = adoptArrayPtr(new char[bufferSize]); size_t stringLength = WKStringGetUTF8CString(string, buffer.get(), bufferSize); return std::string(buffer.get(), stringLength - 1); }
void WebPreferences::copyWebKitPreferencesToCFPreferences(CFDictionaryRef dict) { ASSERT_ARG(dict, dict); int count = CFDictionaryGetCount(dict); if (count <= 0) return; CFStringRef didRemoveDefaultsKey = CFSTR(WebKitDidMigrateDefaultSettingsFromSafari3BetaPreferenceKey); bool omitDefaults = !booleanValueForPreferencesValue(CFDictionaryGetValue(dict, didRemoveDefaultsKey)); OwnArrayPtr<CFTypeRef> keys = adoptArrayPtr(new CFTypeRef[count]); OwnArrayPtr<CFTypeRef> values = adoptArrayPtr(new CFTypeRef[count]); CFDictionaryGetKeysAndValues(dict, keys.get(), values.get()); for (int i = 0; i < count; ++i) { if (!keys[i] || !values[i] || CFGetTypeID(keys[i]) != CFStringGetTypeID()) continue; if (omitDefaults) { CFTypeRef defaultValue = CFDictionaryGetValue(defaultSettings, keys[i]); if (defaultValue && CFEqual(defaultValue, values[i])) continue; } setValueForKey(static_cast<CFStringRef>(keys[i]), values[i]); } }
PassOwnArrayPtr<Length> newCoordsArray(const String& string, int& len) { unsigned length = string.length(); const UChar* data = string.characters(); StringBuffer<UChar> spacified(length); for (unsigned i = 0; i < length; i++) { UChar cc = data[i]; if (cc > '9' || (cc < '0' && cc != '-' && cc != '*' && cc != '.')) spacified[i] = ' '; else spacified[i] = cc; } RefPtr<StringImpl> str = StringImpl::adopt(spacified); str = str->simplifyWhiteSpace(); len = countCharacter(str->characters(), str->length(), ' ') + 1; OwnArrayPtr<Length> r = adoptArrayPtr(new Length[len]); int i = 0; unsigned pos = 0; size_t pos2; while ((pos2 = str->find(' ', pos)) != notFound) { r[i++] = parseLength(str->characters() + pos, pos2 - pos); pos = pos2+1; } r[i] = parseLength(str->characters() + pos, str->length() - pos); ASSERT(i == len - 1); return r.release(); }
bool GraphicsContext3DPrivate::getActiveUniform(Platform3DObject program, GC3Duint index, ActiveInfo& info) { if (!program) { synthesizeGLError(GL_INVALID_VALUE); return false; } makeContextCurrent(); GLint maxNameLength = 0; m_api->glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength); if (!maxNameLength) return false; OwnArrayPtr<char> name = adoptArrayPtr(new char[maxNameLength]); if (!name) { synthesizeGLError(GL_OUT_OF_MEMORY); return false; } GLsizei length = 0; GLint size = 0; GLenum type = 0; m_api->glGetActiveUniform(program, index, maxNameLength, &length, &size, &type, name.get()); if (!length) return false; info.name = String::fromUTF8(name.get(), length); info.type = type; info.size = size; return true; }
String GraphicsContext3D::getShaderInfoLog(Platform3DObject shader) { ASSERT(shader); makeContextCurrent(); HashMap<Platform3DObject, ShaderSourceEntry>::iterator result = m_shaderSourceMap.find(shader); if (result == m_shaderSourceMap.end()) return String(); ShaderSourceEntry entry = result->second; if (!entry.isValid) return entry.log; GLint length = 0; ::glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &length); if (!length) return String(); GLsizei size = 0; OwnArrayPtr<GLchar> info = adoptArrayPtr(new GLchar[length]); ::glGetShaderInfoLog(shader, length, &size, info.get()); return String(info.get()); }
static PassOwnArrayPtr<v8::Handle<v8::Value> > createValueListFromVariantArgs(const NPVariant* arguments, uint32_t argumentCount, NPObject* owner, v8::Isolate* isolate) { OwnArrayPtr<v8::Handle<v8::Value> > argv = adoptArrayPtr(new v8::Handle<v8::Value>[argumentCount]); for (uint32_t index = 0; index < argumentCount; index++) { const NPVariant* arg = &arguments[index]; argv[index] = convertNPVariantToV8Object(arg, owner, isolate); } return argv.release(); }
bool ScriptItem::invoke() const { BlackBerry::WebKit::JavaScriptDataType type; BlackBerry::WebKit::WebString result; size_t scriptArrSize = JSStringGetMaximumUTF8CStringSize(m_script.get()); OwnArrayPtr<char> script = adoptArrayPtr(new char[scriptArrSize]); JSStringGetUTF8CString(m_script.get(), script.get(), scriptArrSize); BlackBerry::WebKit::DumpRenderTree::currentInstance()->page()->executeJavaScript(script.get(), type, result); return true; }
static bool encodeImpl(const unsigned char* input, int imageWidth, int imageHeight, int bytesPerRow, Vector<unsigned char>* output, PixelConversionFunc conversionFunc) { int inputColorComponents = 4; int outputColorComponents = 4; int pngOutputColorType = PNG_COLOR_TYPE_RGB_ALPHA; if (imageWidth < 0) imageWidth = 0; if (imageHeight < 0) imageHeight = 0; // Row stride should be at least as long as the length of the data. if (inputColorComponents * imageWidth > bytesPerRow) { ASSERT(false); return false; } png_struct* pngPtr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0); if (!pngPtr) return false; png_info* infoPtr = png_create_info_struct(pngPtr); if (!infoPtr) { png_destroy_write_struct(&pngPtr, 0); return false; } PNGWriteStructDestroyer destroyer(&pngPtr, &infoPtr); if (setjmp(png_jmpbuf(pngPtr))) { // The destroyer will ensure that the structures are cleaned up in this // case, even though we may get here as a jump from random parts of the // PNG library called below. return false; } // Set our callback for libpng to give us the data. PNGEncoderState state(output); png_set_write_fn(pngPtr, &state, encoderWriteCallback, 0); png_set_IHDR(pngPtr, infoPtr, imageWidth, imageHeight, 8, pngOutputColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT); png_write_info(pngPtr, infoPtr); OwnArrayPtr<unsigned char> rowPixels = adoptArrayPtr(new unsigned char[imageWidth * outputColorComponents]); for (int y = 0; y < imageHeight; y ++) { conversionFunc(&input[y * bytesPerRow], imageWidth, rowPixels.get()); png_write_row(pngPtr, rowPixels.get()); } png_write_end(pngPtr, infoPtr); return true; }
void PluginView::handleTouchEvent(TouchEvent* event) { if (!m_private) return; if (!m_private->m_isFocused) focusPluginElement(); NPTouchEvent npTouchEvent; if (event->isDoubleTap()) npTouchEvent.type = TOUCH_EVENT_DOUBLETAP; else if (event->isTouchHold()) npTouchEvent.type = TOUCH_EVENT_TOUCHHOLD; else if (event->type() == eventNames().touchcancelEvent) npTouchEvent.type = TOUCH_EVENT_CANCEL; else return; TouchList* touchList; // The touches list is empty if in a touch end event. // Since DoubleTap is ususally a TouchEnd Use changedTouches instead. if (npTouchEvent.type == TOUCH_EVENT_DOUBLETAP) touchList = event->changedTouches(); else touchList = event->touches(); npTouchEvent.points = 0; npTouchEvent.size = touchList->length(); OwnArrayPtr<NPTouchPoint> touchPoints; if (touchList->length()) { touchPoints = adoptArrayPtr(new NPTouchPoint[touchList->length()]); npTouchEvent.points = touchPoints.get(); for (unsigned i = 0; i < touchList->length(); i++) { Touch* touchItem = touchList->item(i); touchPoints[i].touchId = touchItem->identifier(); touchPoints[i].clientX = touchItem->pageX() - frameRect().x(); touchPoints[i].clientY = touchItem->pageY() - frameRect().y(); touchPoints[i].screenX = touchItem->screenX(); touchPoints[i].screenY = touchItem->screenY(); touchPoints[i].pageX = touchItem->pageX(); touchPoints[i].pageY = touchItem->pageY(); } } NPEvent npEvent; npEvent.type = NP_TouchEvent; npEvent.data = &npTouchEvent; if (dispatchNPEvent(npEvent)) event->setDefaultHandled(); }
static void vprintf_stderr_with_prefix(const char* prefix, const char* format, va_list args) { size_t prefixLength = strlen(prefix); size_t formatLength = strlen(format); OwnArrayPtr<char> formatWithPrefix = adoptArrayPtr(new char[prefixLength + formatLength + 1]); memcpy(formatWithPrefix.get(), prefix, prefixLength); memcpy(formatWithPrefix.get() + prefixLength, format, formatLength); formatWithPrefix[prefixLength + formatLength] = 0; vprintf_stderr_common(formatWithPrefix.get(), args); }
SkImageFilter* FEMerge::createImageFilter(SkiaImageFilterBuilder* builder) { unsigned size = numberOfEffectInputs(); OwnArrayPtr<SkAutoTUnref<SkImageFilter> > inputRefs = adoptArrayPtr(new SkAutoTUnref<SkImageFilter>[size]); OwnArrayPtr<SkImageFilter*> inputs = adoptArrayPtr(new SkImageFilter*[size]); for (unsigned i = 0; i < size; ++i) { inputRefs[i].reset(builder->build(inputEffect(i))); inputs[i] = inputRefs[i].get(); } return new SkMergeImageFilter(inputs.get(), size); }
::testing::AssertionResult runJSTest(const char*, const char*, const char*, WKPageRef page, const char* script, const char* expectedResult) { JavaScriptCallbackContext context; WKPageRunJavaScriptInMainFrame(page, Util::toWK(script).get(), &context, javaScriptCallback); Util::run(&context.didFinish); size_t bufferSize = JSStringGetMaximumUTF8CStringSize(context.actualString.get()); OwnArrayPtr<char> buffer = adoptArrayPtr(new char[bufferSize]); JSStringGetUTF8CString(context.actualString.get(), buffer.get(), bufferSize); return compareJSResult(script, buffer.get(), expectedResult); }
void TestRunner::queueLoad(JSStringRef url, JSStringRef target) { size_t urlArrSize = JSStringGetMaximumUTF8CStringSize(url); OwnArrayPtr<char> urlArr = adoptArrayPtr(new char[urlArrSize]); JSStringGetUTF8CString(url, urlArr.get(), urlArrSize); WebCore::KURL base = mainFrame->loader()->documentLoader()->response().url(); WebCore::KURL absolute(base, urlArr.get()); JSRetainPtr<JSStringRef> absoluteURL(Adopt, JSStringCreateWithUTF8CString(absolute.string().utf8().data())); WorkQueue::shared()->queue(new LoadItem(absoluteURL.get(), target)); }
static inline JSValueRef stringArrayToJS(JSContextRef context, WKArrayRef strings) { const size_t count = WKArrayGetSize(strings); OwnArrayPtr<JSValueRef> jsStringsArray = adoptArrayPtr(new JSValueRef[count]); for (size_t i = 0; i < count; ++i) { WKStringRef stringRef = static_cast<WKStringRef>(WKArrayGetItemAtIndex(strings, i)); JSRetainPtr<JSStringRef> stringJS = toJS(stringRef); jsStringsArray[i] = JSValueMakeString(context, stringJS.get()); } return JSObjectMakeArray(context, count, jsStringsArray.get(), 0); }
void JSGlobalObject::copyGlobalsFrom(RegisterFile& registerFile) { ASSERT(!m_registerArray); ASSERT(!m_registerArraySize); int numGlobals = registerFile.numGlobals(); if (!numGlobals) { m_registers = 0; return; } OwnArrayPtr<WriteBarrier<Unknown> > registerArray = copyRegisterArray(globalData(), reinterpret_cast<WriteBarrier<Unknown>*>(registerFile.lastGlobal()), numGlobals, numGlobals); WriteBarrier<Unknown>* registers = registerArray.get() + numGlobals; setRegisters(registers, registerArray.release(), numGlobals); }
void DumpRenderTreeSupportEfl::setValueForUser(JSContextRef context, JSValueRef nodeObject, JSStringRef value) { JSC::ExecState* exec = toJS(context); WebCore::Element* element = WebCore::toElement(toJS(exec, nodeObject)); if (!element) return; WebCore::HTMLInputElement* inputElement = element->toInputElement(); if (!inputElement) return; size_t bufferSize = JSStringGetMaximumUTF8CStringSize(value); OwnArrayPtr<char> valueBuffer = adoptArrayPtr(new char[bufferSize]); JSStringGetUTF8CString(value, valueBuffer.get(), bufferSize); inputElement->setValueForUser(String::fromUTF8(valueBuffer.get())); }
static void vprintf_stderr_with_trailing_newline(const char* format, va_list args) { size_t formatLength = strlen(format); if (formatLength && format[formatLength - 1] == '\n') { vprintf_stderr_common(format, args); return; } OwnArrayPtr<char> formatWithNewline = adoptArrayPtr(new char[formatLength + 2]); memcpy(formatWithNewline.get(), format, formatLength); formatWithNewline[formatLength] = '\n'; formatWithNewline[formatLength + 1] = 0; vprintf_stderr_common(formatWithNewline.get(), args); }
// Creates the image from stdin with the given data length. On success, it // will return true. On failure, no other methods should be accessed. bool craeteFromStdin(size_t byteLength) { if (!byteLength) return false; OwnArrayPtr<unsigned char> source = adoptArrayPtr(new unsigned char[byteLength]); if (fread(source.get(), 1, byteLength, stdin) != byteLength) return false; if (!webkit_support::DecodePNG(source.get(), byteLength, &m_data, &m_width, &m_height)) { clear(); return false; } return true; }
WKArrayRef WKBundlePageCopyContextMenuItemTitles(WKBundlePageRef pageRef) { #if ENABLE(CONTEXT_MENUS) WebContextMenu* contextMenu = toImpl(pageRef)->contextMenu(); const Vector<WebContextMenuItemData> &items = contextMenu->items(); size_t arrayLength = items.size(); OwnArrayPtr<WKTypeRef> itemNames = adoptArrayPtr(new WKTypeRef[arrayLength]); for (size_t i = 0; i < arrayLength; ++i) itemNames[i] = WKStringCreateWithUTF8CString(items[i].title().utf8().data()); return WKArrayCreateAdoptingValues(itemNames.get(), arrayLength); #else return 0; #endif }