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
}
