| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| /* |
| * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved. |
| * Copyright (C) 2009 Holger Hans Peter Freyther |
| * Copyright (C) 2010 Collabora Ltd. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "PluginObject.h" |
| |
| #include <assert.h> |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "PluginTest.h" |
| #include "base/strings/string_util.h" |
| #include "content/shell/tools/plugin/test_object.h" |
| |
| // Helper function which takes in the plugin window object for logging to the |
| // console object. |
| static void pluginLogWithWindowObject(NPObject* windowObject, |
| NPP instance, |
| const char* message) { |
| NPVariant consoleVariant; |
| if (!browser->getproperty(instance, |
| windowObject, |
| browser->getstringidentifier("console"), |
| &consoleVariant)) { |
| fprintf(stderr, |
| "Failed to retrieve console object while logging: %s\n", |
| message); |
| return; |
| } |
| |
| NPObject* consoleObject = NPVARIANT_TO_OBJECT(consoleVariant); |
| |
| NPVariant messageVariant; |
| STRINGZ_TO_NPVARIANT(message, messageVariant); |
| |
| NPVariant result; |
| if (!browser->invoke(instance, |
| consoleObject, |
| browser->getstringidentifier("log"), |
| &messageVariant, |
| 1, |
| &result)) { |
| fprintf( |
| stderr, "Failed to invoke console.log while logging: %s\n", message); |
| browser->releaseobject(consoleObject); |
| return; |
| } |
| |
| browser->releasevariantvalue(&result); |
| browser->releaseobject(consoleObject); |
| } |
| |
| void pluginLogWithArguments(NPP instance, const char* format, va_list args) { |
| const size_t messageBufferSize = 2048; |
| char message[messageBufferSize] = "PLUGIN: "; |
| int messageLength = sizeof("PLUGIN: ") - 1; |
| messageLength += vsnprintf(message + messageLength, |
| messageBufferSize - 1 - messageLength, |
| format, |
| args); |
| message[messageLength] = '\0'; |
| |
| NPObject* windowObject = 0; |
| NPError error = |
| browser->getvalue(instance, NPNVWindowNPObject, &windowObject); |
| if (error != NPERR_NO_ERROR) { |
| fprintf(stderr, |
| "Failed to retrieve window object while logging: %s\n", |
| message); |
| return; |
| } |
| |
| pluginLogWithWindowObject(windowObject, instance, message); |
| browser->releaseobject(windowObject); |
| } |
| |
| // Helper function to log to the console object. |
| void pluginLog(NPP instance, const char* format, ...) { |
| va_list args; |
| va_start(args, format); |
| pluginLogWithArguments(instance, format, args); |
| va_end(args); |
| } |
| |
| static void pluginInvalidate(NPObject*); |
| static bool pluginHasProperty(NPObject*, NPIdentifier name); |
| static bool pluginHasMethod(NPObject*, NPIdentifier name); |
| static bool pluginGetProperty(NPObject*, NPIdentifier name, NPVariant*); |
| static bool pluginSetProperty(NPObject*, NPIdentifier name, const NPVariant*); |
| static bool pluginInvoke(NPObject*, |
| NPIdentifier name, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result); |
| static NPObject* pluginAllocate(NPP npp, NPClass*); |
| static void pluginDeallocate(NPObject*); |
| |
| NPNetscapeFuncs* browser; |
| NPPluginFuncs* pluginFunctions; |
| |
| static NPClass pluginClass_ = { |
| NP_CLASS_STRUCT_VERSION, pluginAllocate, pluginDeallocate, |
| pluginInvalidate, pluginHasMethod, pluginInvoke, |
| 0, // NPClass::invokeDefault, |
| pluginHasProperty, pluginGetProperty, pluginSetProperty, |
| 0, // NPClass::removeProperty |
| 0, // NPClass::enumerate |
| 0, // NPClass::construct |
| }; |
| |
| NPClass* createPluginClass(void) { |
| NPClass* pluginClass = new NPClass; |
| *pluginClass = pluginClass_; |
| return pluginClass; |
| } |
| |
| static bool identifiersInitialized = false; |
| |
| enum { |
| ID_PROPERTY_PROPERTY = 0, |
| ID_PROPERTY_EVENT_LOGGING, |
| ID_PROPERTY_HAS_STREAM, |
| ID_PROPERTY_TEST_OBJECT, |
| ID_PROPERTY_LOG_DESTROY, |
| ID_PROPERTY_RETURN_ERROR_FROM_NEWSTREAM, |
| ID_PROPERTY_RETURN_NEGATIVE_ONE_FROM_WRITE, |
| ID_PROPERTY_THROW_EXCEPTION_PROPERTY, |
| ID_LAST_SET_WINDOW_ARGUMENTS, |
| ID_PROPERTY_TEST_OBJECT_COUNT, |
| ID_PROPERTY_DELETE_IN_GET_PROPERTY, |
| ID_PROPERTY_DELETE_IN_HAS_PROPERTY_RETURN_TRUE, |
| ID_PROPERTY_DELETE_IN_SET_PROPERTY, |
| NUM_PROPERTY_IDENTIFIERS |
| }; |
| |
| static NPIdentifier pluginPropertyIdentifiers[NUM_PROPERTY_IDENTIFIERS]; |
| static const NPUTF8* pluginPropertyIdentifierNames[NUM_PROPERTY_IDENTIFIERS] = { |
| "property", |
| "eventLoggingEnabled", |
| "hasStream", |
| "testObject", |
| "logDestroy", |
| "returnErrorFromNewStream", |
| "returnNegativeOneFromWrite", |
| "testThrowExceptionProperty", |
| "lastSetWindowArguments", |
| "testObjectCount", |
| "deletePluginInGetProperty", |
| "deletePluginInHasPropertyReturnTrue", |
| "deletePluginInSetProperty"}; |
| |
| enum { |
| ID_TEST_CALLBACK_METHOD = 0, |
| ID_TEST_CALLBACK_METHOD_RETURN, |
| ID_TEST_GETURL, |
| ID_TEST_DOM_ACCESS, |
| ID_TEST_GET_URL_NOTIFY, |
| ID_TEST_INVOKE_DEFAULT, |
| ID_DESTROY_STREAM, |
| ID_TEST_ENUMERATE, |
| ID_TEST_GETINTIDENTIFIER, |
| ID_TEST_GET_PROPERTY, |
| ID_TEST_HAS_PROPERTY, |
| ID_TEST_HAS_METHOD, |
| ID_TEST_EVALUATE, |
| ID_TEST_GET_PROPERTY_RETURN_VALUE, |
| ID_TEST_IDENTIFIER_TO_STRING, |
| ID_TEST_IDENTIFIER_TO_INT, |
| ID_TEST_PASS_TEST_OBJECT, |
| ID_TEST_POSTURL_FILE, |
| ID_TEST_CONSTRUCT, |
| ID_TEST_THROW_EXCEPTION_METHOD, |
| ID_TEST_FAIL_METHOD, |
| ID_TEST_CLONE_OBJECT, |
| ID_TEST_SCRIPT_OBJECT_INVOKE, |
| ID_TEST_CREATE_TEST_OBJECT, |
| ID_DESTROY_NULL_STREAM, |
| ID_TEST_RELOAD_PLUGINS_NO_PAGES, |
| ID_TEST_RELOAD_PLUGINS_AND_PAGES, |
| ID_TEST_GET_BROWSER_PROPERTY, |
| ID_TEST_SET_BROWSER_PROPERTY, |
| ID_REMEMBER, |
| ID_GET_REMEMBERED_OBJECT, |
| ID_GET_AND_FORGET_REMEMBERED_OBJECT, |
| ID_REF_COUNT, |
| ID_SET_STATUS, |
| ID_RESIZE_TO, |
| ID_NORMALIZE, |
| ID_INVALIDATE_RECT, |
| ID_OBJECTS_ARE_SAME, |
| ID_TEST_DELETE_WITHIN_INVOKE, |
| NUM_METHOD_IDENTIFIERS |
| }; |
| |
| static NPIdentifier pluginMethodIdentifiers[NUM_METHOD_IDENTIFIERS]; |
| static const NPUTF8* pluginMethodIdentifierNames[NUM_METHOD_IDENTIFIERS] = { |
| "testCallback", "testCallbackReturn", |
| "getURL", "testDOMAccess", |
| "getURLNotify", "testInvokeDefault", |
| "destroyStream", "testEnumerate", |
| "testGetIntIdentifier", "testGetProperty", |
| "testHasProperty", "testHasMethod", |
| "testEvaluate", "testGetPropertyReturnValue", |
| "testIdentifierToString", "testIdentifierToInt", |
| "testPassTestObject", "testPostURLFile", |
| "testConstruct", "testThrowException", |
| "testFail", "testCloneObject", |
| "testScriptObjectInvoke", "testCreateTestObject", |
| "destroyNullStream", "reloadPluginsNoPages", |
| "reloadPluginsAndPages", "testGetBrowserProperty", |
| "testSetBrowserProperty", "remember", |
| "getRememberedObject", "getAndForgetRememberedObject", |
| "refCount", "setStatus", |
| "resizeTo", "normalize", |
| "invalidateRect", "objectsAreSame", |
| "testDeleteWithinInvoke"}; |
| |
| static NPUTF8* createCStringFromNPVariant(const NPVariant* variant) { |
| size_t length = NPVARIANT_TO_STRING(*variant).UTF8Length; |
| NPUTF8* result = (NPUTF8*)malloc(length + 1); |
| memcpy(result, NPVARIANT_TO_STRING(*variant).UTF8Characters, length); |
| result[length] = '\0'; |
| return result; |
| } |
| |
| static void initializeIdentifiers(void) { |
| browser->getstringidentifiers(pluginPropertyIdentifierNames, |
| NUM_PROPERTY_IDENTIFIERS, |
| pluginPropertyIdentifiers); |
| browser->getstringidentifiers(pluginMethodIdentifierNames, |
| NUM_METHOD_IDENTIFIERS, |
| pluginMethodIdentifiers); |
| } |
| |
| static bool callDeletePlugin(NPObject* obj, |
| NPIdentifier name, |
| NPIdentifier identifierToMatch) { |
| if (name != identifierToMatch) |
| return false; |
| |
| PluginObject* plugin = reinterpret_cast<PluginObject*>(obj); |
| NPObject* windowScriptObject; |
| browser->getvalue(plugin->npp, NPNVWindowNPObject, &windowScriptObject); |
| |
| NPIdentifier callbackIdentifier = |
| browser->getstringidentifier("deletePlugin"); |
| NPVariant browserResult; |
| if (browser->invoke(plugin->npp, |
| windowScriptObject, |
| callbackIdentifier, |
| 0, |
| 0, |
| &browserResult)) |
| browser->releasevariantvalue(&browserResult); |
| return true; |
| } |
| |
| static bool pluginHasProperty(NPObject* obj, NPIdentifier name) { |
| if (callDeletePlugin( |
| obj, |
| name, |
| browser->getstringidentifier("deletePluginInHasPropertyReturnFalse"))) |
| return false; |
| |
| callDeletePlugin(obj, |
| name, |
| pluginPropertyIdentifiers |
| [ID_PROPERTY_DELETE_IN_HAS_PROPERTY_RETURN_TRUE]); |
| |
| for (int i = 0; i < NUM_PROPERTY_IDENTIFIERS; i++) |
| if (name == pluginPropertyIdentifiers[i]) |
| return true; |
| return false; |
| } |
| |
| static bool pluginHasMethod(NPObject* obj, NPIdentifier name) { |
| if (callDeletePlugin( |
| obj, name, browser->getstringidentifier("deletePluginInHasMethod"))) |
| return true; |
| |
| for (int i = 0; i < NUM_METHOD_IDENTIFIERS; i++) |
| if (name == pluginMethodIdentifiers[i]) |
| return true; |
| return false; |
| } |
| |
| static bool pluginGetProperty(NPObject* obj, |
| NPIdentifier name, |
| NPVariant* result) { |
| PluginObject* plugin = reinterpret_cast<PluginObject*>(obj); |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_PROPERTY]) { |
| static const char* originalString = "property"; |
| char* buf = |
| static_cast<char*>(browser->memalloc(strlen(originalString) + 1)); |
| strcpy(buf, originalString); |
| STRINGZ_TO_NPVARIANT(buf, *result); |
| return true; |
| } |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_EVENT_LOGGING]) { |
| BOOLEAN_TO_NPVARIANT(plugin->eventLogging, *result); |
| return true; |
| } |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_LOG_DESTROY]) { |
| BOOLEAN_TO_NPVARIANT(plugin->logDestroy, *result); |
| return true; |
| } |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_HAS_STREAM]) { |
| BOOLEAN_TO_NPVARIANT(plugin->stream, *result); |
| return true; |
| } |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_TEST_OBJECT]) { |
| NPObject* testObject = plugin->testObject; |
| browser->retainobject(testObject); |
| OBJECT_TO_NPVARIANT(testObject, *result); |
| return true; |
| } |
| if (name == |
| pluginPropertyIdentifiers[ID_PROPERTY_RETURN_ERROR_FROM_NEWSTREAM]) { |
| BOOLEAN_TO_NPVARIANT(plugin->returnErrorFromNewStream, *result); |
| return true; |
| } |
| if (name == |
| pluginPropertyIdentifiers[ID_PROPERTY_RETURN_NEGATIVE_ONE_FROM_WRITE]) { |
| BOOLEAN_TO_NPVARIANT(plugin->returnNegativeOneFromWrite, *result); |
| return true; |
| } |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_THROW_EXCEPTION_PROPERTY]) { |
| browser->setexception(obj, |
| "plugin object testThrowExceptionProperty SUCCESS"); |
| return true; |
| } |
| if (name == pluginPropertyIdentifiers[ID_LAST_SET_WINDOW_ARGUMENTS]) { |
| char* buf = static_cast<char*>(browser->memalloc(256)); |
| snprintf( |
| buf, |
| 256, |
| "x: %d, y: %d, width: %u, height: %u, clipRect: (%u, %u, %u, %u)", |
| (int)plugin->lastWindow.x, |
| (int)plugin->lastWindow.y, |
| (unsigned)plugin->lastWindow.width, |
| (unsigned)plugin->lastWindow.height, |
| plugin->lastWindow.clipRect.left, |
| plugin->lastWindow.clipRect.top, |
| plugin->lastWindow.clipRect.right - plugin->lastWindow.clipRect.left, |
| plugin->lastWindow.clipRect.bottom - plugin->lastWindow.clipRect.top); |
| |
| STRINGZ_TO_NPVARIANT(buf, *result); |
| return true; |
| } |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_TEST_OBJECT_COUNT]) { |
| INT32_TO_NPVARIANT(content::GetTestObjectCount(), *result); |
| return true; |
| } |
| |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_DELETE_IN_GET_PROPERTY]) { |
| browser->retainobject(obj); |
| callDeletePlugin( |
| obj, |
| name, |
| pluginPropertyIdentifiers[ID_PROPERTY_DELETE_IN_GET_PROPERTY]); |
| NPObject* testObject = plugin->testObject; |
| browser->retainobject(testObject); |
| OBJECT_TO_NPVARIANT(testObject, *result); |
| browser->releaseobject(obj); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static bool pluginSetProperty(NPObject* obj, |
| NPIdentifier name, |
| const NPVariant* variant) { |
| PluginObject* plugin = reinterpret_cast<PluginObject*>(obj); |
| if (callDeletePlugin( |
| obj, |
| name, |
| pluginPropertyIdentifiers[ID_PROPERTY_DELETE_IN_SET_PROPERTY])) |
| return true; |
| |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_EVENT_LOGGING]) { |
| plugin->eventLogging = NPVARIANT_TO_BOOLEAN(*variant); |
| return true; |
| } |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_LOG_DESTROY]) { |
| plugin->logDestroy = NPVARIANT_TO_BOOLEAN(*variant); |
| return true; |
| } |
| if (name == |
| pluginPropertyIdentifiers[ID_PROPERTY_RETURN_ERROR_FROM_NEWSTREAM]) { |
| plugin->returnErrorFromNewStream = NPVARIANT_TO_BOOLEAN(*variant); |
| return true; |
| } |
| if (name == |
| pluginPropertyIdentifiers[ID_PROPERTY_RETURN_NEGATIVE_ONE_FROM_WRITE]) { |
| plugin->returnNegativeOneFromWrite = NPVARIANT_TO_BOOLEAN(*variant); |
| return true; |
| } |
| if (name == pluginPropertyIdentifiers[ID_PROPERTY_THROW_EXCEPTION_PROPERTY]) { |
| browser->setexception(obj, |
| "plugin object testThrowExceptionProperty SUCCESS"); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| static bool testDOMAccess(PluginObject* obj, |
| const NPVariant*, |
| uint32_t, |
| NPVariant* result) { |
| // Get plugin's DOM element |
| NPObject* elementObject; |
| if (browser->getvalue(obj->npp, NPNVPluginElementNPObject, &elementObject) == |
| NPERR_NO_ERROR) { |
| // Get style |
| NPVariant styleVariant; |
| NPIdentifier styleIdentifier = browser->getstringidentifier("style"); |
| if (browser->getproperty( |
| obj->npp, elementObject, styleIdentifier, &styleVariant) && |
| NPVARIANT_IS_OBJECT(styleVariant)) { |
| // Set style.border |
| NPIdentifier borderIdentifier = browser->getstringidentifier("border"); |
| NPVariant borderVariant; |
| STRINGZ_TO_NPVARIANT("3px solid red", borderVariant); |
| browser->setproperty(obj->npp, |
| NPVARIANT_TO_OBJECT(styleVariant), |
| borderIdentifier, |
| &borderVariant); |
| browser->releasevariantvalue(&styleVariant); |
| } |
| |
| browser->releaseobject(elementObject); |
| } |
| VOID_TO_NPVARIANT(*result); |
| return true; |
| } |
| |
| static NPIdentifier stringVariantToIdentifier(NPVariant variant) { |
| assert(NPVARIANT_IS_STRING(variant)); |
| NPUTF8* utf8String = createCStringFromNPVariant(&variant); |
| NPIdentifier identifier = browser->getstringidentifier(utf8String); |
| free(utf8String); |
| return identifier; |
| } |
| |
| static NPIdentifier int32VariantToIdentifier(NPVariant variant) { |
| assert(NPVARIANT_IS_INT32(variant)); |
| int32_t integer = NPVARIANT_TO_INT32(variant); |
| return browser->getintidentifier(integer); |
| } |
| |
| static NPIdentifier doubleVariantToIdentifier(NPVariant variant) { |
| assert(NPVARIANT_IS_DOUBLE(variant)); |
| double value = NPVARIANT_TO_DOUBLE(variant); |
| // Sadly there is no "getdoubleidentifier" |
| int32_t integer = static_cast<int32_t>(value); |
| return browser->getintidentifier(integer); |
| } |
| |
| static NPIdentifier variantToIdentifier(NPVariant variant) { |
| if (NPVARIANT_IS_STRING(variant)) |
| return stringVariantToIdentifier(variant); |
| if (NPVARIANT_IS_INT32(variant)) |
| return int32VariantToIdentifier(variant); |
| if (NPVARIANT_IS_DOUBLE(variant)) |
| return doubleVariantToIdentifier(variant); |
| return 0; |
| } |
| |
| static bool testIdentifierToString(PluginObject*, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 1) |
| return true; |
| NPIdentifier identifier = variantToIdentifier(args[0]); |
| if (!identifier) |
| return true; |
| NPUTF8* utf8String = browser->utf8fromidentifier(identifier); |
| if (!utf8String) |
| return true; |
| STRINGZ_TO_NPVARIANT(utf8String, *result); |
| return true; |
| } |
| |
| static bool testIdentifierToInt(PluginObject*, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 1) |
| return false; |
| NPIdentifier identifier = variantToIdentifier(args[0]); |
| if (!identifier) |
| return false; |
| int32_t integer = browser->intfromidentifier(identifier); |
| INT32_TO_NPVARIANT(integer, *result); |
| return true; |
| } |
| |
| static bool testPassTestObject(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 2 || !NPVARIANT_IS_STRING(args[0])) |
| return false; |
| |
| NPObject* windowScriptObject; |
| browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject); |
| |
| NPUTF8* callbackString = createCStringFromNPVariant(&args[0]); |
| NPIdentifier callbackIdentifier = |
| browser->getstringidentifier(callbackString); |
| free(callbackString); |
| |
| NPVariant browserResult; |
| browser->invoke(obj->npp, |
| windowScriptObject, |
| callbackIdentifier, |
| &args[1], |
| 1, |
| &browserResult); |
| browser->releasevariantvalue(&browserResult); |
| |
| VOID_TO_NPVARIANT(*result); |
| return true; |
| } |
| |
| static bool testCallback(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (!argCount || !NPVARIANT_IS_STRING(args[0])) |
| return false; |
| |
| NPObject* windowScriptObject; |
| browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject); |
| |
| NPUTF8* callbackString = createCStringFromNPVariant(&args[0]); |
| NPIdentifier callbackIdentifier = |
| browser->getstringidentifier(callbackString); |
| free(callbackString); |
| |
| NPVariant browserResult; |
| if (browser->invoke(obj->npp, |
| windowScriptObject, |
| callbackIdentifier, |
| 0, |
| 0, |
| &browserResult)) |
| browser->releasevariantvalue(&browserResult); |
| |
| browser->releaseobject(windowScriptObject); |
| |
| VOID_TO_NPVARIANT(*result); |
| return true; |
| } |
| |
| static bool testCallbackReturn(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 1 || !NPVARIANT_IS_STRING(args[0])) |
| return false; |
| |
| NPObject* windowScriptObject; |
| browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject); |
| |
| NPUTF8* callbackString = createCStringFromNPVariant(&args[0]); |
| NPIdentifier callbackIdentifier = |
| browser->getstringidentifier(callbackString); |
| free(callbackString); |
| |
| NPVariant callbackArgs[1]; |
| OBJECT_TO_NPVARIANT(windowScriptObject, callbackArgs[0]); |
| |
| NPVariant browserResult; |
| browser->invoke(obj->npp, |
| windowScriptObject, |
| callbackIdentifier, |
| callbackArgs, |
| 1, |
| &browserResult); |
| |
| if (NPVARIANT_IS_OBJECT(browserResult)) |
| OBJECT_TO_NPVARIANT(NPVARIANT_TO_OBJECT(browserResult), *result); |
| else { |
| browser->releasevariantvalue(&browserResult); |
| VOID_TO_NPVARIANT(*result); |
| } |
| |
| return true; |
| } |
| |
| static bool getURL(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount == 2 && NPVARIANT_IS_STRING(args[0]) && |
| NPVARIANT_IS_STRING(args[1])) { |
| NPUTF8* urlString = createCStringFromNPVariant(&args[0]); |
| NPUTF8* targetString = createCStringFromNPVariant(&args[1]); |
| NPError npErr = browser->geturl(obj->npp, urlString, targetString); |
| free(urlString); |
| free(targetString); |
| |
| INT32_TO_NPVARIANT(npErr, *result); |
| return true; |
| } |
| if (argCount == 1 && NPVARIANT_IS_STRING(args[0])) { |
| NPUTF8* urlString = createCStringFromNPVariant(&args[0]); |
| NPError npErr = browser->geturl(obj->npp, urlString, 0); |
| free(urlString); |
| |
| INT32_TO_NPVARIANT(npErr, *result); |
| return true; |
| } |
| return false; |
| } |
| |
| static bool getURLNotify(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 3 || !NPVARIANT_IS_STRING(args[0]) || |
| (!NPVARIANT_IS_STRING(args[1]) && !NPVARIANT_IS_NULL(args[1])) || |
| !NPVARIANT_IS_STRING(args[2])) |
| return false; |
| |
| NPUTF8* urlString = createCStringFromNPVariant(&args[0]); |
| NPUTF8* targetString = |
| (NPVARIANT_IS_STRING(args[1]) ? createCStringFromNPVariant(&args[1]) : 0); |
| NPUTF8* callbackString = createCStringFromNPVariant(&args[2]); |
| |
| NPIdentifier callbackIdentifier = |
| browser->getstringidentifier(callbackString); |
| browser->geturlnotify(obj->npp, urlString, targetString, callbackIdentifier); |
| |
| free(urlString); |
| free(targetString); |
| free(callbackString); |
| |
| VOID_TO_NPVARIANT(*result); |
| return true; |
| } |
| |
| static bool testInvokeDefault(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (!NPVARIANT_IS_OBJECT(args[0])) |
| return false; |
| |
| NPObject* callback = NPVARIANT_TO_OBJECT(args[0]); |
| |
| NPVariant invokeArgs[1]; |
| NPVariant browserResult; |
| |
| STRINGZ_TO_NPVARIANT("test", invokeArgs[0]); |
| bool retval = |
| browser->invokeDefault(obj->npp, callback, invokeArgs, 1, &browserResult); |
| |
| if (retval) |
| browser->releasevariantvalue(&browserResult); |
| |
| BOOLEAN_TO_NPVARIANT(retval, *result); |
| return true; |
| } |
| |
| static bool destroyStream(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| NPError npError = |
| browser->destroystream(obj->npp, obj->stream, NPRES_USER_BREAK); |
| INT32_TO_NPVARIANT(npError, *result); |
| return true; |
| } |
| |
| static bool destroyNullStream(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| NPError npError = browser->destroystream(obj->npp, 0, NPRES_USER_BREAK); |
| INT32_TO_NPVARIANT(npError, *result); |
| return true; |
| } |
| |
| static bool testEnumerate(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 2 || !NPVARIANT_IS_OBJECT(args[0]) || |
| !NPVARIANT_IS_OBJECT(args[1])) |
| return false; |
| |
| uint32_t count; |
| NPIdentifier* identifiers; |
| if (browser->enumerate( |
| obj->npp, NPVARIANT_TO_OBJECT(args[0]), &identifiers, &count)) { |
| NPObject* outArray = NPVARIANT_TO_OBJECT(args[1]); |
| NPIdentifier pushIdentifier = browser->getstringidentifier("push"); |
| |
| for (uint32_t i = 0; i < count; i++) { |
| NPUTF8* string = browser->utf8fromidentifier(identifiers[i]); |
| |
| if (!string) |
| continue; |
| |
| NPVariant args[1]; |
| STRINGZ_TO_NPVARIANT(string, args[0]); |
| NPVariant browserResult; |
| if (browser->invoke( |
| obj->npp, outArray, pushIdentifier, args, 1, &browserResult)) |
| browser->releasevariantvalue(&browserResult); |
| browser->memfree(string); |
| } |
| |
| browser->memfree(identifiers); |
| } |
| |
| VOID_TO_NPVARIANT(*result); |
| return true; |
| } |
| |
| static bool testGetIntIdentifier(PluginObject*, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 1 || !NPVARIANT_IS_DOUBLE(args[0])) |
| return false; |
| |
| NPIdentifier identifier = |
| browser->getintidentifier((int)NPVARIANT_TO_DOUBLE(args[0])); |
| INT32_TO_NPVARIANT((int32_t)(long long)identifier, *result); |
| return true; |
| } |
| |
| static bool testGetProperty(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (!argCount) |
| return false; |
| |
| NPObject* object; |
| browser->getvalue(obj->npp, NPNVWindowNPObject, &object); |
| |
| for (uint32_t i = 0; i < argCount; i++) { |
| assert(NPVARIANT_IS_STRING(args[i])); |
| NPUTF8* propertyString = createCStringFromNPVariant(&args[i]); |
| NPIdentifier propertyIdentifier = |
| browser->getstringidentifier(propertyString); |
| free(propertyString); |
| |
| NPVariant variant; |
| bool retval = |
| browser->getproperty(obj->npp, object, propertyIdentifier, &variant); |
| browser->releaseobject(object); |
| |
| if (!retval) |
| break; |
| |
| if (i + 1 < argCount) { |
| assert(NPVARIANT_IS_OBJECT(variant)); |
| object = NPVARIANT_TO_OBJECT(variant); |
| } else { |
| *result = variant; |
| return true; |
| } |
| } |
| |
| VOID_TO_NPVARIANT(*result); |
| return false; |
| } |
| |
| static bool testHasProperty(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 2 || !NPVARIANT_IS_OBJECT(args[0]) || |
| !NPVARIANT_IS_STRING(args[1])) |
| return false; |
| |
| NPUTF8* propertyString = createCStringFromNPVariant(&args[1]); |
| NPIdentifier propertyIdentifier = |
| browser->getstringidentifier(propertyString); |
| free(propertyString); |
| |
| bool retval = browser->hasproperty( |
| obj->npp, NPVARIANT_TO_OBJECT(args[0]), propertyIdentifier); |
| |
| BOOLEAN_TO_NPVARIANT(retval, *result); |
| return true; |
| } |
| |
| static bool testHasMethod(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 2 || !NPVARIANT_IS_OBJECT(args[0]) || |
| !NPVARIANT_IS_STRING(args[1])) |
| return false; |
| |
| NPUTF8* propertyString = createCStringFromNPVariant(&args[1]); |
| NPIdentifier propertyIdentifier = |
| browser->getstringidentifier(propertyString); |
| free(propertyString); |
| |
| bool retval = browser->hasmethod( |
| obj->npp, NPVARIANT_TO_OBJECT(args[0]), propertyIdentifier); |
| |
| BOOLEAN_TO_NPVARIANT(retval, *result); |
| return true; |
| } |
| |
| static bool testEvaluate(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 1 || !NPVARIANT_IS_STRING(args[0])) |
| return false; |
| NPObject* windowScriptObject; |
| browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject); |
| |
| NPString s = NPVARIANT_TO_STRING(args[0]); |
| |
| bool retval = browser->evaluate(obj->npp, windowScriptObject, &s, result); |
| browser->releaseobject(windowScriptObject); |
| return retval; |
| } |
| |
| static bool testGetPropertyReturnValue(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 2 || !NPVARIANT_IS_OBJECT(args[0]) || |
| !NPVARIANT_IS_STRING(args[1])) |
| return false; |
| |
| NPUTF8* propertyString = createCStringFromNPVariant(&args[1]); |
| NPIdentifier propertyIdentifier = |
| browser->getstringidentifier(propertyString); |
| free(propertyString); |
| |
| NPVariant variant; |
| bool retval = browser->getproperty( |
| obj->npp, NPVARIANT_TO_OBJECT(args[0]), propertyIdentifier, &variant); |
| if (retval) |
| browser->releasevariantvalue(&variant); |
| |
| BOOLEAN_TO_NPVARIANT(retval, *result); |
| return true; |
| } |
| |
| static char* toCString(const NPString& string) { |
| char* result = static_cast<char*>(malloc(string.UTF8Length + 1)); |
| memcpy(result, string.UTF8Characters, string.UTF8Length); |
| result[string.UTF8Length] = '\0'; |
| |
| return result; |
| } |
| |
| static bool testPostURLFile(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 4 || !NPVARIANT_IS_STRING(args[0]) || |
| !NPVARIANT_IS_STRING(args[1]) || !NPVARIANT_IS_STRING(args[2]) || |
| !NPVARIANT_IS_STRING(args[3])) |
| return false; |
| |
| NPString urlString = NPVARIANT_TO_STRING(args[0]); |
| char* url = toCString(urlString); |
| |
| NPString targetString = NPVARIANT_TO_STRING(args[1]); |
| char* target = toCString(targetString); |
| |
| NPString pathString = NPVARIANT_TO_STRING(args[2]); |
| char* path = toCString(pathString); |
| |
| NPString contentsString = NPVARIANT_TO_STRING(args[3]); |
| |
| FILE* tempFile = fopen(path, "w"); |
| if (!tempFile) |
| return false; |
| |
| size_t written = fwrite( |
| contentsString.UTF8Characters, contentsString.UTF8Length, 1, tempFile); |
| fclose(tempFile); |
| if (!written) |
| return false; |
| |
| NPError error = browser->posturl( |
| obj->npp, url, target, pathString.UTF8Length, path, true); |
| |
| free(path); |
| free(target); |
| free(url); |
| |
| BOOLEAN_TO_NPVARIANT(error == NPERR_NO_ERROR, *result); |
| return true; |
| } |
| |
| static bool testConstruct(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (!argCount || !NPVARIANT_IS_OBJECT(args[0])) |
| return false; |
| |
| return browser->construct( |
| obj->npp, NPVARIANT_TO_OBJECT(args[0]), args + 1, argCount - 1, result); |
| } |
| |
| // Invoke a script callback to get a script NPObject. Then call a method on the |
| // script NPObject passing it a freshly created NPObject. |
| static bool testScriptObjectInvoke(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 2 || !NPVARIANT_IS_STRING(args[0]) || |
| !NPVARIANT_IS_STRING(args[1])) |
| return false; |
| NPObject* windowScriptObject; |
| browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject); |
| |
| // Arg1 is the name of the callback |
| NPUTF8* callbackString = createCStringFromNPVariant(&args[0]); |
| NPIdentifier callbackIdentifier = |
| browser->getstringidentifier(callbackString); |
| free(callbackString); |
| |
| // Invoke a callback that returns a script object |
| NPVariant object_result; |
| browser->invoke(obj->npp, |
| windowScriptObject, |
| callbackIdentifier, |
| &args[1], |
| 1, |
| &object_result); |
| |
| // Script object returned |
| if (!NPVARIANT_IS_OBJECT(object_result)) { |
| browser->releasevariantvalue(&object_result); |
| return false; |
| } |
| NPObject* script_object = NPVARIANT_TO_OBJECT(object_result); |
| |
| // Arg2 is the name of the method to be called on the script object |
| NPUTF8* object_method_string = createCStringFromNPVariant(&args[1]); |
| NPIdentifier object_method = |
| browser->getstringidentifier(object_method_string); |
| free(object_method_string); |
| |
| // Create a fresh NPObject to be passed as an argument |
| NPObject* object_arg = browser->createobject(obj->npp, obj->header._class); |
| |
| NPVariant invoke_args[1]; |
| OBJECT_TO_NPVARIANT(object_arg, invoke_args[0]); |
| |
| // Invoke the script method |
| NPVariant object_method_result; |
| browser->invoke(obj->npp, |
| script_object, |
| object_method, |
| invoke_args, |
| 1, |
| &object_method_result); |
| |
| browser->releasevariantvalue(&object_result); |
| VOID_TO_NPVARIANT(*result); |
| if (NPVARIANT_IS_OBJECT(object_method_result)) { |
| // Now return the callbacks return value back to our caller. |
| // BUG 897451: This should be the same as the |
| // windowScriptObject, but its not (in Chrome) - or at least, it |
| // has a different refcount. This means Chrome will delete the |
| // object before returning it and the calling JS gets a garbage |
| // value. Firefox handles it fine. |
| OBJECT_TO_NPVARIANT(NPVARIANT_TO_OBJECT(object_method_result), *result); |
| } else { |
| browser->releasevariantvalue(&object_method_result); |
| VOID_TO_NPVARIANT(*result); |
| } |
| |
| browser->releaseobject(object_arg); |
| |
| return true; |
| } |
| |
| // Helper function to notify the layout test controller that the test completed. |
| void notifyTestCompletion(NPP npp, NPObject* object) { |
| NPVariant result; |
| NPString script; |
| script.UTF8Characters = "javascript:window.testRunner.notifyDone();"; |
| script.UTF8Length = strlen("javascript:window.testRunner.notifyDone();"); |
| browser->evaluate(npp, object, &script, &result); |
| browser->releasevariantvalue(&result); |
| } |
| |
| bool testDocumentOpen(NPP npp) { |
| NPIdentifier documentId = browser->getstringidentifier("document"); |
| NPIdentifier openId = browser->getstringidentifier("open"); |
| |
| NPObject* windowObject = 0; |
| browser->getvalue(npp, NPNVWindowNPObject, &windowObject); |
| if (!windowObject) |
| return false; |
| |
| NPVariant docVariant; |
| browser->getproperty(npp, windowObject, documentId, &docVariant); |
| if (docVariant.type != NPVariantType_Object) { |
| browser->releaseobject(windowObject); |
| return false; |
| } |
| |
| NPObject* documentObject = NPVARIANT_TO_OBJECT(docVariant); |
| |
| NPVariant openArgs[2]; |
| STRINGZ_TO_NPVARIANT("text/html", openArgs[0]); |
| STRINGZ_TO_NPVARIANT("_blank", openArgs[1]); |
| |
| NPVariant result; |
| if (!browser->invoke(npp, documentObject, openId, openArgs, 2, &result)) { |
| browser->releaseobject(windowObject); |
| browser->releaseobject(documentObject); |
| return false; |
| } |
| |
| browser->releaseobject(documentObject); |
| |
| if (result.type != NPVariantType_Object) { |
| browser->releaseobject(windowObject); |
| browser->releasevariantvalue(&result); |
| return false; |
| } |
| |
| pluginLogWithWindowObject(windowObject, npp, "PLUGIN: DOCUMENT OPEN SUCCESS"); |
| notifyTestCompletion(npp, result.value.objectValue); |
| browser->releaseobject(result.value.objectValue); |
| browser->releaseobject(windowObject); |
| return true; |
| } |
| |
| bool testWindowOpen(NPP npp) { |
| NPIdentifier openId = browser->getstringidentifier("open"); |
| |
| NPObject* windowObject = 0; |
| browser->getvalue(npp, NPNVWindowNPObject, &windowObject); |
| if (!windowObject) |
| return false; |
| |
| NPVariant openArgs[2]; |
| STRINGZ_TO_NPVARIANT("about:blank", openArgs[0]); |
| STRINGZ_TO_NPVARIANT("_blank", openArgs[1]); |
| |
| NPVariant result; |
| if (!browser->invoke(npp, windowObject, openId, openArgs, 2, &result)) { |
| browser->releaseobject(windowObject); |
| return false; |
| } |
| |
| if (result.type != NPVariantType_Object) { |
| browser->releaseobject(windowObject); |
| browser->releasevariantvalue(&result); |
| return false; |
| } |
| |
| pluginLogWithWindowObject(windowObject, npp, "PLUGIN: WINDOW OPEN SUCCESS"); |
| notifyTestCompletion(npp, result.value.objectValue); |
| browser->releaseobject(result.value.objectValue); |
| browser->releaseobject(windowObject); |
| return true; |
| } |
| |
| static bool testSetStatus(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| char* message = 0; |
| if (argCount && NPVARIANT_IS_STRING(args[0])) { |
| NPString statusString = NPVARIANT_TO_STRING(args[0]); |
| message = toCString(statusString); |
| } |
| |
| browser->status(obj->npp, message); |
| |
| free(message); |
| return true; |
| } |
| |
| static bool testResizeTo(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| VOID_TO_NPVARIANT(*result); |
| |
| NPObject* windowObject; |
| if (NPERR_NO_ERROR != |
| browser->getvalue(obj->npp, NPNVWindowNPObject, &windowObject)) |
| return false; |
| |
| NPVariant callResult; |
| if (browser->invoke(obj->npp, |
| windowObject, |
| browser->getstringidentifier("resizePlugin"), |
| args, |
| argCount, |
| &callResult)) |
| browser->releasevariantvalue(&callResult); |
| |
| // Force layout. |
| if (browser->getproperty(obj->npp, |
| windowObject, |
| browser->getstringidentifier("pageYOffset"), |
| &callResult)) |
| browser->releasevariantvalue(&callResult); |
| |
| return true; |
| } |
| |
| static bool normalizeOverride(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| VOID_TO_NPVARIANT(*result); |
| |
| NPObject* windowObject; |
| if (NPERR_NO_ERROR != |
| browser->getvalue(obj->npp, NPNVWindowNPObject, &windowObject)) |
| return false; |
| |
| NPVariant callResult; |
| if (browser->invoke(obj->npp, |
| windowObject, |
| browser->getstringidentifier("pluginCallback"), |
| args, |
| argCount, |
| &callResult)) |
| browser->releasevariantvalue(&callResult); |
| |
| return true; |
| } |
| |
| static bool invalidateRect(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 4) |
| return false; |
| |
| NPRect rect; |
| rect.left = static_cast<uint16_t>(NPVARIANT_TO_DOUBLE(args[0])); |
| rect.top = static_cast<uint16_t>(NPVARIANT_TO_DOUBLE(args[1])); |
| rect.right = static_cast<uint16_t>(NPVARIANT_TO_DOUBLE(args[2])); |
| rect.bottom = static_cast<uint16_t>(NPVARIANT_TO_DOUBLE(args[3])); |
| |
| browser->invalidaterect(obj->npp, &rect); |
| return true; |
| } |
| |
| static bool objectsAreSame(PluginObject* obj, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| if (argCount != 2 || !NPVARIANT_IS_OBJECT(args[0]) || |
| !NPVARIANT_IS_OBJECT(args[1])) |
| return false; |
| |
| BOOLEAN_TO_NPVARIANT( |
| NPVARIANT_TO_OBJECT(args[0]) == NPVARIANT_TO_OBJECT(args[1]), *result); |
| return true; |
| } |
| |
| static bool pluginInvoke(NPObject* header, |
| NPIdentifier name, |
| const NPVariant* args, |
| uint32_t argCount, |
| NPVariant* result) { |
| PluginObject* plugin = reinterpret_cast<PluginObject*>(header); |
| if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD]) |
| return testCallback(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD_RETURN]) |
| return testCallbackReturn(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_GETURL]) |
| return getURL(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_DOM_ACCESS]) |
| return testDOMAccess(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_GET_URL_NOTIFY]) |
| return getURLNotify(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_INVOKE_DEFAULT]) |
| return testInvokeDefault(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_ENUMERATE]) |
| return testEnumerate(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_DESTROY_STREAM]) |
| return destroyStream(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_GETINTIDENTIFIER]) |
| return testGetIntIdentifier(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_EVALUATE]) |
| return testEvaluate(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY]) |
| return testGetProperty(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY_RETURN_VALUE]) |
| return testGetPropertyReturnValue(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_HAS_PROPERTY]) |
| return testHasProperty(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_HAS_METHOD]) |
| return testHasMethod(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_IDENTIFIER_TO_STRING]) |
| return testIdentifierToString(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_IDENTIFIER_TO_INT]) |
| return testIdentifierToInt(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_PASS_TEST_OBJECT]) |
| return testPassTestObject(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_POSTURL_FILE]) |
| return testPostURLFile(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_CONSTRUCT]) |
| return testConstruct(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_SCRIPT_OBJECT_INVOKE]) |
| return testScriptObjectInvoke(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_THROW_EXCEPTION_METHOD]) { |
| browser->setexception(header, "plugin object testThrowException SUCCESS"); |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_TEST_FAIL_METHOD]) { |
| NPObject* windowScriptObject; |
| browser->getvalue(plugin->npp, NPNVWindowNPObject, &windowScriptObject); |
| browser->invoke( |
| plugin->npp, windowScriptObject, name, args, argCount, result); |
| return false; |
| } |
| if (name == pluginMethodIdentifiers[ID_TEST_CLONE_OBJECT]) { |
| NPObject* new_object = |
| browser->createobject(plugin->npp, plugin->header._class); |
| assert(new_object->referenceCount == 1); |
| OBJECT_TO_NPVARIANT(new_object, *result); |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_TEST_CREATE_TEST_OBJECT]) { |
| NPObject* testObject = |
| browser->createobject(plugin->npp, content::GetTestClass()); |
| assert(testObject->referenceCount == 1); |
| OBJECT_TO_NPVARIANT(testObject, *result); |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_DESTROY_NULL_STREAM]) |
| return destroyNullStream(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_RELOAD_PLUGINS_NO_PAGES]) { |
| browser->reloadplugins(false); |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_TEST_RELOAD_PLUGINS_AND_PAGES]) { |
| browser->reloadplugins(true); |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_TEST_GET_BROWSER_PROPERTY]) { |
| browser->getproperty(plugin->npp, |
| NPVARIANT_TO_OBJECT(args[0]), |
| stringVariantToIdentifier(args[1]), |
| result); |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_TEST_SET_BROWSER_PROPERTY]) { |
| browser->setproperty(plugin->npp, |
| NPVARIANT_TO_OBJECT(args[0]), |
| stringVariantToIdentifier(args[1]), |
| &args[2]); |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_REMEMBER]) { |
| if (plugin->rememberedObject) |
| browser->releaseobject(plugin->rememberedObject); |
| plugin->rememberedObject = NPVARIANT_TO_OBJECT(args[0]); |
| browser->retainobject(plugin->rememberedObject); |
| VOID_TO_NPVARIANT(*result); |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_GET_REMEMBERED_OBJECT]) { |
| assert(plugin->rememberedObject); |
| browser->retainobject(plugin->rememberedObject); |
| OBJECT_TO_NPVARIANT(plugin->rememberedObject, *result); |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_GET_AND_FORGET_REMEMBERED_OBJECT]) { |
| assert(plugin->rememberedObject); |
| OBJECT_TO_NPVARIANT(plugin->rememberedObject, *result); |
| plugin->rememberedObject = 0; |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_REF_COUNT]) { |
| uint32_t refCount = NPVARIANT_TO_OBJECT(args[0])->referenceCount; |
| INT32_TO_NPVARIANT(refCount, *result); |
| return true; |
| } |
| if (name == pluginMethodIdentifiers[ID_SET_STATUS]) |
| return testSetStatus(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_RESIZE_TO]) |
| return testResizeTo(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_NORMALIZE]) |
| return normalizeOverride(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_INVALIDATE_RECT]) |
| return invalidateRect(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_OBJECTS_ARE_SAME]) |
| return objectsAreSame(plugin, args, argCount, result); |
| if (name == pluginMethodIdentifiers[ID_TEST_DELETE_WITHIN_INVOKE]) { |
| NPObject* newObject = |
| browser->createobject(plugin->npp, plugin->header._class); |
| OBJECT_TO_NPVARIANT(newObject, *result); |
| callDeletePlugin( |
| header, name, pluginMethodIdentifiers[ID_TEST_DELETE_WITHIN_INVOKE]); |
| return true; |
| } |
| return false; |
| } |
| |
| static void pluginInvalidate(NPObject* header) { |
| PluginObject* plugin = reinterpret_cast<PluginObject*>(header); |
| plugin->testObject = 0; |
| plugin->rememberedObject = 0; |
| } |
| |
| static NPObject* pluginAllocate(NPP npp, NPClass* theClass) { |
| PluginObject* newInstance = (PluginObject*)malloc(sizeof(PluginObject)); |
| |
| if (!identifiersInitialized) { |
| identifiersInitialized = true; |
| initializeIdentifiers(); |
| } |
| |
| newInstance->pluginTest = 0; |
| newInstance->npp = npp; |
| newInstance->testObject = browser->createobject(npp, content::GetTestClass()); |
| newInstance->rememberedObject = 0; |
| newInstance->eventLogging = false; |
| newInstance->onStreamLoad = 0; |
| newInstance->onStreamDestroy = 0; |
| newInstance->onDestroy = 0; |
| newInstance->onURLNotify = 0; |
| newInstance->onSetWindow = 0; |
| newInstance->onPaintEvent = 0; |
| newInstance->logDestroy = false; |
| newInstance->logSetWindow = false; |
| newInstance->returnErrorFromNewStream = false; |
| newInstance->returnNegativeOneFromWrite = false; |
| newInstance->stream = 0; |
| |
| newInstance->firstUrl = 0; |
| newInstance->firstHeaders = 0; |
| newInstance->lastUrl = 0; |
| newInstance->lastHeaders = 0; |
| |
| newInstance->testGetURLOnDestroy = false; |
| newInstance->testWindowOpen = false; |
| newInstance->testKeyboardFocusForPlugins = false; |
| |
| newInstance->mouseDownForEvaluateScript = false; |
| newInstance->evaluateScriptOnMouseDownOrKeyDown = 0; |
| |
| return (NPObject*)newInstance; |
| } |
| |
| static void pluginDeallocate(NPObject* header) { |
| PluginObject* plugin = reinterpret_cast<PluginObject*>(header); |
| delete plugin->pluginTest; |
| if (plugin->testObject) |
| browser->releaseobject(plugin->testObject); |
| if (plugin->rememberedObject) |
| browser->releaseobject(plugin->rememberedObject); |
| |
| free(plugin->firstUrl); |
| free(plugin->firstHeaders); |
| free(plugin->lastUrl); |
| free(plugin->lastHeaders); |
| free(plugin); |
| } |
| |
| void handleCallback(PluginObject* object, |
| const char* url, |
| NPReason reason, |
| void* notifyData) { |
| assert(object); |
| |
| NPVariant args[2]; |
| |
| NPObject* windowScriptObject; |
| browser->getvalue(object->npp, NPNVWindowNPObject, &windowScriptObject); |
| |
| NPIdentifier callbackIdentifier = notifyData; |
| |
| INT32_TO_NPVARIANT(reason, args[0]); |
| |
| char* strHdr = 0; |
| if (object->firstUrl && object->firstHeaders && object->lastUrl && |
| object->lastHeaders) { |
| // Format expected by JavaScript validator: four fields separated by \n\n: |
| // First URL; first header block; last URL; last header block. |
| // Note that header blocks already end with \n due to how NPStream::headers |
| // works. |
| int len = strlen(object->firstUrl) + 2 + strlen(object->firstHeaders) + 1 + |
| strlen(object->lastUrl) + 2 + strlen(object->lastHeaders) + 1; |
| strHdr = (char*)malloc(len + 1); |
| snprintf(strHdr, |
| len + 1, |
| "%s\n\n%s\n%s\n\n%s\n", |
| object->firstUrl, |
| object->firstHeaders, |
| object->lastUrl, |
| object->lastHeaders); |
| STRINGN_TO_NPVARIANT(strHdr, len, args[1]); |
| } else |
| NULL_TO_NPVARIANT(args[1]); |
| |
| NPVariant browserResult; |
| if (browser->invoke(object->npp, |
| windowScriptObject, |
| callbackIdentifier, |
| args, |
| 2, |
| &browserResult)) |
| browser->releasevariantvalue(&browserResult); |
| |
| free(strHdr); |
| } |
| |
| void notifyStream(PluginObject* object, const char* url, const char* headers) { |
| if (!object->firstUrl) { |
| if (url) |
| object->firstUrl = base::strdup(url); |
| if (headers) |
| object->firstHeaders = base::strdup(headers); |
| } else { |
| free(object->lastUrl); |
| free(object->lastHeaders); |
| object->lastUrl = (url ? base::strdup(url) : 0); |
| object->lastHeaders = (headers ? base::strdup(headers) : 0); |
| } |
| } |
| |
| void testNPRuntime(NPP npp) { |
| NPObject* windowScriptObject; |
| browser->getvalue(npp, NPNVWindowNPObject, &windowScriptObject); |
| |
| // Invoke |
| NPIdentifier testNPInvoke = browser->getstringidentifier("testNPInvoke"); |
| NPVariant args[7]; |
| |
| VOID_TO_NPVARIANT(args[0]); |
| NULL_TO_NPVARIANT(args[1]); |
| BOOLEAN_TO_NPVARIANT(true, args[2]); |
| INT32_TO_NPVARIANT(242, args[3]); |
| DOUBLE_TO_NPVARIANT(242.242, args[4]); |
| STRINGZ_TO_NPVARIANT("Hello, World", args[5]); |
| OBJECT_TO_NPVARIANT(windowScriptObject, args[6]); |
| |
| NPVariant result; |
| if (browser->invoke(npp, windowScriptObject, testNPInvoke, args, 7, &result)) |
| browser->releasevariantvalue(&result); |
| |
| browser->releaseobject(windowScriptObject); |
| } |
