src/third_party/WebKit/Source/testing/plugin/PluginObject.cpp

   1 /*
   2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
   3  * Copyright (C) 2009 Holger Hans Peter Freyther
   4  * Copyright (C) 2010 Collabora Ltd.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "PluginObject.h"
  29
  30 #include "PluginTest.h"
  31 #include "TestObject.h"
  32 #include <assert.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 // Helper function which takes in the plugin window object for logging to the console object.
  38 static void pluginLogWithWindowObject(NPObject* windowObject, NPP instance, const char* message)
  39 {
  40     NPVariant consoleVariant;
  41     if (!browser->getproperty(instance, windowObject, browser->getstringidentifier("console"), &consoleVariant)) {
  42         fprintf(stderr, "Failed to retrieve console object while logging: %s\n", message);
  43         return;
  44     }
  45
  46     NPObject* consoleObject = NPVARIANT_TO_OBJECT(consoleVariant);
  47
  48     NPVariant messageVariant;
  49     STRINGZ_TO_NPVARIANT(message, messageVariant);
  50
  51     NPVariant result;
  52     if (!browser->invoke(instance, consoleObject, browser->getstringidentifier("log"), &messageVariant, 1, &result)) {
  53         fprintf(stderr, "Failed to invoke console.log while logging: %s\n", message);
  54         browser->releaseobject(consoleObject);
  55         return;
  56     }
  57
  58     browser->releasevariantvalue(&result);
  59     browser->releaseobject(consoleObject);
  60 }
  61
  62 void pluginLogWithArguments(NPP instance, const char* format, va_list args)
  63 {
  64     const size_t messageBufferSize = 2048;
  65     char message[messageBufferSize] = "PLUGIN: ";
  66     int messageLength = sizeof("PLUGIN: ") - 1;
  67     messageLength += vsnprintf(message + messageLength, messageBufferSize - 1 - messageLength, format, args);
  68     message[messageLength] = '\0';
  69
  70     NPObject* windowObject = 0;
  71     NPError error = browser->getvalue(instance, NPNVWindowNPObject, &windowObject);
  72     if (error != NPERR_NO_ERROR) {
  73         fprintf(stderr, "Failed to retrieve window object while logging: %s\n", message);
  74         return;
  75     }
  76
  77     pluginLogWithWindowObject(windowObject, instance, message);
  78     browser->releaseobject(windowObject);
  79 }
  80
  81 // Helper function to log to the console object.
  82 void pluginLog(NPP instance, const char* format, ...)
  83 {
  84     va_list args;
  85     va_start(args, format);
  86     pluginLogWithArguments(instance, format, args);
  87     va_end(args);
  88 }
  89
  90 static void pluginInvalidate(NPObject*);
  91 static bool pluginHasProperty(NPObject*, NPIdentifier name);
  92 static bool pluginHasMethod(NPObject*, NPIdentifier name);
  93 static bool pluginGetProperty(NPObject*, NPIdentifier name, NPVariant*);
  94 static bool pluginSetProperty(NPObject*, NPIdentifier name, const NPVariant*);
  95 static bool pluginInvoke(NPObject*, NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result);
  96 static NPObject* pluginAllocate(NPP npp, NPClass*);
  97 static void pluginDeallocate(NPObject*);
  98
  99 NPNetscapeFuncs* browser;
 100 NPPluginFuncs* pluginFunctions;
 101
 102 static NPClass pluginClass_ = {
 103     NP_CLASS_STRUCT_VERSION,
 104     pluginAllocate,
 105     pluginDeallocate,
 106     pluginInvalidate,
 107     pluginHasMethod,
 108     pluginInvoke,
 109     0, // NPClass::invokeDefault,
 110     pluginHasProperty,
 111     pluginGetProperty,
 112     pluginSetProperty,
 113     0, // NPClass::removeProperty
 114     0, // NPClass::enumerate
 115     0, // NPClass::construct
 116 };
 117
 118 NPClass* createPluginClass(void)
 119 {
 120     NPClass* pluginClass = new NPClass;
 121     *pluginClass = pluginClass_;
 122     return pluginClass;
 123 }
 124
 125 static bool identifiersInitialized = false;
 126
 127 enum {
 128     ID_PROPERTY_PROPERTY = 0,
 129     ID_PROPERTY_EVENT_LOGGING,
 130     ID_PROPERTY_HAS_STREAM,
 131     ID_PROPERTY_TEST_OBJECT,
 132     ID_PROPERTY_LOG_DESTROY,
 133     ID_PROPERTY_RETURN_ERROR_FROM_NEWSTREAM,
 134     ID_PROPERTY_RETURN_NEGATIVE_ONE_FROM_WRITE,
 135     ID_PROPERTY_THROW_EXCEPTION_PROPERTY,
 136     ID_LAST_SET_WINDOW_ARGUMENTS,
 137     ID_PROPERTY_WINDOWED_PLUGIN,
 138     ID_PROPERTY_TEST_OBJECT_COUNT,
 139     ID_PROPERTY_DELETE_IN_GET_PROPERTY,
 140     ID_PROPERTY_DELETE_IN_HAS_PROPERTY_RETURN_TRUE,
 141     ID_PROPERTY_DELETE_IN_SET_PROPERTY,
 142     NUM_PROPERTY_IDENTIFIERS
 143 };
 144
 145 static NPIdentifier pluginPropertyIdentifiers[NUM_PROPERTY_IDENTIFIERS];
 146 static const NPUTF8 *pluginPropertyIdentifierNames[NUM_PROPERTY_IDENTIFIERS] = {
 147     "property",
 148     "eventLoggingEnabled",
 149     "hasStream",
 150     "testObject",
 151     "logDestroy",
 152     "returnErrorFromNewStream",
 153     "returnNegativeOneFromWrite",
 154     "testThrowExceptionProperty",
 155     "lastSetWindowArguments",
 156     "windowedPlugin",
 157     "testObjectCount",
 158     "deletePluginInGetProperty",
 159     "deletePluginInHasPropertyReturnTrue",
 160     "deletePluginInSetProperty"
 161 };
 162
 163 enum {
 164     ID_TEST_CALLBACK_METHOD = 0,
 165     ID_TEST_CALLBACK_METHOD_RETURN,
 166     ID_TEST_GETURL,
 167     ID_TEST_DOM_ACCESS,
 168     ID_TEST_GET_URL_NOTIFY,
 169     ID_TEST_INVOKE_DEFAULT,
 170     ID_DESTROY_STREAM,
 171     ID_TEST_ENUMERATE,
 172     ID_TEST_GETINTIDENTIFIER,
 173     ID_TEST_GET_PROPERTY,
 174     ID_TEST_HAS_PROPERTY,
 175     ID_TEST_HAS_METHOD,
 176     ID_TEST_EVALUATE,
 177     ID_TEST_GET_PROPERTY_RETURN_VALUE,
 178     ID_TEST_IDENTIFIER_TO_STRING,
 179     ID_TEST_IDENTIFIER_TO_INT,
 180     ID_TEST_PASS_TEST_OBJECT,
 181     ID_TEST_POSTURL_FILE,
 182     ID_TEST_CONSTRUCT,
 183     ID_TEST_THROW_EXCEPTION_METHOD,
 184     ID_TEST_FAIL_METHOD,
 185     ID_TEST_CLONE_OBJECT,
 186     ID_TEST_SCRIPT_OBJECT_INVOKE,
 187     ID_TEST_CREATE_TEST_OBJECT,
 188     ID_DESTROY_NULL_STREAM,
 189     ID_TEST_RELOAD_PLUGINS_NO_PAGES,
 190     ID_TEST_RELOAD_PLUGINS_AND_PAGES,
 191     ID_TEST_GET_BROWSER_PROPERTY,
 192     ID_TEST_SET_BROWSER_PROPERTY,
 193     ID_REMEMBER,
 194     ID_GET_REMEMBERED_OBJECT,
 195     ID_GET_AND_FORGET_REMEMBERED_OBJECT,
 196     ID_REF_COUNT,
 197     ID_SET_STATUS,
 198     ID_RESIZE_TO,
 199     ID_NORMALIZE,
 200     ID_INVALIDATE_RECT,
 201     ID_OBJECTS_ARE_SAME,
 202     ID_TEST_DELETE_WITHIN_INVOKE,
 203     NUM_METHOD_IDENTIFIERS
 204 };
 205
 206 static NPIdentifier pluginMethodIdentifiers[NUM_METHOD_IDENTIFIERS];
 207 static const NPUTF8 *pluginMethodIdentifierNames[NUM_METHOD_IDENTIFIERS] = {
 208     "testCallback",
 209     "testCallbackReturn",
 210     "getURL",
 211     "testDOMAccess",
 212     "getURLNotify",
 213     "testInvokeDefault",
 214     "destroyStream",
 215     "testEnumerate",
 216     "testGetIntIdentifier",
 217     "testGetProperty",
 218     "testHasProperty",
 219     "testHasMethod",
 220     "testEvaluate",
 221     "testGetPropertyReturnValue",
 222     "testIdentifierToString",
 223     "testIdentifierToInt",
 224     "testPassTestObject",
 225     "testPostURLFile",
 226     "testConstruct",
 227     "testThrowException",
 228     "testFail",
 229     "testCloneObject",
 230     "testScriptObjectInvoke",
 231     "testCreateTestObject",
 232     "destroyNullStream",
 233     "reloadPluginsNoPages",
 234     "reloadPluginsAndPages",
 235     "testGetBrowserProperty",
 236     "testSetBrowserProperty",
 237     "remember",
 238     "getRememberedObject",
 239     "getAndForgetRememberedObject",
 240     "refCount",
 241     "setStatus",
 242     "resizeTo",
 243     "normalize",
 244     "invalidateRect",
 245     "objectsAreSame",
 246     "testDeleteWithinInvoke"
 247 };
 248
 249 static NPUTF8* createCStringFromNPVariant(const NPVariant* variant)
 250 {
 251     size_t length = NPVARIANT_TO_STRING(*variant).UTF8Length;
 252     NPUTF8* result = (NPUTF8*)malloc(length + 1);
 253     memcpy(result, NPVARIANT_TO_STRING(*variant).UTF8Characters, length);
 254     result[length] = '\0';
 255     return result;
 256 }
 257
 258 static void initializeIdentifiers(void)
 259 {
 260     browser->getstringidentifiers(pluginPropertyIdentifierNames, NUM_PROPERTY_IDENTIFIERS, pluginPropertyIdentifiers);
 261     browser->getstringidentifiers(pluginMethodIdentifierNames, NUM_METHOD_IDENTIFIERS, pluginMethodIdentifiers);
 262 }
 263
 264 static bool callDeletePlugin(NPObject* obj, NPIdentifier name, NPIdentifier identifierToMatch)
 265 {
 266     if (name != identifierToMatch)
 267         return false;
 268
 269     PluginObject* plugin = reinterpret_cast<PluginObject*>(obj);
 270     NPObject* windowScriptObject;
 271     browser->getvalue(plugin->npp, NPNVWindowNPObject, &windowScriptObject);
 272
 273     NPIdentifier callbackIdentifier = browser->getstringidentifier("deletePlugin");
 274     NPVariant browserResult;
 275     if (browser->invoke(plugin->npp, windowScriptObject, callbackIdentifier, 0, 0, &browserResult))
 276         browser->releasevariantvalue(&browserResult);
 277     return true;
 278 }
 279
 280 static bool pluginHasProperty(NPObject *obj, NPIdentifier name)
 281 {
 282     if (callDeletePlugin(obj, name, browser->getstringidentifier("deletePluginInHasPropertyReturnFalse")))
 283         return false;
 284
 285     callDeletePlugin(obj, name, pluginPropertyIdentifiers[ID_PROPERTY_DELETE_IN_HAS_PROPERTY_RETURN_TRUE]);
 286
 287     for (int i = 0; i < NUM_PROPERTY_IDENTIFIERS; i++)
 288         if (name == pluginPropertyIdentifiers[i])
 289             return true;
 290     return false;
 291 }
 292
 293 static bool pluginHasMethod(NPObject *obj, NPIdentifier name)
 294 {
 295     if (callDeletePlugin(obj, name, browser->getstringidentifier("deletePluginInHasMethod")))
 296         return true;
 297
 298     for (int i = 0; i < NUM_METHOD_IDENTIFIERS; i++)
 299         if (name == pluginMethodIdentifiers[i])
 300             return true;
 301     return false;
 302 }
 303
 304 static bool pluginGetProperty(NPObject* obj, NPIdentifier name, NPVariant* result)
 305 {
 306     PluginObject* plugin = reinterpret_cast<PluginObject*>(obj);
 307     if (name == pluginPropertyIdentifiers[ID_PROPERTY_PROPERTY]) {
 308         static const char* originalString = "property";
 309         char* buf = static_cast<char*>(browser->memalloc(strlen(originalString) + 1));
 310         strcpy(buf, originalString);
 311         STRINGZ_TO_NPVARIANT(buf, *result);
 312         return true;
 313     }
 314     if (name == pluginPropertyIdentifiers[ID_PROPERTY_EVENT_LOGGING]) {
 315         BOOLEAN_TO_NPVARIANT(plugin->eventLogging, *result);
 316         return true;
 317     }
 318     if (name == pluginPropertyIdentifiers[ID_PROPERTY_LOG_DESTROY]) {
 319         BOOLEAN_TO_NPVARIANT(plugin->logDestroy, *result);
 320         return true;
 321     }
 322     if (name == pluginPropertyIdentifiers[ID_PROPERTY_HAS_STREAM]) {
 323         BOOLEAN_TO_NPVARIANT(plugin->stream, *result);
 324         return true;
 325     }
 326     if (name == pluginPropertyIdentifiers[ID_PROPERTY_TEST_OBJECT]) {
 327         NPObject* testObject = plugin->testObject;
 328         browser->retainobject(testObject);
 329         OBJECT_TO_NPVARIANT(testObject, *result);
 330         return true;
 331     }
 332     if (name == pluginPropertyIdentifiers[ID_PROPERTY_RETURN_ERROR_FROM_NEWSTREAM]) {
 333         BOOLEAN_TO_NPVARIANT(plugin->returnErrorFromNewStream, *result);
 334         return true;
 335     }
 336     if (name == pluginPropertyIdentifiers[ID_PROPERTY_RETURN_NEGATIVE_ONE_FROM_WRITE]) {
 337         BOOLEAN_TO_NPVARIANT(plugin->returnNegativeOneFromWrite, *result);
 338         return true;
 339     }
 340     if (name == pluginPropertyIdentifiers[ID_PROPERTY_THROW_EXCEPTION_PROPERTY]) {
 341         browser->setexception(obj, "plugin object testThrowExceptionProperty SUCCESS");
 342         return true;
 343     }
 344     if (name == pluginPropertyIdentifiers[ID_LAST_SET_WINDOW_ARGUMENTS]) {
 345         char* buf = static_cast<char*>(browser->memalloc(256));
 346         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,
 347             plugin->lastWindow.clipRect.left, plugin->lastWindow.clipRect.top, plugin->lastWindow.clipRect.right - plugin->lastWindow.clipRect.left, plugin->lastWindow.clipRect.bottom - plugin->lastWindow.clipRect.top);
 348
 349         STRINGZ_TO_NPVARIANT(buf, *result);
 350         return true;
 351     }
 352     if (name == pluginPropertyIdentifiers[ID_PROPERTY_TEST_OBJECT_COUNT]) {
 353         INT32_TO_NPVARIANT(getTestObjectCount(), *result);
 354         return true;
 355     }
 356
 357     if (name == pluginPropertyIdentifiers[ID_PROPERTY_DELETE_IN_GET_PROPERTY]) {
 358         browser->retainobject(obj);
 359         callDeletePlugin(obj, name, pluginPropertyIdentifiers[ID_PROPERTY_DELETE_IN_GET_PROPERTY]);
 360         NPObject* testObject = plugin->testObject;
 361         browser->retainobject(testObject);
 362         OBJECT_TO_NPVARIANT(testObject, *result);
 363         browser->releaseobject(obj);
 364         return true;
 365     }
 366
 367     return false;
 368 }
 369
 370 static bool pluginSetProperty(NPObject* obj, NPIdentifier name, const NPVariant* variant)
 371 {
 372     PluginObject* plugin = reinterpret_cast<PluginObject*>(obj);
 373     if (callDeletePlugin(obj, name, pluginPropertyIdentifiers[ID_PROPERTY_DELETE_IN_SET_PROPERTY]))
 374         return true;
 375
 376     if (name == pluginPropertyIdentifiers[ID_PROPERTY_EVENT_LOGGING]) {
 377         plugin->eventLogging = NPVARIANT_TO_BOOLEAN(*variant);
 378         return true;
 379     }
 380     if (name == pluginPropertyIdentifiers[ID_PROPERTY_LOG_DESTROY]) {
 381         plugin->logDestroy = NPVARIANT_TO_BOOLEAN(*variant);
 382         return true;
 383     }
 384     if (name == pluginPropertyIdentifiers[ID_PROPERTY_RETURN_ERROR_FROM_NEWSTREAM]) {
 385         plugin->returnErrorFromNewStream = NPVARIANT_TO_BOOLEAN(*variant);
 386         return true;
 387     }
 388     if (name == pluginPropertyIdentifiers[ID_PROPERTY_RETURN_NEGATIVE_ONE_FROM_WRITE]) {
 389         plugin->returnNegativeOneFromWrite = NPVARIANT_TO_BOOLEAN(*variant);
 390         return true;
 391     }
 392     if (name == pluginPropertyIdentifiers[ID_PROPERTY_THROW_EXCEPTION_PROPERTY]) {
 393         browser->setexception(obj, "plugin object testThrowExceptionProperty SUCCESS");
 394         return true;
 395     }
 396     if (name == pluginPropertyIdentifiers[ID_PROPERTY_WINDOWED_PLUGIN]) {
 397         browser->setvalue(plugin->npp, NPPVpluginWindowBool, (void *)NPVARIANT_TO_BOOLEAN(*variant));
 398         return true;
 399     }
 400
 401     return false;
 402 }
 403
 404 static bool testDOMAccess(PluginObject* obj, const NPVariant*, uint32_t, NPVariant* result)
 405 {
 406     // Get plug-in's DOM element
 407     NPObject* elementObject;
 408     if (browser->getvalue(obj->npp, NPNVPluginElementNPObject, &elementObject) == NPERR_NO_ERROR) {
 409         // Get style
 410         NPVariant styleVariant;
 411         NPIdentifier styleIdentifier = browser->getstringidentifier("style");
 412         if (browser->getproperty(obj->npp, elementObject, styleIdentifier, &styleVariant) && NPVARIANT_IS_OBJECT(styleVariant)) {
 413             // Set style.border
 414             NPIdentifier borderIdentifier = browser->getstringidentifier("border");
 415             NPVariant borderVariant;
 416             STRINGZ_TO_NPVARIANT("3px solid red", borderVariant);
 417             browser->setproperty(obj->npp, NPVARIANT_TO_OBJECT(styleVariant), borderIdentifier, &borderVariant);
 418             browser->releasevariantvalue(&styleVariant);
 419         }
 420
 421         browser->releaseobject(elementObject);
 422     }
 423     VOID_TO_NPVARIANT(*result);
 424     return true;
 425 }
 426
 427 static NPIdentifier stringVariantToIdentifier(NPVariant variant)
 428 {
 429     assert(NPVARIANT_IS_STRING(variant));
 430     NPUTF8* utf8String = createCStringFromNPVariant(&variant);
 431     NPIdentifier identifier = browser->getstringidentifier(utf8String);
 432     free(utf8String);
 433     return identifier;
 434 }
 435
 436 static NPIdentifier int32VariantToIdentifier(NPVariant variant)
 437 {
 438     assert(NPVARIANT_IS_INT32(variant));
 439     int32_t integer = NPVARIANT_TO_INT32(variant);
 440     return browser->getintidentifier(integer);
 441 }
 442
 443 static NPIdentifier doubleVariantToIdentifier(NPVariant variant)
 444 {
 445     assert(NPVARIANT_IS_DOUBLE(variant));
 446     double value = NPVARIANT_TO_DOUBLE(variant);
 447     // Sadly there is no "getdoubleidentifier"
 448     int32_t integer = static_cast<int32_t>(value);
 449     return browser->getintidentifier(integer);
 450 }
 451
 452 static NPIdentifier variantToIdentifier(NPVariant variant)
 453 {
 454     if (NPVARIANT_IS_STRING(variant))
 455         return stringVariantToIdentifier(variant);
 456     if (NPVARIANT_IS_INT32(variant))
 457         return int32VariantToIdentifier(variant);
 458     if (NPVARIANT_IS_DOUBLE(variant))
 459         return doubleVariantToIdentifier(variant);
 460     return 0;
 461 }
 462
 463 static bool testIdentifierToString(PluginObject*, const NPVariant* args, uint32_t argCount, NPVariant* result)
 464 {
 465     if (argCount != 1)
 466         return true;
 467     NPIdentifier identifier = variantToIdentifier(args[0]);
 468     if (!identifier)
 469         return true;
 470     NPUTF8* utf8String = browser->utf8fromidentifier(identifier);
 471     if (!utf8String)
 472         return true;
 473     STRINGZ_TO_NPVARIANT(utf8String, *result);
 474     return true;
 475 }
 476
 477 static bool testIdentifierToInt(PluginObject*, const NPVariant* args, uint32_t argCount, NPVariant* result)
 478 {
 479     if (argCount != 1)
 480         return false;
 481     NPIdentifier identifier = variantToIdentifier(args[0]);
 482     if (!identifier)
 483         return false;
 484     int32_t integer = browser->intfromidentifier(identifier);
 485     INT32_TO_NPVARIANT(integer, *result);
 486     return true;
 487 }
 488
 489 static bool testPassTestObject(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 490 {
 491     if (argCount != 2 || !NPVARIANT_IS_STRING(args[0]))
 492         return false;
 493
 494     NPObject* windowScriptObject;
 495     browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
 496
 497     NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
 498     NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
 499     free(callbackString);
 500
 501     NPVariant browserResult;
 502     browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, &args[1], 1, &browserResult);
 503     browser->releasevariantvalue(&browserResult);
 504
 505     VOID_TO_NPVARIANT(*result);
 506     return true;
 507 }
 508
 509 static bool testCallback(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 510 {
 511     if (!argCount || !NPVARIANT_IS_STRING(args[0]))
 512         return false;
 513
 514     NPObject* windowScriptObject;
 515     browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
 516
 517     NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
 518     NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
 519     free(callbackString);
 520
 521     NPVariant browserResult;
 522     if (browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, 0, 0, &browserResult))
 523         browser->releasevariantvalue(&browserResult);
 524
 525     browser->releaseobject(windowScriptObject);
 526
 527     VOID_TO_NPVARIANT(*result);
 528     return true;
 529 }
 530
 531 static bool testCallbackReturn(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 532 {
 533     if (argCount != 1 || !NPVARIANT_IS_STRING(args[0]))
 534         return false;
 535
 536     NPObject* windowScriptObject;
 537     browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
 538
 539     NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
 540     NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
 541     free(callbackString);
 542
 543     NPVariant callbackArgs[1];
 544     OBJECT_TO_NPVARIANT(windowScriptObject, callbackArgs[0]);
 545
 546     NPVariant browserResult;
 547     browser->invoke(obj->npp, windowScriptObject, callbackIdentifier,
 548                     callbackArgs, 1, &browserResult);
 549
 550     if (NPVARIANT_IS_OBJECT(browserResult))
 551         OBJECT_TO_NPVARIANT(NPVARIANT_TO_OBJECT(browserResult), *result);
 552     else {
 553         browser->releasevariantvalue(&browserResult);
 554         VOID_TO_NPVARIANT(*result);
 555     }
 556
 557     return true;
 558 }
 559
 560 static bool getURL(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 561 {
 562     if (argCount == 2 && NPVARIANT_IS_STRING(args[0]) && NPVARIANT_IS_STRING(args[1])) {
 563         NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
 564         NPUTF8* targetString = createCStringFromNPVariant(&args[1]);
 565         NPError npErr = browser->geturl(obj->npp, urlString, targetString);
 566         free(urlString);
 567         free(targetString);
 568
 569         INT32_TO_NPVARIANT(npErr, *result);
 570         return true;
 571     }
 572     if (argCount == 1 && NPVARIANT_IS_STRING(args[0])) {
 573         NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
 574         NPError npErr = browser->geturl(obj->npp, urlString, 0);
 575         free(urlString);
 576
 577         INT32_TO_NPVARIANT(npErr, *result);
 578         return true;
 579     }
 580     return false;
 581 }
 582
 583 static bool getURLNotify(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 584 {
 585     if (argCount != 3 || !NPVARIANT_IS_STRING(args[0])
 586         || (!NPVARIANT_IS_STRING(args[1]) && !NPVARIANT_IS_NULL(args[1]))
 587         || !NPVARIANT_IS_STRING(args[2]))
 588         return false;
 589
 590     NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
 591     NPUTF8* targetString = (NPVARIANT_IS_STRING(args[1]) ? createCStringFromNPVariant(&args[1]) : 0);
 592     NPUTF8* callbackString = createCStringFromNPVariant(&args[2]);
 593
 594     NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
 595     browser->geturlnotify(obj->npp, urlString, targetString, callbackIdentifier);
 596
 597     free(urlString);
 598     free(targetString);
 599     free(callbackString);
 600
 601     VOID_TO_NPVARIANT(*result);
 602     return true;
 603 }
 604
 605 static bool testInvokeDefault(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 606 {
 607     if (!NPVARIANT_IS_OBJECT(args[0]))
 608         return false;
 609
 610     NPObject* callback = NPVARIANT_TO_OBJECT(args[0]);
 611
 612     NPVariant invokeArgs[1];
 613     NPVariant browserResult;
 614
 615     STRINGZ_TO_NPVARIANT("test", invokeArgs[0]);
 616     bool retval = browser->invokeDefault(obj->npp, callback, invokeArgs, 1, &browserResult);
 617
 618     if (retval)
 619         browser->releasevariantvalue(&browserResult);
 620
 621     BOOLEAN_TO_NPVARIANT(retval, *result);
 622     return true;
 623 }
 624
 625 static bool destroyStream(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 626 {
 627     NPError npError = browser->destroystream(obj->npp, obj->stream, NPRES_USER_BREAK);
 628     INT32_TO_NPVARIANT(npError, *result);
 629     return true;
 630 }
 631
 632 static bool destroyNullStream(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 633 {
 634     NPError npError = browser->destroystream(obj->npp, 0, NPRES_USER_BREAK);
 635     INT32_TO_NPVARIANT(npError, *result);
 636     return true;
 637 }
 638
 639 static bool testEnumerate(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 640 {
 641     if (argCount != 2 || !NPVARIANT_IS_OBJECT(args[0]) || !NPVARIANT_IS_OBJECT(args[1]))
 642         return false;
 643
 644     uint32_t count;
 645     NPIdentifier* identifiers;
 646     if (browser->enumerate(obj->npp, NPVARIANT_TO_OBJECT(args[0]), &identifiers, &count)) {
 647         NPObject* outArray = NPVARIANT_TO_OBJECT(args[1]);
 648         NPIdentifier pushIdentifier = browser->getstringidentifier("push");
 649
 650         for (uint32_t i = 0; i < count; i++) {
 651             NPUTF8* string = browser->utf8fromidentifier(identifiers[i]);
 652
 653             if (!string)
 654                 continue;
 655
 656             NPVariant args[1];
 657             STRINGZ_TO_NPVARIANT(string, args[0]);
 658             NPVariant browserResult;
 659             if (browser->invoke(obj->npp, outArray, pushIdentifier, args, 1, &browserResult))
 660                 browser->releasevariantvalue(&browserResult);
 661             browser->memfree(string);
 662         }
 663
 664         browser->memfree(identifiers);
 665     }
 666
 667     VOID_TO_NPVARIANT(*result);
 668     return true;
 669 }
 670
 671 static bool testGetIntIdentifier(PluginObject*, const NPVariant* args, uint32_t argCount, NPVariant* result)
 672 {
 673     if (argCount != 1 || !NPVARIANT_IS_DOUBLE(args[0]))
 674         return false;
 675
 676     NPIdentifier identifier = browser->getintidentifier((int)NPVARIANT_TO_DOUBLE(args[0]));
 677     INT32_TO_NPVARIANT((int32_t)(long long)identifier, *result);
 678     return true;
 679 }
 680
 681 static bool testGetProperty(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 682 {
 683     if (!argCount)
 684         return false;
 685
 686     NPObject* object;
 687     browser->getvalue(obj->npp, NPNVWindowNPObject, &object);
 688
 689     for (uint32_t i = 0; i < argCount; i++) {
 690         assert(NPVARIANT_IS_STRING(args[i]));
 691         NPUTF8* propertyString = createCStringFromNPVariant(&args[i]);
 692         NPIdentifier propertyIdentifier = browser->getstringidentifier(propertyString);
 693         free(propertyString);
 694
 695         NPVariant variant;
 696         bool retval = browser->getproperty(obj->npp, object, propertyIdentifier, &variant);
 697         browser->releaseobject(object);
 698
 699         if (!retval)
 700             break;
 701
 702         if (i + 1 < argCount) {
 703             assert(NPVARIANT_IS_OBJECT(variant));
 704             object = NPVARIANT_TO_OBJECT(variant);
 705         } else {
 706             *result = variant;
 707             return true;
 708         }
 709     }
 710
 711     VOID_TO_NPVARIANT(*result);
 712     return false;
 713 }
 714
 715 static bool testHasProperty(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 716 {
 717     if (argCount != 2 || !NPVARIANT_IS_OBJECT(args[0]) || !NPVARIANT_IS_STRING(args[1]))
 718         return false;
 719
 720     NPUTF8* propertyString = createCStringFromNPVariant(&args[1]);
 721     NPIdentifier propertyIdentifier = browser->getstringidentifier(propertyString);
 722     free(propertyString);
 723
 724     bool retval = browser->hasproperty(obj->npp, NPVARIANT_TO_OBJECT(args[0]), propertyIdentifier);
 725
 726     BOOLEAN_TO_NPVARIANT(retval, *result);
 727     return true;
 728 }
 729
 730 static bool testHasMethod(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 731 {
 732     if (argCount != 2 || !NPVARIANT_IS_OBJECT(args[0]) || !NPVARIANT_IS_STRING(args[1]))
 733         return false;
 734
 735     NPUTF8* propertyString = createCStringFromNPVariant(&args[1]);
 736     NPIdentifier propertyIdentifier = browser->getstringidentifier(propertyString);
 737     free(propertyString);
 738
 739     bool retval = browser->hasmethod(obj->npp, NPVARIANT_TO_OBJECT(args[0]), propertyIdentifier);
 740
 741     BOOLEAN_TO_NPVARIANT(retval, *result);
 742     return true;
 743 }
 744
 745 static bool testEvaluate(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 746 {
 747     if (argCount != 1 || !NPVARIANT_IS_STRING(args[0]))
 748         return false;
 749     NPObject* windowScriptObject;
 750     browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
 751
 752     NPString s = NPVARIANT_TO_STRING(args[0]);
 753
 754     bool retval = browser->evaluate(obj->npp, windowScriptObject, &s, result);
 755     browser->releaseobject(windowScriptObject);
 756     return retval;
 757 }
 758
 759 static bool testGetPropertyReturnValue(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 760 {
 761     if (argCount != 2 || !NPVARIANT_IS_OBJECT(args[0]) || !NPVARIANT_IS_STRING(args[1]))
 762         return false;
 763
 764     NPUTF8* propertyString = createCStringFromNPVariant(&args[1]);
 765     NPIdentifier propertyIdentifier = browser->getstringidentifier(propertyString);
 766     free(propertyString);
 767
 768     NPVariant variant;
 769     bool retval = browser->getproperty(obj->npp, NPVARIANT_TO_OBJECT(args[0]), propertyIdentifier, &variant);
 770     if (retval)
 771         browser->releasevariantvalue(&variant);
 772
 773     BOOLEAN_TO_NPVARIANT(retval, *result);
 774     return true;
 775 }
 776
 777 static char* toCString(const NPString& string)
 778 {
 779     char* result = static_cast<char*>(malloc(string.UTF8Length + 1));
 780     memcpy(result, string.UTF8Characters, string.UTF8Length);
 781     result[string.UTF8Length] = '\0';
 782
 783     return result;
 784 }
 785
 786 static bool testPostURLFile(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 787 {
 788     if (argCount != 4 || !NPVARIANT_IS_STRING(args[0]) || !NPVARIANT_IS_STRING(args[1]) || !NPVARIANT_IS_STRING(args[2]) || !NPVARIANT_IS_STRING(args[3]))
 789         return false;
 790
 791     NPString urlString = NPVARIANT_TO_STRING(args[0]);
 792     char* url = toCString(urlString);
 793
 794     NPString targetString = NPVARIANT_TO_STRING(args[1]);
 795     char* target = toCString(targetString);
 796
 797     NPString pathString = NPVARIANT_TO_STRING(args[2]);
 798     char* path = toCString(pathString);
 799
 800     NPString contentsString = NPVARIANT_TO_STRING(args[3]);
 801
 802     FILE* tempFile = fopen(path, "w");
 803     if (!tempFile)
 804         return false;
 805
 806     size_t written = fwrite(contentsString.UTF8Characters, contentsString.UTF8Length, 1, tempFile);
 807     fclose(tempFile);
 808     if (!written)
 809         return false;
 810
 811     NPError error = browser->posturl(obj->npp, url, target, pathString.UTF8Length, path, true);
 812
 813     free(path);
 814     free(target);
 815     free(url);
 816
 817     BOOLEAN_TO_NPVARIANT(error == NPERR_NO_ERROR, *result);
 818     return true;
 819 }
 820
 821 static bool testConstruct(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 822 {
 823     if (!argCount || !NPVARIANT_IS_OBJECT(args[0]))
 824         return false;
 825
 826     return browser->construct(obj->npp, NPVARIANT_TO_OBJECT(args[0]), args + 1, argCount - 1, result);
 827 }
 828
 829 // Invoke a script callback to get a script NPObject. Then call a method on the
 830 // script NPObject passing it a freshly created NPObject.
 831 static bool testScriptObjectInvoke(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 832 {
 833     if (argCount != 2 || !NPVARIANT_IS_STRING(args[0]) || !NPVARIANT_IS_STRING(args[1]))
 834         return false;
 835     NPObject* windowScriptObject;
 836     browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);
 837
 838     // Arg1 is the name of the callback
 839     NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
 840     NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
 841     free(callbackString);
 842
 843     // Invoke a callback that returns a script object
 844     NPVariant object_result;
 845     browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, &args[1], 1, &object_result);
 846
 847     // Script object returned
 848     NPObject* script_object = object_result.value.objectValue;
 849
 850     // Arg2 is the name of the method to be called on the script object
 851     NPUTF8* object_mehod_string = createCStringFromNPVariant(&args[1]);
 852     NPIdentifier object_method = browser->getstringidentifier(object_mehod_string);
 853     free(object_mehod_string);
 854
 855     // Create a fresh NPObject to be passed as an argument
 856     NPObject* object_arg = browser->createobject(obj->npp, obj->header._class);
 857
 858     NPVariant invoke_args[1];
 859     OBJECT_TO_NPVARIANT(object_arg, invoke_args[0]);
 860
 861     // Invoke the script method
 862     NPVariant object_method_result;
 863     browser->invoke(obj->npp, script_object, object_method, invoke_args, 1, &object_method_result);
 864
 865     browser->releasevariantvalue(&object_result);
 866     VOID_TO_NPVARIANT(*result);
 867     if (NPVARIANT_IS_OBJECT(object_method_result)) {
 868         // Now return the callbacks return value back to our caller.
 869         // BUG 897451: This should be the same as the
 870         // windowScriptObject, but its not (in Chrome) - or at least, it
 871         // has a different refcount. This means Chrome will delete the
 872         // object before returning it and the calling JS gets a garbage
 873         // value.  Firefox handles it fine.
 874         OBJECT_TO_NPVARIANT(NPVARIANT_TO_OBJECT(object_method_result), *result);
 875     } else {
 876         browser->releasevariantvalue(&object_method_result);
 877         VOID_TO_NPVARIANT(*result);
 878     }
 879
 880     browser->releaseobject(object_arg);
 881
 882     return true;
 883 }
 884
 885 // Helper function to notify the layout test controller that the test completed.
 886 void notifyTestCompletion(NPP npp, NPObject* object)
 887 {
 888     NPVariant result;
 889     NPString script;
 890     script.UTF8Characters = "javascript:window.testRunner.notifyDone();";
 891     script.UTF8Length = strlen("javascript:window.testRunner.notifyDone();");
 892     browser->evaluate(npp, object, &script, &result);
 893     browser->releasevariantvalue(&result);
 894 }
 895
 896 bool testDocumentOpen(NPP npp)
 897 {
 898     NPIdentifier documentId = browser->getstringidentifier("document");
 899     NPIdentifier openId = browser->getstringidentifier("open");
 900
 901     NPObject* windowObject = 0;
 902     browser->getvalue(npp, NPNVWindowNPObject, &windowObject);
 903     if (!windowObject)
 904         return false;
 905
 906     NPVariant docVariant;
 907     browser->getproperty(npp, windowObject, documentId, &docVariant);
 908     if (docVariant.type != NPVariantType_Object) {
 909         browser->releaseobject(windowObject);
 910         return false;
 911     }
 912
 913     NPObject* documentObject = NPVARIANT_TO_OBJECT(docVariant);
 914
 915     NPVariant openArgs[2];
 916     STRINGZ_TO_NPVARIANT("text/html", openArgs[0]);
 917     STRINGZ_TO_NPVARIANT("_blank", openArgs[1]);
 918
 919     NPVariant result;
 920     if (!browser->invoke(npp, documentObject, openId, openArgs, 2, &result)) {
 921         browser->releaseobject(windowObject);
 922         browser->releaseobject(documentObject);
 923         return false;
 924     }
 925
 926     browser->releaseobject(documentObject);
 927
 928     if (result.type != NPVariantType_Object) {
 929         browser->releaseobject(windowObject);
 930         browser->releasevariantvalue(&result);
 931         return false;
 932     }
 933
 934     pluginLogWithWindowObject(windowObject, npp, "PLUGIN: DOCUMENT OPEN SUCCESS");
 935     notifyTestCompletion(npp, result.value.objectValue);
 936     browser->releaseobject(result.value.objectValue);
 937     browser->releaseobject(windowObject);
 938     return true;
 939 }
 940
 941 bool testWindowOpen(NPP npp)
 942 {
 943     NPIdentifier openId = browser->getstringidentifier("open");
 944
 945     NPObject* windowObject = 0;
 946     browser->getvalue(npp, NPNVWindowNPObject, &windowObject);
 947     if (!windowObject)
 948         return false;
 949
 950     NPVariant openArgs[2];
 951     STRINGZ_TO_NPVARIANT("about:blank", openArgs[0]);
 952     STRINGZ_TO_NPVARIANT("_blank", openArgs[1]);
 953
 954     NPVariant result;
 955     if (!browser->invoke(npp, windowObject, openId, openArgs, 2, &result)) {
 956         browser->releaseobject(windowObject);
 957         return false;
 958     }
 959
 960     if (result.type != NPVariantType_Object) {
 961         browser->releaseobject(windowObject);
 962         browser->releasevariantvalue(&result);
 963         return false;
 964     }
 965
 966     pluginLogWithWindowObject(windowObject, npp, "PLUGIN: WINDOW OPEN SUCCESS");
 967     notifyTestCompletion(npp, result.value.objectValue);
 968     browser->releaseobject(result.value.objectValue);
 969     browser->releaseobject(windowObject);
 970     return true;
 971 }
 972
 973 static bool testSetStatus(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 974 {
 975     char* message = 0;
 976     if (argCount && NPVARIANT_IS_STRING(args[0])) {
 977         NPString statusString = NPVARIANT_TO_STRING(args[0]);
 978         message = toCString(statusString);
 979     }
 980
 981     browser->status(obj->npp, message);
 982
 983     free(message);
 984     return true;
 985 }
 986
 987 static bool testResizeTo(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 988 {
 989     VOID_TO_NPVARIANT(*result);
 990
 991     NPObject* windowObject;
 992     if (NPERR_NO_ERROR != browser->getvalue(obj->npp, NPNVWindowNPObject, &windowObject))
 993         return false;
 994
 995     NPVariant callResult;
 996     if (browser->invoke(obj->npp, windowObject, browser->getstringidentifier("resizePlugin"), args, argCount, &callResult))
 997         browser->releasevariantvalue(&callResult);
 998
 999     // Force layout.
1000     if (browser->getproperty(obj->npp, windowObject, browser->getstringidentifier("pageYOffset"), &callResult))
1001         browser->releasevariantvalue(&callResult);
1002
1003     return true;
1004 }
1005
1006 static bool normalizeOverride(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
1007 {
1008     VOID_TO_NPVARIANT(*result);
1009
1010     NPObject* windowObject;
1011     if (NPERR_NO_ERROR != browser->getvalue(obj->npp, NPNVWindowNPObject, &windowObject))
1012         return false;
1013
1014     NPVariant callResult;
1015     if (browser->invoke(obj->npp, windowObject, browser->getstringidentifier("pluginCallback"), args, argCount, &callResult))
1016         browser->releasevariantvalue(&callResult);
1017
1018     return true;
1019 }
1020
1021 static bool invalidateRect(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
1022 {
1023     if (argCount != 4)
1024         return false;
1025
1026     NPRect rect;
1027     rect.left = static_cast<int>(NPVARIANT_TO_DOUBLE(args[0]));
1028     rect.top = static_cast<int>(NPVARIANT_TO_DOUBLE(args[1]));
1029     rect.right = static_cast<int>(NPVARIANT_TO_DOUBLE(args[2]));
1030     rect.bottom = static_cast<int>(NPVARIANT_TO_DOUBLE(args[3]));
1031
1032     browser->invalidaterect(obj->npp, &rect);
1033     return true;
1034 }
1035
1036 static bool objectsAreSame(PluginObject* obj, const NPVariant* args, uint32_t argCount, NPVariant* result)
1037 {
1038     if (argCount != 2 || !NPVARIANT_IS_OBJECT(args[0]) || !NPVARIANT_IS_OBJECT(args[1]))
1039         return false;
1040
1041     BOOLEAN_TO_NPVARIANT(NPVARIANT_TO_OBJECT(args[0]) == NPVARIANT_TO_OBJECT(args[1]), *result);
1042     return true;
1043 }
1044
1045 static bool pluginInvoke(NPObject* header, NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result)
1046 {
1047     PluginObject* plugin = reinterpret_cast<PluginObject*>(header);
1048     if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD])
1049         return testCallback(plugin, args, argCount, result);
1050     if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD_RETURN])
1051         return testCallbackReturn(plugin, args, argCount, result);
1052     if (name == pluginMethodIdentifiers[ID_TEST_GETURL])
1053         return getURL(plugin, args, argCount, result);
1054     if (name == pluginMethodIdentifiers[ID_TEST_DOM_ACCESS])
1055         return testDOMAccess(plugin, args, argCount, result);
1056     if (name == pluginMethodIdentifiers[ID_TEST_GET_URL_NOTIFY])
1057         return getURLNotify(plugin, args, argCount, result);
1058     if (name == pluginMethodIdentifiers[ID_TEST_INVOKE_DEFAULT])
1059         return testInvokeDefault(plugin, args, argCount, result);
1060     if (name == pluginMethodIdentifiers[ID_TEST_ENUMERATE])
1061         return testEnumerate(plugin, args, argCount, result);
1062     if (name == pluginMethodIdentifiers[ID_DESTROY_STREAM])
1063         return destroyStream(plugin, args, argCount, result);
1064     if (name == pluginMethodIdentifiers[ID_TEST_GETINTIDENTIFIER])
1065         return testGetIntIdentifier(plugin, args, argCount, result);
1066     if (name == pluginMethodIdentifiers[ID_TEST_EVALUATE])
1067         return testEvaluate(plugin, args, argCount, result);
1068     if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY])
1069         return testGetProperty(plugin, args, argCount, result);
1070     if (name == pluginMethodIdentifiers[ID_TEST_GET_PROPERTY_RETURN_VALUE])
1071         return testGetPropertyReturnValue(plugin, args, argCount, result);
1072     if (name == pluginMethodIdentifiers[ID_TEST_HAS_PROPERTY])
1073         return testHasProperty(plugin, args, argCount, result);
1074     if (name == pluginMethodIdentifiers[ID_TEST_HAS_METHOD])
1075         return testHasMethod(plugin, args, argCount, result);
1076     if (name == pluginMethodIdentifiers[ID_TEST_IDENTIFIER_TO_STRING])
1077         return testIdentifierToString(plugin, args, argCount, result);
1078     if (name == pluginMethodIdentifiers[ID_TEST_IDENTIFIER_TO_INT])
1079         return testIdentifierToInt(plugin, args, argCount, result);
1080     if (name == pluginMethodIdentifiers[ID_TEST_PASS_TEST_OBJECT])
1081         return testPassTestObject(plugin, args, argCount, result);
1082     if (name == pluginMethodIdentifiers[ID_TEST_POSTURL_FILE])
1083         return testPostURLFile(plugin, args, argCount, result);
1084     if (name == pluginMethodIdentifiers[ID_TEST_CONSTRUCT])
1085         return testConstruct(plugin, args, argCount, result);
1086     if (name == pluginMethodIdentifiers[ID_TEST_SCRIPT_OBJECT_INVOKE])
1087         return testScriptObjectInvoke(plugin, args, argCount, result);
1088     if (name == pluginMethodIdentifiers[ID_TEST_THROW_EXCEPTION_METHOD]) {
1089         browser->setexception(header, "plugin object testThrowException SUCCESS");
1090         return true;
1091     }
1092     if (name == pluginMethodIdentifiers[ID_TEST_FAIL_METHOD]) {
1093         NPObject* windowScriptObject;
1094         browser->getvalue(plugin->npp, NPNVWindowNPObject, &windowScriptObject);
1095         browser->invoke(plugin->npp, windowScriptObject, name, args, argCount, result);
1096         return false;
1097     }
1098     if (name == pluginMethodIdentifiers[ID_TEST_CLONE_OBJECT]) {
1099         NPObject* new_object = browser->createobject(plugin->npp, plugin->header._class);
1100         assert(new_object->referenceCount == 1);
1101         OBJECT_TO_NPVARIANT(new_object, *result);
1102         return true;
1103     }
1104     if (name == pluginMethodIdentifiers[ID_TEST_CREATE_TEST_OBJECT]) {
1105         NPObject* testObject = browser->createobject(plugin->npp, getTestClass());
1106         assert(testObject->referenceCount == 1);
1107         OBJECT_TO_NPVARIANT(testObject, *result);
1108         return true;
1109     }
1110     if (name == pluginMethodIdentifiers[ID_DESTROY_NULL_STREAM])
1111         return destroyNullStream(plugin, args, argCount, result);
1112     if (name == pluginMethodIdentifiers[ID_TEST_RELOAD_PLUGINS_NO_PAGES]) {
1113         browser->reloadplugins(false);
1114         return true;
1115     }
1116     if (name == pluginMethodIdentifiers[ID_TEST_RELOAD_PLUGINS_AND_PAGES]) {
1117         browser->reloadplugins(true);
1118         return true;
1119     }
1120     if (name == pluginMethodIdentifiers[ID_TEST_GET_BROWSER_PROPERTY]) {
1121         browser->getproperty(plugin->npp, NPVARIANT_TO_OBJECT(args[0]), stringVariantToIdentifier(args[1]), result);
1122         return true;
1123     }
1124     if (name == pluginMethodIdentifiers[ID_TEST_SET_BROWSER_PROPERTY]) {
1125         browser->setproperty(plugin->npp, NPVARIANT_TO_OBJECT(args[0]), stringVariantToIdentifier(args[1]), &args[2]);
1126         return true;
1127     }
1128     if (name == pluginMethodIdentifiers[ID_REMEMBER]) {
1129         if (plugin->rememberedObject)
1130             browser->releaseobject(plugin->rememberedObject);
1131         plugin->rememberedObject = NPVARIANT_TO_OBJECT(args[0]);
1132         browser->retainobject(plugin->rememberedObject);
1133         VOID_TO_NPVARIANT(*result);
1134         return true;
1135     }
1136     if (name == pluginMethodIdentifiers[ID_GET_REMEMBERED_OBJECT]) {
1137         assert(plugin->rememberedObject);
1138         browser->retainobject(plugin->rememberedObject);
1139         OBJECT_TO_NPVARIANT(plugin->rememberedObject, *result);
1140         return true;
1141     }
1142     if (name == pluginMethodIdentifiers[ID_GET_AND_FORGET_REMEMBERED_OBJECT]) {
1143         assert(plugin->rememberedObject);
1144         OBJECT_TO_NPVARIANT(plugin->rememberedObject, *result);
1145         plugin->rememberedObject = 0;
1146         return true;
1147     }
1148     if (name == pluginMethodIdentifiers[ID_REF_COUNT]) {
1149         uint32_t refCount = NPVARIANT_TO_OBJECT(args[0])->referenceCount;
1150         INT32_TO_NPVARIANT(refCount, *result);
1151         return true;
1152     }
1153     if (name == pluginMethodIdentifiers[ID_SET_STATUS])
1154         return testSetStatus(plugin, args, argCount, result);
1155     if (name == pluginMethodIdentifiers[ID_RESIZE_TO])
1156         return testResizeTo(plugin, args, argCount, result);
1157     if (name == pluginMethodIdentifiers[ID_NORMALIZE])
1158         return normalizeOverride(plugin, args, argCount, result);
1159     if (name == pluginMethodIdentifiers[ID_INVALIDATE_RECT])
1160         return invalidateRect(plugin, args, argCount, result);
1161     if (name == pluginMethodIdentifiers[ID_OBJECTS_ARE_SAME])
1162         return objectsAreSame(plugin, args, argCount, result);
1163     if (name == pluginMethodIdentifiers[ID_TEST_DELETE_WITHIN_INVOKE]) {
1164         NPObject* newObject = browser->createobject(plugin->npp, plugin->header._class);
1165         OBJECT_TO_NPVARIANT(newObject, *result);
1166         callDeletePlugin(header, name, pluginMethodIdentifiers[ID_TEST_DELETE_WITHIN_INVOKE]);
1167         return true;
1168     }
1169     return false;
1170 }
1171
1172 static void pluginInvalidate(NPObject* header)
1173 {
1174     PluginObject* plugin = reinterpret_cast<PluginObject*>(header);
1175     plugin->testObject = 0;
1176     plugin->rememberedObject = 0;
1177 }
1178
1179 static NPObject *pluginAllocate(NPP npp, NPClass *theClass)
1180 {
1181     PluginObject* newInstance = (PluginObject*)malloc(sizeof(PluginObject));
1182
1183     if (!identifiersInitialized) {
1184         identifiersInitialized = true;
1185         initializeIdentifiers();
1186     }
1187
1188     newInstance->pluginTest = 0;
1189     newInstance->npp = npp;
1190     newInstance->testObject = browser->createobject(npp, getTestClass());
1191     newInstance->rememberedObject = 0;
1192     newInstance->eventLogging = false;
1193     newInstance->onStreamLoad = 0;
1194     newInstance->onStreamDestroy = 0;
1195     newInstance->onDestroy = 0;
1196     newInstance->onURLNotify = 0;
1197     newInstance->onSetWindow = 0;
1198     newInstance->onPaintEvent = 0;
1199     newInstance->logDestroy = false;
1200     newInstance->logSetWindow = false;
1201     newInstance->returnErrorFromNewStream = false;
1202     newInstance->returnNegativeOneFromWrite = false;
1203     newInstance->stream = 0;
1204
1205     newInstance->firstUrl = 0;
1206     newInstance->firstHeaders = 0;
1207     newInstance->lastUrl = 0;
1208     newInstance->lastHeaders = 0;
1209
1210     newInstance->testGetURLOnDestroy = false;
1211     newInstance->testWindowOpen = false;
1212     newInstance->testKeyboardFocusForPlugins = false;
1213
1214     newInstance->mouseDownForEvaluateScript = false;
1215     newInstance->evaluateScriptOnMouseDownOrKeyDown = 0;
1216
1217     return (NPObject*)newInstance;
1218 }
1219
1220 static void pluginDeallocate(NPObject* header)
1221 {
1222     PluginObject* plugin = reinterpret_cast<PluginObject*>(header);
1223     delete plugin->pluginTest;
1224     if (plugin->testObject)
1225         browser->releaseobject(plugin->testObject);
1226     if (plugin->rememberedObject)
1227         browser->releaseobject(plugin->rememberedObject);
1228
1229     free(plugin->firstUrl);
1230     free(plugin->firstHeaders);
1231     free(plugin->lastUrl);
1232     free(plugin->lastHeaders);
1233     free(plugin);
1234 }
1235
1236 void handleCallback(PluginObject* object, const char *url, NPReason reason, void *notifyData)
1237 {
1238     assert(object);
1239
1240     NPVariant args[2];
1241
1242     NPObject* windowScriptObject;
1243     browser->getvalue(object->npp, NPNVWindowNPObject, &windowScriptObject);
1244
1245     NPIdentifier callbackIdentifier = notifyData;
1246
1247     INT32_TO_NPVARIANT(reason, args[0]);
1248
1249     char* strHdr = 0;
1250     if (object->firstUrl && object->firstHeaders && object->lastUrl && object->lastHeaders) {
1251         // Format expected by JavaScript validator: four fields separated by \n\n:
1252         // First URL; first header block; last URL; last header block.
1253         // Note that header blocks already end with \n due to how NPStream::headers works.
1254         int len = strlen(object->firstUrl) + 2
1255             + strlen(object->firstHeaders) + 1
1256             + strlen(object->lastUrl) + 2
1257             + strlen(object->lastHeaders) + 1;
1258         strHdr = (char*)malloc(len + 1);
1259         snprintf(strHdr, len + 1, "%s\n\n%s\n%s\n\n%s\n",
1260                  object->firstUrl, object->firstHeaders, object->lastUrl, object->lastHeaders);
1261         STRINGN_TO_NPVARIANT(strHdr, len, args[1]);
1262     } else
1263         NULL_TO_NPVARIANT(args[1]);
1264
1265     NPVariant browserResult;
1266     if (browser->invoke(object->npp, windowScriptObject, callbackIdentifier, args, 2, &browserResult))
1267         browser->releasevariantvalue(&browserResult);
1268
1269     free(strHdr);
1270 }
1271
1272 void notifyStream(PluginObject* object, const char *url, const char *headers)
1273 {
1274     if (!object->firstUrl) {
1275         if (url)
1276             object->firstUrl = strdup(url);
1277         if (headers)
1278             object->firstHeaders = strdup(headers);
1279     } else {
1280         free(object->lastUrl);
1281         free(object->lastHeaders);
1282         object->lastUrl = (url ? strdup(url) : 0);
1283         object->lastHeaders = (headers ? strdup(headers) : 0);
1284     }
1285 }
1286
1287 void testNPRuntime(NPP npp)
1288 {
1289     NPObject* windowScriptObject;
1290     browser->getvalue(npp, NPNVWindowNPObject, &windowScriptObject);
1291
1292     // Invoke
1293     NPIdentifier testNPInvoke = browser->getstringidentifier("testNPInvoke");
1294     NPVariant args[7];
1295
1296     VOID_TO_NPVARIANT(args[0]);
1297     NULL_TO_NPVARIANT(args[1]);
1298     BOOLEAN_TO_NPVARIANT(true, args[2]);
1299     INT32_TO_NPVARIANT(242, args[3]);
1300     DOUBLE_TO_NPVARIANT(242.242, args[4]);
1301     STRINGZ_TO_NPVARIANT("Hello, World", args[5]);
1302     OBJECT_TO_NPVARIANT(windowScriptObject, args[6]);
1303
1304     NPVariant result;
1305     if (browser->invoke(npp, windowScriptObject, testNPInvoke, args, 7, &result))
1306         browser->releasevariantvalue(&result);
1307
1308     browser->releaseobject(windowScriptObject);
1309 }