The Tor Browser: dom/plugins/test/testplugin/nptest.cpp@6474c204b198 (annotated)

dom/plugins/test/testplugin/nptest.cpp@6474c204b198 (annotated)

dom/plugins/test/testplugin/nptest.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* ***** BEGIN LICENSE BLOCK *****
  *
  * Copyright (c) 2008, Mozilla Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  * * Redistributions of source code must retain the above copyright notice, this
  *   list of conditions and the following disclaimer.
  * * 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.
  * * Neither the name of the Mozilla Corporation nor the names of its
  *   contributors may be used to endorse or promote products derived from this
  *   software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER 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.
  *
  * Contributor(s):
  *   Dave Townsend <dtownsend@oxymoronical.com>
  *   Josh Aas <josh@mozilla.com>
  *
  * ***** END LICENSE BLOCK ***** */
 #include "nptest.h"
 #include "nptest_utils.h"
 #include "nptest_platform.h"
 #include "mozilla/IntentionalCrash.h"
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <iostream>
 #include <string>
 #include <sstream>
 #include <list>
 #include <ctime>
 #ifdef XP_WIN
 #include <process.h>
 #include <float.h>
 #include <windows.h>
 #define getpid _getpid
 #define strcasecmp _stricmp
 #else
 #include <unistd.h>
 #include <pthread.h>
 #endif
 #include "mozilla/NullPtr.h"
 using namespace std;
 #define PLUGIN_VERSION     "1.0.0.0"
 #define ARRAY_LENGTH(a) (sizeof(a)/sizeof(a[0]))
 #define STATIC_ASSERT(condition)                                \
     extern void np_static_assert(int arg[(condition) ? 1 : -1])
 extern const char *sPluginName;
 extern const char *sPluginDescription;
 static char sPluginVersion[] = PLUGIN_VERSION;
 //
 // Intentional crash
 //
 int gCrashCount = 0;
 static void Crash()
 {
   int *pi = nullptr;
   *pi = 55; // Crash dereferencing null pointer
   ++gCrashCount;
 }
 static void
 IntentionalCrash()
 {
   mozilla::NoteIntentionalCrash("plugin");
   Crash();
 }
 //
 // static data
 //
 static NPNetscapeFuncs* sBrowserFuncs = nullptr;
 static NPClass sNPClass;
 void
 asyncCallback(void* cookie);
 //
 // identifiers
 //
 typedef bool (* ScriptableFunction)
   (NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool npnEvaluateTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool npnInvokeTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool npnInvokeDefaultTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool setUndefinedValueTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool identifierToStringTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool timerTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool queryPrivateModeState(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool lastReportedPrivateModeState(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool hasWidget(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getEdge(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getClipRegionRectCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getClipRegionRectEdge(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool startWatchingInstanceCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getInstanceCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool stopWatchingInstanceCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getLastMouseX(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getLastMouseY(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getPaintCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getWidthAtLastPaint(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool setInvalidateDuringPaint(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool setSlowPaint(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getError(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool doInternalConsistencyCheck(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool setColor(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool throwExceptionNextInvoke(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool convertPointX(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool convertPointY(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool streamTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool setPluginWantsAllStreams(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool crashPlugin(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool crashOnDestroy(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getObjectValue(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getJavaCodebase(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool checkObjectValue(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool enableFPExceptions(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool setCookie(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getCookie(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getAuthInfo(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool asyncCallbackTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool checkGCRace(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool hangPlugin(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool stallPlugin(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getClipboardText(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool callOnDestroy(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool reinitWidget(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool crashPluginInNestedLoop(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool destroySharedGfxStuff(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool propertyAndMethod(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getTopLevelWindowActivationState(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getTopLevelWindowActivationEventCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getFocusState(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getFocusEventCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getEventModel(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getReflector(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool isVisible(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getWindowPosition(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool constructObject(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool setSitesWithData(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool setSitesWithDataCapabilities(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getLastKeyText(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getNPNVdocumentOrigin(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool getMouseUpEventCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static bool queryContentsScaleFactor(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 static const NPUTF8* sPluginMethodIdentifierNames[] = {
   "npnEvaluateTest",
   "npnInvokeTest",
   "npnInvokeDefaultTest",
   "setUndefinedValueTest",
   "identifierToStringTest",
   "timerTest",
   "queryPrivateModeState",
   "lastReportedPrivateModeState",
   "hasWidget",
   "getEdge",
   "getClipRegionRectCount",
   "getClipRegionRectEdge",
   "startWatchingInstanceCount",
   "getInstanceCount",
   "stopWatchingInstanceCount",
   "getLastMouseX",
   "getLastMouseY",
   "getPaintCount",
   "getWidthAtLastPaint",
   "setInvalidateDuringPaint",
   "setSlowPaint",
   "getError",
   "doInternalConsistencyCheck",
   "setColor",
   "throwExceptionNextInvoke",
   "convertPointX",
   "convertPointY",
   "streamTest",
   "setPluginWantsAllStreams",
   "crash",
   "crashOnDestroy",
   "getObjectValue",
   "getJavaCodebase",
   "checkObjectValue",
   "enableFPExceptions",
   "setCookie",
   "getCookie",
   "getAuthInfo",
   "asyncCallbackTest",
   "checkGCRace",
   "hang",
   "stall",
   "getClipboardText",
   "callOnDestroy",
   "reinitWidget",
   "crashInNestedLoop",
   "destroySharedGfxStuff",
   "propertyAndMethod",
   "getTopLevelWindowActivationState",
   "getTopLevelWindowActivationEventCount",
   "getFocusState",
   "getFocusEventCount",
   "getEventModel",
   "getReflector",
   "isVisible",
   "getWindowPosition",
   "constructObject",
   "setSitesWithData",
   "setSitesWithDataCapabilities",
   "getLastKeyText",
   "getNPNVdocumentOrigin",
   "getMouseUpEventCount",
   "queryContentsScaleFactor"
 };
 static NPIdentifier sPluginMethodIdentifiers[ARRAY_LENGTH(sPluginMethodIdentifierNames)];
 static const ScriptableFunction sPluginMethodFunctions[] = {
   npnEvaluateTest,
   npnInvokeTest,
   npnInvokeDefaultTest,
   setUndefinedValueTest,
   identifierToStringTest,
   timerTest,
   queryPrivateModeState,
   lastReportedPrivateModeState,
   hasWidget,
   getEdge,
   getClipRegionRectCount,
   getClipRegionRectEdge,
   startWatchingInstanceCount,
   getInstanceCount,
   stopWatchingInstanceCount,
   getLastMouseX,
   getLastMouseY,
   getPaintCount,
   getWidthAtLastPaint,
   setInvalidateDuringPaint,
   setSlowPaint,
   getError,
   doInternalConsistencyCheck,
   setColor,
   throwExceptionNextInvoke,
   convertPointX,
   convertPointY,
   streamTest,
   setPluginWantsAllStreams,
   crashPlugin,
   crashOnDestroy,
   getObjectValue,
   getJavaCodebase,
   checkObjectValue,
   enableFPExceptions,
   setCookie,
   getCookie,
   getAuthInfo,
   asyncCallbackTest,
   checkGCRace,
   hangPlugin,
   stallPlugin,
   getClipboardText,
   callOnDestroy,
   reinitWidget,
   crashPluginInNestedLoop,
   destroySharedGfxStuff,
   propertyAndMethod,
   getTopLevelWindowActivationState,
   getTopLevelWindowActivationEventCount,
   getFocusState,
   getFocusEventCount,
   getEventModel,
   getReflector,
   isVisible,
   getWindowPosition,
   constructObject,
   setSitesWithData,
   setSitesWithDataCapabilities,
   getLastKeyText,
   getNPNVdocumentOrigin,
   getMouseUpEventCount,
   queryContentsScaleFactor
 };
 STATIC_ASSERT(ARRAY_LENGTH(sPluginMethodIdentifierNames) ==
               ARRAY_LENGTH(sPluginMethodFunctions));
 static const NPUTF8* sPluginPropertyIdentifierNames[] = {
   "propertyAndMethod"
 };
 static NPIdentifier sPluginPropertyIdentifiers[ARRAY_LENGTH(sPluginPropertyIdentifierNames)];
 static NPVariant sPluginPropertyValues[ARRAY_LENGTH(sPluginPropertyIdentifierNames)];
 struct URLNotifyData
 {
   const char* cookie;
   NPObject* writeCallback;
   NPObject* notifyCallback;
   NPObject* redirectCallback;
   bool allowRedirects;
   uint32_t size;
   char* data;
 };
 static URLNotifyData kNotifyData = {
   "static-cookie",
   nullptr,
   nullptr,
   nullptr,
   false,
 ,
   nullptr
 };
 static const char* SUCCESS_STRING = "pass";
 static bool sIdentifiersInitialized = false;
 struct timerEvent {
   int32_t timerIdReceive;
   int32_t timerIdSchedule;
   uint32_t timerInterval;
   bool timerRepeat;
   int32_t timerIdUnschedule;
 };
 static timerEvent timerEvents[] = {
   {-1, 0, 200, false, -1},
   {0, 0, 400, false, -1},
   {0, 0, 200, true, -1},
   {0, 1, 400, true, -1},
   {0, -1, 0, false, 0},
   {1, -1, 0, false, -1},
   {1, -1, 0, false, 1},
 };
 static uint32_t currentTimerEventCount = 0;
 static uint32_t totalTimerEvents = sizeof(timerEvents) / sizeof(timerEvent);
 /**
  * Incremented for every startWatchingInstanceCount.
  */
 static int32_t sCurrentInstanceCountWatchGeneration = 0;
 /**
  * Tracks the number of instances created or destroyed since the last
  * startWatchingInstanceCount.
  */
 static int32_t sInstanceCount = 0;
 /**
  * True when we've had a startWatchingInstanceCount with no corresponding
  * stopWatchingInstanceCount.
  */
 static bool sWatchingInstanceCount = false;
 /**
  * A list representing sites for which the plugin has stored data. See
  * NPP_ClearSiteData and NPP_GetSitesWithData.
  */
 struct siteData {
   string site;
   uint64_t flags;
   uint64_t age;
 };
 static list<siteData>* sSitesWithData;
 static bool sClearByAgeSupported;
 static void initializeIdentifiers()
 {
   if (!sIdentifiersInitialized) {
     NPN_GetStringIdentifiers(sPluginMethodIdentifierNames,
         ARRAY_LENGTH(sPluginMethodIdentifierNames), sPluginMethodIdentifiers);
     NPN_GetStringIdentifiers(sPluginPropertyIdentifierNames,
         ARRAY_LENGTH(sPluginPropertyIdentifierNames), sPluginPropertyIdentifiers);
     sIdentifiersInitialized = true;
     // Check whether nullptr is handled in NPN_GetStringIdentifiers
     NPIdentifier IDList[2];
     static char const *const kIDNames[2] = { nullptr, "setCookie" };
     NPN_GetStringIdentifiers(const_cast<const NPUTF8**>(kIDNames), 2, IDList);
   }
 }
 static void clearIdentifiers()
 {
   memset(sPluginMethodIdentifiers, 0,
       ARRAY_LENGTH(sPluginMethodIdentifiers) * sizeof(NPIdentifier));
   memset(sPluginPropertyIdentifiers, 0,
       ARRAY_LENGTH(sPluginPropertyIdentifiers) * sizeof(NPIdentifier));
   sIdentifiersInitialized = false;
 }
 static void addRange(InstanceData* instanceData, const char* range)
 {
   char rangestr[16];
   strncpy(rangestr, range, sizeof(rangestr));
   const char* str1 = strtok(rangestr, ",");
   const char* str2 = str1 ? strtok(nullptr, ",") : nullptr;
   if (str1 && str2) {
     TestRange* byterange = new TestRange;
     byterange->offset = atoi(str1);
     byterange->length = atoi(str2);
     byterange->waiting = true;
     byterange->next = instanceData->testrange;
     instanceData->testrange = byterange;
   }
 }
 static void sendBufferToFrame(NPP instance)
 {
   InstanceData* instanceData = (InstanceData*)(instance->pdata);
   string outbuf;
   if (!instanceData->npnNewStream) outbuf = "data:text/html,";
   const char* buf = reinterpret_cast<char *>(instanceData->streamBuf);
   int32_t bufsize = instanceData->streamBufSize;
   if (instanceData->streamMode == NP_ASFILE ||
       instanceData->streamMode == NP_ASFILEONLY) {
     buf = reinterpret_cast<char *>(instanceData->fileBuf);
     bufsize = instanceData->fileBufSize;
   }
   if (instanceData->err.str().length() > 0) {
     outbuf.append(instanceData->err.str());
   }
   else if (bufsize > 0) {
     outbuf.append(buf);
   }
   else {
     outbuf.append("Error: no data in buffer");
   }
   if (instanceData->npnNewStream &&
       instanceData->err.str().length() == 0) {
     char typeHTML[] = "text/html";
     NPStream* stream;
     printf("calling NPN_NewStream...");
     NPError err = NPN_NewStream(instance, typeHTML,
         instanceData->frame.c_str(), &stream);
     printf("return value %d\n", err);
     if (err != NPERR_NO_ERROR) {
       instanceData->err << "NPN_NewStream returned " << err;
       return;
     }
     int32_t bytesToWrite = outbuf.length();
     int32_t bytesWritten = 0;
     while ((bytesToWrite - bytesWritten) > 0) {
       int32_t numBytes = (bytesToWrite - bytesWritten) <
           instanceData->streamChunkSize ?
           bytesToWrite - bytesWritten : instanceData->streamChunkSize;
       int32_t written = NPN_Write(instance, stream,
           numBytes, (void*)(outbuf.c_str() + bytesWritten));
       if (written <= 0) {
         instanceData->err << "NPN_Write returned " << written;
         break;
       }
       bytesWritten += numBytes;
       printf("%d bytes written, total %d\n", written, bytesWritten);
     }
     err = NPN_DestroyStream(instance, stream, NPRES_DONE);
     if (err != NPERR_NO_ERROR) {
       instanceData->err << "NPN_DestroyStream returned " << err;
     }
   }
   else {
     // Convert CRLF to LF, and escape most other non-alphanumeric chars.
     for (size_t i = 0; i < outbuf.length(); i++) {
       if (outbuf[i] == '\n') {
         outbuf.replace(i, 1, "%0a");
         i += 2;
       }
       else if (outbuf[i] == '\r') {
         outbuf.replace(i, 1, "");
         i -= 1;
       }
       else {
         int ascii = outbuf[i];
         if (!((ascii >= ',' && ascii <= ';') ||
               (ascii >= 'A' && ascii <= 'Z') ||
               (ascii >= 'a' && ascii <= 'z'))) {
           char hex[8];
           sprintf(hex, "%%%x", ascii);
           outbuf.replace(i, 1, hex);
           i += 2;
         }
       }
     }
     NPError err = NPN_GetURL(instance, outbuf.c_str(),
                              instanceData->frame.c_str());
     if (err != NPERR_NO_ERROR) {
       instanceData->err << "NPN_GetURL returned " << err;
     }
   }
 }
 static void XPSleep(unsigned int seconds)
 {
 #ifdef XP_WIN
   Sleep(1000 * seconds);
 #else
   sleep(seconds);
 #endif
 }
 TestFunction
 getFuncFromString(const char* funcname)
 {
   FunctionTable funcTable[] =
     {
       { FUNCTION_NPP_NEWSTREAM, "npp_newstream" },
       { FUNCTION_NPP_WRITEREADY, "npp_writeready" },
       { FUNCTION_NPP_WRITE, "npp_write" },
       { FUNCTION_NPP_DESTROYSTREAM, "npp_destroystream" },
       { FUNCTION_NPP_WRITE_RPC, "npp_write_rpc" },
       { FUNCTION_NONE, nullptr }
     };
   int32_t i = 0;
   while(funcTable[i].funcName) {
     if (!strcmp(funcname, funcTable[i].funcName)) return funcTable[i].funcId;
     i++;
   }
   return FUNCTION_NONE;
 }
 static void
 DuplicateNPVariant(NPVariant& aDest, const NPVariant& aSrc)
 {
   if (NPVARIANT_IS_STRING(aSrc)) {
     NPString src = NPVARIANT_TO_STRING(aSrc);
     char* buf = new char[src.UTF8Length];
     strncpy(buf, src.UTF8Characters, src.UTF8Length);
     STRINGN_TO_NPVARIANT(buf, src.UTF8Length, aDest);
   }
   else if (NPVARIANT_IS_OBJECT(aSrc)) {
     NPObject* obj =
       NPN_RetainObject(NPVARIANT_TO_OBJECT(aSrc));
     OBJECT_TO_NPVARIANT(obj, aDest);
   }
   else {
     aDest = aSrc;
   }
 }
 void
 drawAsyncBitmapColor(InstanceData* instanceData)
 {
   NPP npp = instanceData->npp;
   uint32_t *pixelData = (uint32_t*)instanceData->backBuffer->bitmap.data;
   uint32_t rgba = instanceData->scriptableObject->drawColor;
   unsigned char subpixels[4];
   subpixels[0] = rgba & 0xFF;
   subpixels[1] = (rgba & 0xFF00) >> 8;
   subpixels[2] = (rgba & 0xFF0000) >> 16;
   subpixels[3] = (rgba & 0xFF000000) >> 24;
   subpixels[0] = uint8_t(float(subpixels[3] * subpixels[0]) / 0xFF);
   subpixels[1] = uint8_t(float(subpixels[3] * subpixels[1]) / 0xFF);
   subpixels[2] = uint8_t(float(subpixels[3] * subpixels[2]) / 0xFF);
   uint32_t premultiplied;
   memcpy(&premultiplied, subpixels, sizeof(premultiplied));
   for (uint32_t* lastPixel = pixelData + instanceData->backBuffer->size.width * instanceData->backBuffer->size.height;
 	pixelData < lastPixel;
 	++pixelData) {
     *pixelData = premultiplied;
   }
   NPN_SetCurrentAsyncSurface(npp, instanceData->backBuffer, nullptr);
   NPAsyncSurface *oldFront = instanceData->frontBuffer;
   instanceData->frontBuffer = instanceData->backBuffer;
   instanceData->backBuffer = oldFront;
 }
 static bool bug813906(NPP npp, const char* const function, const char* const url, const char* const frame)
 {
   NPObject *windowObj = nullptr;
   NPError err = NPN_GetValue(npp, NPNVWindowNPObject, &windowObj);
   if (err != NPERR_NO_ERROR) {
     return false;
   }
   NPVariant result;
   bool res = NPN_Invoke(npp, windowObj, NPN_GetStringIdentifier(function), nullptr, 0, &result);
   NPN_ReleaseObject(windowObj);
   if (!res) {
     return false;
   }
   NPN_ReleaseVariantValue(&result);
   err = NPN_GetURL(npp, url, frame);
   if (err != NPERR_NO_ERROR) {
     err = NPN_GetURL(npp, "about:blank", frame);
     return false;
   }
   return true;
 }
 //
 // function signatures
 //
 NPObject* scriptableAllocate(NPP npp, NPClass* aClass);
 void scriptableDeallocate(NPObject* npobj);
 void scriptableInvalidate(NPObject* npobj);
 bool scriptableHasMethod(NPObject* npobj, NPIdentifier name);
 bool scriptableInvoke(NPObject* npobj, NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result);
 bool scriptableInvokeDefault(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 bool scriptableHasProperty(NPObject* npobj, NPIdentifier name);
 bool scriptableGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result);
 bool scriptableSetProperty(NPObject* npobj, NPIdentifier name, const NPVariant* value);
 bool scriptableRemoveProperty(NPObject* npobj, NPIdentifier name);
 bool scriptableEnumerate(NPObject* npobj, NPIdentifier** identifier, uint32_t* count);
 bool scriptableConstruct(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result);
 //
 // npapi plugin functions
 //
 #ifdef XP_UNIX
 NP_EXPORT(char*)
 NP_GetPluginVersion()
 {
   return sPluginVersion;
 }
 #endif
 extern const char *sMimeDescription;
 #if defined(XP_UNIX)
 NP_EXPORT(const char*) NP_GetMIMEDescription()
 #elif defined(XP_WIN)
 const char* NP_GetMIMEDescription()
 #endif
 {
   return sMimeDescription;
 }
 #ifdef XP_UNIX
 NP_EXPORT(NPError)
 NP_GetValue(void* future, NPPVariable aVariable, void* aValue) {
   switch (aVariable) {
     case NPPVpluginNameString:
       *((const char**)aValue) = sPluginName;
       break;
     case NPPVpluginDescriptionString:
       *((const char**)aValue) = sPluginDescription;
       break;
     default:
       return NPERR_INVALID_PARAM;
       break;
   }
   return NPERR_NO_ERROR;
 }
 #endif
 static bool fillPluginFunctionTable(NPPluginFuncs* pFuncs)
 {
   // Check the size of the provided structure based on the offset of the
   // last member we need.
   if (pFuncs->size < (offsetof(NPPluginFuncs, getsiteswithdata) + sizeof(void*)))
     return false;
   pFuncs->newp = NPP_New;
   pFuncs->destroy = NPP_Destroy;
   pFuncs->setwindow = NPP_SetWindow;
   pFuncs->newstream = NPP_NewStream;
   pFuncs->destroystream = NPP_DestroyStream;
   pFuncs->asfile = NPP_StreamAsFile;
   pFuncs->writeready = NPP_WriteReady;
   pFuncs->write = NPP_Write;
   pFuncs->print = NPP_Print;
   pFuncs->event = NPP_HandleEvent;
   pFuncs->urlnotify = NPP_URLNotify;
   pFuncs->getvalue = NPP_GetValue;
   pFuncs->setvalue = NPP_SetValue;
   pFuncs->urlredirectnotify = NPP_URLRedirectNotify;
   pFuncs->clearsitedata = NPP_ClearSiteData;
   pFuncs->getsiteswithdata = NPP_GetSitesWithData;
   return true;
 }
 #if defined(XP_MACOSX)
 NP_EXPORT(NPError) NP_Initialize(NPNetscapeFuncs* bFuncs)
 #elif defined(XP_WIN)
 NPError OSCALL NP_Initialize(NPNetscapeFuncs* bFuncs)
 #elif defined(XP_UNIX)
 NP_EXPORT(NPError) NP_Initialize(NPNetscapeFuncs* bFuncs, NPPluginFuncs* pFuncs)
 #endif
 {
   sBrowserFuncs = bFuncs;
   initializeIdentifiers();
   for (unsigned int i = 0; i < ARRAY_LENGTH(sPluginPropertyValues); i++) {
     VOID_TO_NPVARIANT(sPluginPropertyValues[i]);
   }
   memset(&sNPClass, 0, sizeof(NPClass));
   sNPClass.structVersion =  NP_CLASS_STRUCT_VERSION;
   sNPClass.allocate =       (NPAllocateFunctionPtr)scriptableAllocate;
   sNPClass.deallocate =     (NPDeallocateFunctionPtr)scriptableDeallocate;
   sNPClass.invalidate =     (NPInvalidateFunctionPtr)scriptableInvalidate;
   sNPClass.hasMethod =      (NPHasMethodFunctionPtr)scriptableHasMethod;
   sNPClass.invoke =         (NPInvokeFunctionPtr)scriptableInvoke;
   sNPClass.invokeDefault =  (NPInvokeDefaultFunctionPtr)scriptableInvokeDefault;
   sNPClass.hasProperty =    (NPHasPropertyFunctionPtr)scriptableHasProperty;
   sNPClass.getProperty =    (NPGetPropertyFunctionPtr)scriptableGetProperty;
   sNPClass.setProperty =    (NPSetPropertyFunctionPtr)scriptableSetProperty;
   sNPClass.removeProperty = (NPRemovePropertyFunctionPtr)scriptableRemoveProperty;
   sNPClass.enumerate =      (NPEnumerationFunctionPtr)scriptableEnumerate;
   sNPClass.construct =      (NPConstructFunctionPtr)scriptableConstruct;
 #if defined(XP_UNIX) && !defined(XP_MACOSX)
   if (!fillPluginFunctionTable(pFuncs)) {
     return NPERR_INVALID_FUNCTABLE_ERROR;
   }
 #endif
   return NPERR_NO_ERROR;
 }
 #if defined(XP_MACOSX)
 NP_EXPORT(NPError) NP_GetEntryPoints(NPPluginFuncs* pFuncs)
 #elif defined(XP_WIN)
 NPError OSCALL NP_GetEntryPoints(NPPluginFuncs* pFuncs)
 #endif
 #if defined(XP_MACOSX) || defined(XP_WIN)
 {
   if (!fillPluginFunctionTable(pFuncs)) {
     return NPERR_INVALID_FUNCTABLE_ERROR;
   }
   return NPERR_NO_ERROR;
 }
 #endif
 #if defined(XP_UNIX)
 NP_EXPORT(NPError) NP_Shutdown()
 #elif defined(XP_WIN)
 NPError OSCALL NP_Shutdown()
 #endif
 {
   clearIdentifiers();
   for (unsigned int i = 0; i < ARRAY_LENGTH(sPluginPropertyValues); i++) {
     NPN_ReleaseVariantValue(&sPluginPropertyValues[i]);
   }
   return NPERR_NO_ERROR;
 }
 NPError
 NPP_New(NPMIMEType pluginType, NPP instance, uint16_t mode, int16_t argc, char* argn[], char* argv[], NPSavedData* saved)
 {
   // Make sure our pdata field is nullptr at this point. If it isn't, that
   // probably means the browser gave us uninitialized memory.
   if (instance->pdata) {
     printf("NPP_New called with non-NULL NPP->pdata pointer!\n");
     return NPERR_GENERIC_ERROR;
   }
   // Make sure we can render this plugin
   NPBool browserSupportsWindowless = false;
   NPN_GetValue(instance, NPNVSupportsWindowless, &browserSupportsWindowless);
   if (!browserSupportsWindowless && !pluginSupportsWindowMode()) {
     printf("Windowless mode not supported by the browser, windowed mode not supported by the plugin!\n");
     return NPERR_GENERIC_ERROR;
   }
   // set up our our instance data
   InstanceData* instanceData = new InstanceData;
   if (!instanceData)
     return NPERR_OUT_OF_MEMORY_ERROR;
   instanceData->npp = instance;
   instanceData->streamMode = NP_ASFILEONLY;
   instanceData->testFunction = FUNCTION_NONE;
   instanceData->functionToFail = FUNCTION_NONE;
   instanceData->failureCode = 0;
   instanceData->callOnDestroy = nullptr;
   instanceData->streamChunkSize = 1024;
   instanceData->streamBuf = nullptr;
   instanceData->streamBufSize = 0;
   instanceData->fileBuf = nullptr;
   instanceData->fileBufSize = 0;
   instanceData->throwOnNextInvoke = false;
   instanceData->runScriptOnPaint = false;
   instanceData->dontTouchElement = false;
   instanceData->testrange = nullptr;
   instanceData->hasWidget = false;
   instanceData->npnNewStream = false;
   instanceData->invalidateDuringPaint = false;
   instanceData->slowPaint = false;
   instanceData->writeCount = 0;
   instanceData->writeReadyCount = 0;
   memset(&instanceData->window, 0, sizeof(instanceData->window));
   instanceData->crashOnDestroy = false;
   instanceData->cleanupWidget = true; // only used by nptest_gtk
   instanceData->topLevelWindowActivationState = ACTIVATION_STATE_UNKNOWN;
   instanceData->topLevelWindowActivationEventCount = 0;
   instanceData->focusState = ACTIVATION_STATE_UNKNOWN;
   instanceData->focusEventCount = 0;
   instanceData->eventModel = 0;
   instanceData->closeStream = false;
   instanceData->wantsAllStreams = false;
   instanceData->asyncDrawing = AD_NONE;
   instanceData->frontBuffer = nullptr;
   instanceData->backBuffer = nullptr;
   instanceData->mouseUpEventCount = 0;
   instanceData->bugMode = -1;
   instance->pdata = instanceData;
   TestNPObject* scriptableObject = (TestNPObject*)NPN_CreateObject(instance, &sNPClass);
   if (!scriptableObject) {
     printf("NPN_CreateObject failed to create an object, can't create a plugin instance\n");
     free(instanceData);
     return NPERR_GENERIC_ERROR;
   }
   scriptableObject->npp = instance;
   scriptableObject->drawMode = DM_DEFAULT;
   scriptableObject->drawColor = 0;
   instanceData->scriptableObject = scriptableObject;
   instanceData->instanceCountWatchGeneration = sCurrentInstanceCountWatchGeneration;
   if (NP_FULL == mode) {
     instanceData->streamMode = NP_SEEK;
     instanceData->frame = "testframe";
     addRange(instanceData, "100,100");
   }
   bool requestWindow = false;
   // handle extra params
   for (int i = 0; i < argc; i++) {
     if (strcmp(argn[i], "drawmode") == 0) {
       if (strcmp(argv[i], "solid") == 0)
         scriptableObject->drawMode = DM_SOLID_COLOR;
     }
     else if (strcmp(argn[i], "color") == 0) {
       scriptableObject->drawColor = parseHexColor(argv[i], strlen(argv[i]));
     }
     else if (strcmp(argn[i], "wmode") == 0) {
       if (strcmp(argv[i], "window") == 0) {
         requestWindow = true;
       }
     }
     else if (strcmp(argn[i], "asyncmodel") == 0) {
       if (strcmp(argv[i], "bitmap") == 0) {
         if (pluginSupportsAsyncBitmapDrawing()) {
           instanceData->asyncDrawing = AD_BITMAP;
         }
       }
       if (strcmp(argv[i], "dxgi") == 0) {
         if (pluginSupportsAsyncDXGIDrawing()) {
           instanceData->asyncDrawing = AD_DXGI;
         }
       }
     }
     if (strcmp(argn[i], "streammode") == 0) {
       if (strcmp(argv[i], "normal") == 0) {
         instanceData->streamMode = NP_NORMAL;
       }
       else if ((strcmp(argv[i], "asfile") == 0) &&
                 strlen(argv[i]) == strlen("asfile")) {
         instanceData->streamMode = NP_ASFILE;
       }
       else if (strcmp(argv[i], "asfileonly") == 0) {
         instanceData->streamMode = NP_ASFILEONLY;
       }
       else if (strcmp(argv[i], "seek") == 0) {
         instanceData->streamMode = NP_SEEK;
       }
     }
     if (strcmp(argn[i], "streamchunksize") == 0) {
       instanceData->streamChunkSize = atoi(argv[i]);
     }
     if (strcmp(argn[i], "failurecode") == 0) {
       instanceData->failureCode = atoi(argv[i]);
     }
     if (strcmp(argn[i], "functiontofail") == 0) {
       instanceData->functionToFail = getFuncFromString(argv[i]);
     }
     if (strcmp(argn[i], "geturl") == 0) {
       instanceData->testUrl = argv[i];
       instanceData->testFunction = FUNCTION_NPP_GETURL;
     }
     if (strcmp(argn[i], "posturl") == 0) {
       instanceData->testUrl = argv[i];
       instanceData->testFunction = FUNCTION_NPP_POSTURL;
     }
     if (strcmp(argn[i], "geturlnotify") == 0) {
       instanceData->testUrl = argv[i];
       instanceData->testFunction = FUNCTION_NPP_GETURLNOTIFY;
     }
     if (strcmp(argn[i], "postmode") == 0) {
       if (strcmp(argv[i], "frame") == 0) {
         instanceData->postMode = POSTMODE_FRAME;
       }
       else if (strcmp(argv[i], "stream") == 0) {
         instanceData->postMode = POSTMODE_STREAM;
       }
     }
     if (strcmp(argn[i], "frame") == 0) {
       instanceData->frame = argv[i];
     }
     if (strcmp(argn[i], "range") == 0) {
       string range = argv[i];
       size_t semicolon = range.find(';');
       while (semicolon != string::npos) {
         addRange(instanceData, range.substr(0, semicolon).c_str());
         if (semicolon == range.length()) {
           range = "";
           break;
         }
         range = range.substr(semicolon + 1);
         semicolon = range.find(';');
       }
       if (range.length()) addRange(instanceData, range.c_str());
     }
     if (strcmp(argn[i], "newstream") == 0 &&
         strcmp(argv[i], "true") == 0) {
       instanceData->npnNewStream = true;
     }
     if (strcmp(argn[i], "newcrash") == 0) {
       IntentionalCrash();
     }
     if (strcmp(argn[i], "paintscript") == 0) {
       instanceData->runScriptOnPaint = true;
     }
     if (strcmp(argn[i], "donttouchelement") == 0) {
       instanceData->dontTouchElement = true;
     }
     // "cleanupwidget" is only used with nptest_gtk, defaulting to true.  It
     // indicates whether the plugin should destroy its window in response to
     // NPP_Destroy (or let the platform destroy the widget when the parent
     // window gets destroyed).
     if (strcmp(argn[i], "cleanupwidget") == 0 &&
         strcmp(argv[i], "false") == 0) {
       instanceData->cleanupWidget = false;
     }
     if (!strcmp(argn[i], "closestream")) {
       instanceData->closeStream = true;
     }
     if (strcmp(argn[i], "bugmode") == 0) {
       instanceData->bugMode = atoi(argv[i]);
     }
     // Try to emulate java's codebase handling: Use the last seen codebase
     // value, regardless of whether it is in attributes or params.
     if (strcasecmp(argn[i], "codebase") == 0) {
       instanceData->javaCodebase = argv[i];
     }
   }
   if (!browserSupportsWindowless || !pluginSupportsWindowlessMode()) {
     requestWindow = true;
   } else if (!pluginSupportsWindowMode()) {
     requestWindow = false;
   }
   if (requestWindow) {
     instanceData->hasWidget = true;
   } else {
     // NPPVpluginWindowBool should default to true, so we may as well
     // test that by not setting it in the window case
     NPN_SetValue(instance, NPPVpluginWindowBool, (void*)false);
   }
   if (scriptableObject->drawMode == DM_SOLID_COLOR &&
       (scriptableObject->drawColor & 0xFF000000) != 0xFF000000) {
     NPN_SetValue(instance, NPPVpluginTransparentBool, (void*)true);
   }
   if (instanceData->asyncDrawing == AD_BITMAP) {
     NPBool supportsAsyncBitmap = false;
     if ((NPN_GetValue(instance, NPNVsupportsAsyncBitmapSurfaceBool, &supportsAsyncBitmap) == NPERR_NO_ERROR) &&
         supportsAsyncBitmap) {
       NPN_SetValue(instance, NPPVpluginDrawingModel, (void*)NPDrawingModelAsyncBitmapSurface);
     } else {
       instanceData->asyncDrawing = AD_NONE;
     }
   }
 #ifdef XP_WIN
   else if (instanceData->asyncDrawing == AD_DXGI) {
     NPBool supportsAsyncDXGI = false;
     if ((NPN_GetValue(instance, NPNVsupportsAsyncWindowsDXGISurfaceBool, &supportsAsyncDXGI) == NPERR_NO_ERROR) &&
         supportsAsyncDXGI) {
       NPN_SetValue(instance, NPPVpluginDrawingModel, (void*)NPDrawingModelAsyncWindowsDXGISurface);
     } else {
       instanceData->asyncDrawing = AD_NONE;
     }
   }
 #endif
   instanceData->lastReportedPrivateModeState = false;
   instanceData->lastMouseX = instanceData->lastMouseY = -1;
   instanceData->widthAtLastPaint = -1;
   instanceData->paintCount = 0;
   // do platform-specific initialization
   NPError err = pluginInstanceInit(instanceData);
   if (err != NPERR_NO_ERROR) {
     NPN_ReleaseObject(scriptableObject);
     free(instanceData);
     return err;
   }
   NPVariant variantTrue;
   BOOLEAN_TO_NPVARIANT(true, variantTrue);
   NPObject* o = nullptr;
   // Set a property on NPNVPluginElementNPObject, unless the consumer explicitly
   // opted out of this behavior.
   if (!instanceData->dontTouchElement) {
     err = NPN_GetValue(instance, NPNVPluginElementNPObject, &o);
     if (err == NPERR_NO_ERROR) {
       NPN_SetProperty(instance, o,
                       NPN_GetStringIdentifier("pluginFoundElement"), &variantTrue);
       NPN_ReleaseObject(o);
       o = nullptr;
     }
   }
   // Set a property on NPNVWindowNPObject
   err = NPN_GetValue(instance, NPNVWindowNPObject, &o);
   if (err == NPERR_NO_ERROR) {
     NPN_SetProperty(instance, o,
                     NPN_GetStringIdentifier("pluginFoundWindow"), &variantTrue);
     NPN_ReleaseObject(o);
     o = nullptr;
   }
   ++sInstanceCount;
   if (instanceData->testFunction == FUNCTION_NPP_GETURL) {
     NPError err = NPN_GetURL(instance, instanceData->testUrl.c_str(), nullptr);
     if (err != NPERR_NO_ERROR) {
       instanceData->err << "NPN_GetURL returned " << err;
     }
   }
   else if (instanceData->testFunction == FUNCTION_NPP_GETURLNOTIFY) {
     NPError err = NPN_GetURLNotify(instance, instanceData->testUrl.c_str(),
                                    nullptr, static_cast<void*>(&kNotifyData));
     if (err != NPERR_NO_ERROR) {
       instanceData->err << "NPN_GetURLNotify returned " << err;
     }
   }
   if ((instanceData->bugMode == 813906) && instanceData->frame.length()) {
     bug813906(instance, "f", "browser.xul", instanceData->frame.c_str());
   }
   return NPERR_NO_ERROR;
 }
 NPError
 NPP_Destroy(NPP instance, NPSavedData** save)
 {
   printf("NPP_Destroy\n");
   InstanceData* instanceData = (InstanceData*)(instance->pdata);
   if (instanceData->crashOnDestroy)
     IntentionalCrash();
   if (instanceData->callOnDestroy) {
     NPVariant result;
     NPN_InvokeDefault(instance, instanceData->callOnDestroy, nullptr, 0, &result);
     NPN_ReleaseVariantValue(&result);
     NPN_ReleaseObject(instanceData->callOnDestroy);
   }
   if (instanceData->streamBuf) {
     free(instanceData->streamBuf);
   }
   if (instanceData->fileBuf) {
     free(instanceData->fileBuf);
   }
   TestRange* currentrange = instanceData->testrange;
   TestRange* nextrange;
   while (currentrange != nullptr) {
     nextrange = reinterpret_cast<TestRange*>(currentrange->next);
     delete currentrange;
     currentrange = nextrange;
   }
   if (instanceData->frontBuffer) {
     NPN_SetCurrentAsyncSurface(instance, nullptr, nullptr);
     NPN_FinalizeAsyncSurface(instance, instanceData->frontBuffer);
     NPN_MemFree(instanceData->frontBuffer);
   }
   if (instanceData->backBuffer) {
     NPN_FinalizeAsyncSurface(instance, instanceData->backBuffer);
     NPN_MemFree(instanceData->backBuffer);
   }
   pluginInstanceShutdown(instanceData);
   NPN_ReleaseObject(instanceData->scriptableObject);
   if (sCurrentInstanceCountWatchGeneration == instanceData->instanceCountWatchGeneration) {
     --sInstanceCount;
   }
   delete instanceData;
   return NPERR_NO_ERROR;
 }
 NPError
 NPP_SetWindow(NPP instance, NPWindow* window)
 {
   InstanceData* instanceData = (InstanceData*)(instance->pdata);
   if (instanceData->scriptableObject->drawMode == DM_DEFAULT &&
       (instanceData->window.width != window->width ||
        instanceData->window.height != window->height)) {
     NPRect r;
     r.left = r.top = 0;
     r.right = window->width;
     r.bottom = window->height;
     NPN_InvalidateRect(instance, &r);
   }
   void* oldWindow = instanceData->window.window;
   pluginDoSetWindow(instanceData, window);
   if (instanceData->hasWidget && oldWindow != instanceData->window.window) {
     pluginWidgetInit(instanceData, oldWindow);
   }
   if (instanceData->asyncDrawing == AD_BITMAP) {
     if (instanceData->frontBuffer &&
 	instanceData->frontBuffer->size.width >= 0 &&
        (uint32_t)instanceData->frontBuffer->size.width == window->width &&
        instanceData ->frontBuffer->size.height >= 0 &&
        (uint32_t)instanceData->frontBuffer->size.height == window->height) {
           return NPERR_NO_ERROR;
     }
     if (instanceData->frontBuffer) {
       NPN_FinalizeAsyncSurface(instance, instanceData->frontBuffer);
       NPN_MemFree(instanceData->frontBuffer);
     }
     if (instanceData->backBuffer) {
       NPN_FinalizeAsyncSurface(instance, instanceData->backBuffer);
       NPN_MemFree(instanceData->backBuffer);
     }
     instanceData->frontBuffer = (NPAsyncSurface*)NPN_MemAlloc(sizeof(NPAsyncSurface));
     instanceData->backBuffer = (NPAsyncSurface*)NPN_MemAlloc(sizeof(NPAsyncSurface));
     NPSize size;
     size.width = window->width;
     size.height = window->height;
     memcpy(instanceData->backBuffer, instanceData->frontBuffer, sizeof(NPAsyncSurface));
     NPN_InitAsyncSurface(instance, &size, NPImageFormatBGRA32, nullptr, instanceData->frontBuffer);
     NPN_InitAsyncSurface(instance, &size, NPImageFormatBGRA32, nullptr, instanceData->backBuffer);
     drawAsyncBitmapColor(instanceData);
   }
   return NPERR_NO_ERROR;
 }
 NPError
 NPP_NewStream(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16_t* stype)
 {
   printf("NPP_NewStream\n");
   InstanceData* instanceData = (InstanceData*)(instance->pdata);
   if (instanceData->functionToFail == FUNCTION_NPP_NEWSTREAM &&
       instanceData->failureCode) {
     instanceData->err << SUCCESS_STRING;
     if (instanceData->frame.length() > 0) {
       sendBufferToFrame(instance);
     }
     return instanceData->failureCode;
   }
   if (stream->notifyData &&
       static_cast<URLNotifyData*>(stream->notifyData) != &kNotifyData) {
     // stream from streamTest
     *stype = NP_NORMAL;
   }
   else {
     *stype = instanceData->streamMode;
     if (instanceData->streamBufSize) {
       free(instanceData->streamBuf);
       instanceData->streamBufSize = 0;
       if (instanceData->testFunction == FUNCTION_NPP_POSTURL &&
           instanceData->postMode == POSTMODE_STREAM) {
         instanceData->testFunction = FUNCTION_NPP_GETURL;
       }
       else {
         // We already got a stream and didn't ask for another one.
         instanceData->err << "Received unexpected multiple NPP_NewStream";
       }
     }
   }
   return NPERR_NO_ERROR;
 }
 NPError
 NPP_DestroyStream(NPP instance, NPStream* stream, NPReason reason)
 {
   printf("NPP_DestroyStream\n");
   InstanceData* instanceData = (InstanceData*)(instance->pdata);
   if (instanceData->functionToFail == FUNCTION_NPP_NEWSTREAM) {
     instanceData->err << "NPP_DestroyStream called";
   }
   if (instanceData->functionToFail == FUNCTION_NPP_WRITE) {
     if (instanceData->writeCount == 1)
       instanceData->err << SUCCESS_STRING;
     else
       instanceData->err << "NPP_Write called after returning -1";
   }
   if (instanceData->functionToFail == FUNCTION_NPP_DESTROYSTREAM &&
       instanceData->failureCode) {
     instanceData->err << SUCCESS_STRING;
     if (instanceData->frame.length() > 0) {
       sendBufferToFrame(instance);
     }
     return instanceData->failureCode;
   }
   URLNotifyData* nd = static_cast<URLNotifyData*>(stream->notifyData);
   if (nd && nd != &kNotifyData) {
     return NPERR_NO_ERROR;
   }
   if (instanceData->streamMode == NP_ASFILE &&
       instanceData->functionToFail == FUNCTION_NONE) {
     if (!instanceData->streamBuf) {
       instanceData->err <<
         "Error: no data written with NPP_Write";
       return NPERR_GENERIC_ERROR;
     }
     if (!instanceData->fileBuf) {
       instanceData->err <<
         "Error: no data written with NPP_StreamAsFile";
       return NPERR_GENERIC_ERROR;
     }
     if (strcmp(reinterpret_cast<char *>(instanceData->fileBuf),
                reinterpret_cast<char *>(instanceData->streamBuf))) {
       instanceData->err <<
         "Error: data passed to NPP_Write and NPP_StreamAsFile differed";
     }
   }
   if (instanceData->frame.length() > 0 &&
       instanceData->testFunction != FUNCTION_NPP_GETURLNOTIFY &&
       instanceData->testFunction != FUNCTION_NPP_POSTURL) {
     sendBufferToFrame(instance);
   }
   if (instanceData->testFunction == FUNCTION_NPP_POSTURL) {
     NPError err = NPN_PostURL(instance, instanceData->testUrl.c_str(),
       instanceData->postMode == POSTMODE_FRAME ? instanceData->frame.c_str() : nullptr,
       instanceData->streamBufSize,
       reinterpret_cast<char *>(instanceData->streamBuf), false);
     if (err != NPERR_NO_ERROR)
       instanceData->err << "Error: NPN_PostURL returned error value " << err;
   }
   return NPERR_NO_ERROR;
 }
 int32_t
 NPP_WriteReady(NPP instance, NPStream* stream)
 {
   printf("NPP_WriteReady\n");
   InstanceData* instanceData = (InstanceData*)(instance->pdata);
   instanceData->writeReadyCount++;
   if (instanceData->functionToFail == FUNCTION_NPP_NEWSTREAM) {
     instanceData->err << "NPP_WriteReady called";
   }
   // temporarily disabled per bug 519870
   //if (instanceData->writeReadyCount == 1) {
   //  return 0;
   //}
   return instanceData->streamChunkSize;
 }
 int32_t
 NPP_Write(NPP instance, NPStream* stream, int32_t offset, int32_t len, void* buffer)
 {
   InstanceData* instanceData = (InstanceData*)(instance->pdata);
   instanceData->writeCount++;
   // temporarily disabled per bug 519870
   //if (instanceData->writeReadyCount == 1) {
   //  instanceData->err << "NPP_Write called even though NPP_WriteReady " <<
   //      "returned 0";
   //}
   if (instanceData->functionToFail == FUNCTION_NPP_WRITE_RPC) {
     // Make an RPC call and pretend to consume the data
     NPObject* windowObject = nullptr;
     NPN_GetValue(instance, NPNVWindowNPObject, &windowObject);
     if (windowObject)
       NPN_ReleaseObject(windowObject);
     return len;
   }
   if (instanceData->functionToFail == FUNCTION_NPP_NEWSTREAM) {
     instanceData->err << "NPP_Write called";
   }
   if (instanceData->functionToFail == FUNCTION_NPP_WRITE) {
     return -1;
   }
   URLNotifyData* nd = static_cast<URLNotifyData*>(stream->notifyData);
   if (nd && nd->writeCallback) {
     NPVariant args[1];
     STRINGN_TO_NPVARIANT(stream->url, strlen(stream->url), args[0]);
     NPVariant result;
     NPN_InvokeDefault(instance, nd->writeCallback, args, 1, &result);
     NPN_ReleaseVariantValue(&result);
   }
   if (nd && nd != &kNotifyData) {
     uint32_t newsize = nd->size + len;
     nd->data = (char*) realloc(nd->data, newsize);
     memcpy(nd->data + nd->size, buffer, len);
     nd->size = newsize;
     return len;
   }
   if (instanceData->closeStream) {
     instanceData->closeStream = false;
     if (instanceData->testrange != nullptr) {
       NPN_RequestRead(stream, instanceData->testrange);
     }
     NPN_DestroyStream(instance, stream, NPRES_USER_BREAK);
   }
   else if (instanceData->streamMode == NP_SEEK &&
       stream->end != 0 &&
       stream->end == ((uint32_t)instanceData->streamBufSize + len)) {
     // If the complete stream has been written, and we're doing a seek test,
     // then call NPN_RequestRead.
     // prevent recursion
     instanceData->streamMode = NP_NORMAL;
     if (instanceData->testrange != nullptr) {
       NPError err = NPN_RequestRead(stream, instanceData->testrange);
       if (err != NPERR_NO_ERROR) {
         instanceData->err << "NPN_RequestRead returned error %d" << err;
       }
       printf("called NPN_RequestRead, return %d\n", err);
     }
   }
   char* streamBuf = reinterpret_cast<char *>(instanceData->streamBuf);
   if (offset + len <= instanceData->streamBufSize) {
     if (memcmp(buffer, streamBuf + offset, len)) {
       instanceData->err <<
           "Error: data written from NPN_RequestRead doesn't match";
     }
     else {
       printf("data matches!\n");
     }
     TestRange* range = instanceData->testrange;
     bool stillwaiting = false;
     while(range != nullptr) {
       if (offset == range->offset &&
         (uint32_t)len == range->length) {
         range->waiting = false;
       }
       if (range->waiting) stillwaiting = true;
       range = reinterpret_cast<TestRange*>(range->next);
     }
     if (!stillwaiting) {
       NPError err = NPN_DestroyStream(instance, stream, NPRES_DONE);
       if (err != NPERR_NO_ERROR) {
         instanceData->err << "Error: NPN_DestroyStream returned " << err;
       }
     }
   }
   else {
     if (instanceData->streamBufSize == 0) {
       instanceData->streamBuf = malloc(len + 1);
       streamBuf = reinterpret_cast<char *>(instanceData->streamBuf);
     }
     else {
       instanceData->streamBuf =
         realloc(reinterpret_cast<char *>(instanceData->streamBuf),
         instanceData->streamBufSize + len + 1);
       streamBuf = reinterpret_cast<char *>(instanceData->streamBuf);
     }
     memcpy(streamBuf + instanceData->streamBufSize, buffer, len);
     instanceData->streamBufSize = instanceData->streamBufSize + len;
     streamBuf[instanceData->streamBufSize] = '\0';
   }
   return len;
 }
 void
 NPP_StreamAsFile(NPP instance, NPStream* stream, const char* fname)
 {
   printf("NPP_StreamAsFile, file=%s\n", fname);
   size_t size;
   InstanceData* instanceData = (InstanceData*)(instance->pdata);
   if (instanceData->functionToFail == FUNCTION_NPP_NEWSTREAM ||
       instanceData->functionToFail == FUNCTION_NPP_WRITE) {
     instanceData->err << "NPP_StreamAsFile called";
   }
   if (!fname)
     return;
   FILE *file = fopen(fname, "rb");
   if (file) {
     fseek(file, 0, SEEK_END);
     size = ftell(file);
     instanceData->fileBuf = malloc((int32_t)size + 1);
     char* buf = reinterpret_cast<char *>(instanceData->fileBuf);
     fseek(file, 0, SEEK_SET);
     size_t sizeRead = fread(instanceData->fileBuf, 1, size, file);
     if (sizeRead != size) {
       printf("Unable to read data from file\n");
       instanceData->err << "Unable to read data from file " << fname;
     }
     fclose(file);
     buf[size] = '\0';
     instanceData->fileBufSize = (int32_t)size;
   }
   else {
     printf("Unable to open file\n");
     instanceData->err << "Unable to open file " << fname;
   }
 }
 void
 NPP_Print(NPP instance, NPPrint* platformPrint)
 {
 }
 int16_t
 NPP_HandleEvent(NPP instance, void* event)
 {
   InstanceData* instanceData = (InstanceData*)(instance->pdata);
   return pluginHandleEvent(instanceData, event);
 }
 void
 NPP_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData)
 {
   InstanceData* instanceData = (InstanceData*)(instance->pdata);
   URLNotifyData* ndata = static_cast<URLNotifyData*>(notifyData);
   printf("NPP_URLNotify called\n");
   if (&kNotifyData == ndata) {
     if (instanceData->frame.length() > 0) {
       sendBufferToFrame(instance);
     }
   }
   else if (!strcmp(ndata->cookie, "dynamic-cookie")) {
     if (ndata->notifyCallback) {
       NPVariant args[2];
       INT32_TO_NPVARIANT(reason, args[0]);
       if (ndata->data) {
         STRINGN_TO_NPVARIANT(ndata->data, ndata->size, args[1]);
       }
       else {
         STRINGN_TO_NPVARIANT("", 0, args[1]);
       }
       NPVariant result;
       NPN_InvokeDefault(instance, ndata->notifyCallback, args, 2, &result);
       NPN_ReleaseVariantValue(&result);
     }
     // clean up the URLNotifyData
     if (ndata->writeCallback) {
       NPN_ReleaseObject(ndata->writeCallback);
     }
     if (ndata->notifyCallback) {
       NPN_ReleaseObject(ndata->notifyCallback);
     }
     if (ndata->redirectCallback) {
       NPN_ReleaseObject(ndata->redirectCallback);
     }
     free(ndata->data);
     delete ndata;
   }
   else {
     printf("ERROR! NPP_URLNotify called with wrong cookie\n");
     instanceData->err << "Error: NPP_URLNotify called with wrong cookie";
   }
 }
 NPError
 NPP_GetValue(NPP instance, NPPVariable variable, void* value)
 {
   InstanceData* instanceData = (InstanceData*)instance->pdata;
   if (variable == NPPVpluginScriptableNPObject) {
     NPObject* object = instanceData->scriptableObject;
     NPN_RetainObject(object);
     *((NPObject**)value) = object;
     return NPERR_NO_ERROR;
   }
   if (variable == NPPVpluginNeedsXEmbed) {
     // Only relevant for X plugins
     // use 4-byte writes like some plugins may do
     *(uint32_t*)value = instanceData->hasWidget;
     return NPERR_NO_ERROR;
   }
   if (variable == NPPVpluginWantsAllNetworkStreams) {
     // use 4-byte writes like some plugins may do
     *(uint32_t*)value = instanceData->wantsAllStreams;
     return NPERR_NO_ERROR;
   }
   return NPERR_GENERIC_ERROR;
 }
 NPError
 NPP_SetValue(NPP instance, NPNVariable variable, void* value)
 {
   if (variable == NPNVprivateModeBool) {
     InstanceData* instanceData = (InstanceData*)(instance->pdata);
     instanceData->lastReportedPrivateModeState = bool(*static_cast<NPBool*>(value));
     return NPERR_NO_ERROR;
   }
   return NPERR_GENERIC_ERROR;
 }
 void
 NPP_URLRedirectNotify(NPP instance, const char* url, int32_t status, void* notifyData)
 {
   if (notifyData) {
     URLNotifyData* nd = static_cast<URLNotifyData*>(notifyData);
     if (nd->redirectCallback) {
       NPVariant args[2];
       STRINGN_TO_NPVARIANT(url, strlen(url), args[0]);
       INT32_TO_NPVARIANT(status, args[1]);
       NPVariant result;
       NPN_InvokeDefault(instance, nd->redirectCallback, args, 2, &result);
       NPN_ReleaseVariantValue(&result);
     }
     NPN_URLRedirectResponse(instance, notifyData, nd->allowRedirects);
     return;
   }
   NPN_URLRedirectResponse(instance, notifyData, true);
 }
 NPError
 NPP_ClearSiteData(const char* site, uint64_t flags, uint64_t maxAge)
 {
   if (!sSitesWithData)
     return NPERR_NO_ERROR;
   // Error condition: no support for clear-by-age
   if (!sClearByAgeSupported && maxAge != uint64_t(int64_t(-1)))
     return NPERR_TIME_RANGE_NOT_SUPPORTED;
   // Iterate over list and remove matches
   list<siteData>::iterator iter = sSitesWithData->begin();
   list<siteData>::iterator end = sSitesWithData->end();
   while (iter != end) {
     const siteData& data = *iter;
     list<siteData>::iterator next = iter;
     ++next;
     if ((!site || data.site.compare(site) == 0) &&
         (flags == NP_CLEAR_ALL || data.flags & flags) &&
         data.age <= maxAge) {
       sSitesWithData->erase(iter);
     }
     iter = next;
   }
   return NPERR_NO_ERROR;
 }
 char**
 NPP_GetSitesWithData()
 {
   int length = 0;
   char** result;
   if (sSitesWithData)
     length = sSitesWithData->size();
   // Allocate the maximum possible size the list could be.
   result = static_cast<char**>(NPN_MemAlloc((length + 1) * sizeof(char*)));
   result[length] = nullptr;
   if (length == 0) {
     // Represent the no site data case as an array of length 1 with a nullptr
     // entry.
     return result;
   }
   // Iterate the list of stored data, and build a list of strings.
   list<string> sites;
   {
     list<siteData>::iterator iter = sSitesWithData->begin();
     list<siteData>::iterator end = sSitesWithData->end();
     for (; iter != end; ++iter) {
       const siteData& data = *iter;
       sites.push_back(data.site);
     }
   }
   // Remove duplicate strings.
   sites.sort();
   sites.unique();
   // Add strings to the result array, and null terminate.
   {
     int i = 0;
     list<string>::iterator iter = sites.begin();
     list<string>::iterator end = sites.end();
     for (; iter != end; ++iter, ++i) {
       const string& site = *iter;
       result[i] = static_cast<char*>(NPN_MemAlloc(site.length() + 1));
       memcpy(result[i], site.c_str(), site.length() + 1);
     }
   }
   result[sites.size()] = nullptr;
   return result;
 }
 //
 // npapi browser functions
 //
 bool
 NPN_SetProperty(NPP instance, NPObject* obj, NPIdentifier propertyName, const NPVariant* value)
 {
   return sBrowserFuncs->setproperty(instance, obj, propertyName, value);
 }
 NPIdentifier
 NPN_GetIntIdentifier(int32_t intid)
 {
   return sBrowserFuncs->getintidentifier(intid);
 }
 NPIdentifier
 NPN_GetStringIdentifier(const NPUTF8* name)
 {
   return sBrowserFuncs->getstringidentifier(name);
 }
 void
 NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers)
 {
   return sBrowserFuncs->getstringidentifiers(names, nameCount, identifiers);
 }
 bool
 NPN_IdentifierIsString(NPIdentifier identifier)
 {
   return sBrowserFuncs->identifierisstring(identifier);
 }
 NPUTF8*
 NPN_UTF8FromIdentifier(NPIdentifier identifier)
 {
   return sBrowserFuncs->utf8fromidentifier(identifier);
 }
 int32_t
 NPN_IntFromIdentifier(NPIdentifier identifier)
 {
   return sBrowserFuncs->intfromidentifier(identifier);
 }
 NPError
 NPN_GetValue(NPP instance, NPNVariable variable, void* value)
 {
   return sBrowserFuncs->getvalue(instance, variable, value);
 }
 NPError
 NPN_SetValue(NPP instance, NPPVariable variable, void* value)
 {
   return sBrowserFuncs->setvalue(instance, variable, value);
 }
 void
 NPN_InvalidateRect(NPP instance, NPRect* rect)
 {
   sBrowserFuncs->invalidaterect(instance, rect);
 }
 bool
 NPN_HasProperty(NPP instance, NPObject* obj, NPIdentifier propertyName)
 {
   return sBrowserFuncs->hasproperty(instance, obj, propertyName);
 }
 NPObject*
 NPN_CreateObject(NPP instance, NPClass* aClass)
 {
   return sBrowserFuncs->createobject(instance, aClass);
 }
 bool
 NPN_Invoke(NPP npp, NPObject* obj, NPIdentifier methodName, const NPVariant *args, uint32_t argCount, NPVariant *result)
 {
   return sBrowserFuncs->invoke(npp, obj, methodName, args, argCount, result);
 }
 bool
 NPN_InvokeDefault(NPP npp, NPObject* obj, const NPVariant *args, uint32_t argCount, NPVariant *result)
 {
   return sBrowserFuncs->invokeDefault(npp, obj, args, argCount, result);
 }
 bool
 NPN_Construct(NPP npp, NPObject* npobj, const NPVariant* args,
 	      uint32_t argCount, NPVariant* result)
 {
   return sBrowserFuncs->construct(npp, npobj, args, argCount, result);
 }
 const char*
 NPN_UserAgent(NPP instance)
 {
   return sBrowserFuncs->uagent(instance);
 }
 NPObject*
 NPN_RetainObject(NPObject* obj)
 {
   return sBrowserFuncs->retainobject(obj);
 }
 void
 NPN_ReleaseObject(NPObject* obj)
 {
   return sBrowserFuncs->releaseobject(obj);
 }
 void*
 NPN_MemAlloc(uint32_t size)
 {
   return sBrowserFuncs->memalloc(size);
 }
 char*
 NPN_StrDup(const char* str)
 {
   return strcpy((char*)sBrowserFuncs->memalloc(strlen(str) + 1), str);
 }
 void
 NPN_MemFree(void* ptr)
 {
   return sBrowserFuncs->memfree(ptr);
 }
 uint32_t
 NPN_ScheduleTimer(NPP instance, uint32_t interval, NPBool repeat, void (*timerFunc)(NPP npp, uint32_t timerID))
 {
   return sBrowserFuncs->scheduletimer(instance, interval, repeat, timerFunc);
 }
 void
 NPN_UnscheduleTimer(NPP instance, uint32_t timerID)
 {
   return sBrowserFuncs->unscheduletimer(instance, timerID);
 }
 void
 NPN_ReleaseVariantValue(NPVariant *variant)
 {
   return sBrowserFuncs->releasevariantvalue(variant);
 }
 NPError
 NPN_GetURLNotify(NPP instance, const char* url, const char* target, void* notifyData)
 {
   return sBrowserFuncs->geturlnotify(instance, url, target, notifyData);
 }
 NPError
 NPN_GetURL(NPP instance, const char* url, const char* target)
 {
   return sBrowserFuncs->geturl(instance, url, target);
 }
 NPError
 NPN_RequestRead(NPStream* stream, NPByteRange* rangeList)
 {
   return sBrowserFuncs->requestread(stream, rangeList);
 }
 NPError
 NPN_PostURLNotify(NPP instance, const char* url,
                   const char* target, uint32_t len,
                   const char* buf, NPBool file, void* notifyData)
 {
   return sBrowserFuncs->posturlnotify(instance, url, target, len, buf, file, notifyData);
 }
 NPError
 NPN_PostURL(NPP instance, const char *url,
                     const char *target, uint32_t len,
                     const char *buf, NPBool file)
 {
   return sBrowserFuncs->posturl(instance, url, target, len, buf, file);
 }
 NPError
 NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason)
 {
   return sBrowserFuncs->destroystream(instance, stream, reason);
 }
 NPError
 NPN_NewStream(NPP instance,
               NPMIMEType  type,
               const char* target,
               NPStream**  stream)
 {
   return sBrowserFuncs->newstream(instance, type, target, stream);
 }
 int32_t
 NPN_Write(NPP instance,
           NPStream* stream,
           int32_t len,
           void* buf)
 {
   return sBrowserFuncs->write(instance, stream, len, buf);
 }
 bool
 NPN_Enumerate(NPP instance,
               NPObject *npobj,
               NPIdentifier **identifiers,
               uint32_t *identifierCount)
 {
   return sBrowserFuncs->enumerate(instance, npobj, identifiers,
       identifierCount);
 }
 bool
 NPN_GetProperty(NPP instance,
                 NPObject *npobj,
                 NPIdentifier propertyName,
                 NPVariant *result)
 {
   return sBrowserFuncs->getproperty(instance, npobj, propertyName, result);
 }
 bool
 NPN_Evaluate(NPP instance, NPObject *npobj, NPString *script, NPVariant *result)
 {
   return sBrowserFuncs->evaluate(instance, npobj, script, result);
 }
 void
 NPN_SetException(NPObject *npobj, const NPUTF8 *message)
 {
   return sBrowserFuncs->setexception(npobj, message);
 }
 NPBool
 NPN_ConvertPoint(NPP instance, double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double *destX, double *destY, NPCoordinateSpace destSpace)
 {
   return sBrowserFuncs->convertpoint(instance, sourceX, sourceY, sourceSpace, destX, destY, destSpace);
 }
 NPError
 NPN_SetValueForURL(NPP instance, NPNURLVariable variable, const char *url, const char *value, uint32_t len)
 {
   return sBrowserFuncs->setvalueforurl(instance, variable, url, value, len);
 }
 NPError
 NPN_GetValueForURL(NPP instance, NPNURLVariable variable, const char *url, char **value, uint32_t *len)
 {
   return sBrowserFuncs->getvalueforurl(instance, variable, url, value, len);
 }
 NPError
 NPN_GetAuthenticationInfo(NPP instance,
                           const char *protocol,
                           const char *host, int32_t port,
                           const char *scheme,
                           const char *realm,
                           char **username, uint32_t *ulen,
                           char **password,
                           uint32_t *plen)
 {
   return sBrowserFuncs->getauthenticationinfo(instance, protocol, host, port, scheme, realm,
       username, ulen, password, plen);
 }
 void
 NPN_PluginThreadAsyncCall(NPP plugin, void (*func)(void*), void* userdata)
 {
   return sBrowserFuncs->pluginthreadasynccall(plugin, func, userdata);
 }
 void
 NPN_URLRedirectResponse(NPP instance, void* notifyData, NPBool allow)
 {
   return sBrowserFuncs->urlredirectresponse(instance, notifyData, allow);
 }
 NPError
 NPN_InitAsyncSurface(NPP instance, NPSize *size, NPImageFormat format,
                      void *initData, NPAsyncSurface *surface)
 {
   return sBrowserFuncs->initasyncsurface(instance, size, format, initData, surface);
 }
 NPError
 NPN_FinalizeAsyncSurface(NPP instance, NPAsyncSurface *surface)
 {
   return sBrowserFuncs->finalizeasyncsurface(instance, surface);
 }
 void
 NPN_SetCurrentAsyncSurface(NPP instance, NPAsyncSurface *surface, NPRect *changed)
 {
   sBrowserFuncs->setcurrentasyncsurface(instance, surface, changed);
 }
 //
 // npruntime object functions
 //
 NPObject*
 scriptableAllocate(NPP npp, NPClass* aClass)
 {
   TestNPObject* object = (TestNPObject*)NPN_MemAlloc(sizeof(TestNPObject));
   if (!object)
     return nullptr;
   memset(object, 0, sizeof(TestNPObject));
   return object;
 }
 void
 scriptableDeallocate(NPObject* npobj)
 {
   NPN_MemFree(npobj);
 }
 void
 scriptableInvalidate(NPObject* npobj)
 {
 }
 bool
 scriptableHasMethod(NPObject* npobj, NPIdentifier name)
 {
   for (int i = 0; i < int(ARRAY_LENGTH(sPluginMethodIdentifiers)); i++) {
     if (name == sPluginMethodIdentifiers[i])
       return true;
   }
   return false;
 }
 bool
 scriptableInvoke(NPObject* npobj, NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   if (id->throwOnNextInvoke) {
     id->throwOnNextInvoke = false;
     if (argCount == 0) {
       NPN_SetException(npobj, nullptr);
     }
     else {
       for (uint32_t i = 0; i < argCount; i++) {
         const NPString* argstr = &NPVARIANT_TO_STRING(args[i]);
         NPN_SetException(npobj, argstr->UTF8Characters);
       }
     }
     return false;
   }
   for (int i = 0; i < int(ARRAY_LENGTH(sPluginMethodIdentifiers)); i++) {
     if (name == sPluginMethodIdentifiers[i])
       return sPluginMethodFunctions[i](npobj, args, argCount, result);
   }
   return false;
 }
 bool
 scriptableInvokeDefault(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   if (id->throwOnNextInvoke) {
     id->throwOnNextInvoke = false;
     if (argCount == 0) {
       NPN_SetException(npobj, nullptr);
     }
     else {
       for (uint32_t i = 0; i < argCount; i++) {
         const NPString* argstr = &NPVARIANT_TO_STRING(args[i]);
         NPN_SetException(npobj, argstr->UTF8Characters);
       }
     }
     return false;
   }
   ostringstream value;
   value << sPluginName;
   for (uint32_t i = 0; i < argCount; i++) {
     switch(args[i].type) {
       case NPVariantType_Int32:
         value << ";" << NPVARIANT_TO_INT32(args[i]);
         break;
       case NPVariantType_String: {
         const NPString* argstr = &NPVARIANT_TO_STRING(args[i]);
         value << ";" << argstr->UTF8Characters;
         break;
       }
       case NPVariantType_Void:
         value << ";undefined";
         break;
       case NPVariantType_Null:
         value << ";null";
         break;
       default:
         value << ";other";
     }
   }
   char *outval = NPN_StrDup(value.str().c_str());
   STRINGZ_TO_NPVARIANT(outval, *result);
   return true;
 }
 bool
 scriptableHasProperty(NPObject* npobj, NPIdentifier name)
 {
   if (NPN_IdentifierIsString(name)) {
     NPUTF8 *asUTF8 = NPN_UTF8FromIdentifier(name);
     if (NPN_GetStringIdentifier(asUTF8) != name) {
       Crash();
     }
     NPN_MemFree(asUTF8);
   }
   else {
     if (NPN_GetIntIdentifier(NPN_IntFromIdentifier(name)) != name) {
       Crash();
     }
   }
   for (int i = 0; i < int(ARRAY_LENGTH(sPluginPropertyIdentifiers)); i++) {
     if (name == sPluginPropertyIdentifiers[i]) {
       return true;
     }
   }
   return false;
 }
 bool
 scriptableGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result)
 {
   for (int i = 0; i < int(ARRAY_LENGTH(sPluginPropertyIdentifiers)); i++) {
     if (name == sPluginPropertyIdentifiers[i]) {
       DuplicateNPVariant(*result, sPluginPropertyValues[i]);
       return true;
     }
   }
   return false;
 }
 bool
 scriptableSetProperty(NPObject* npobj, NPIdentifier name, const NPVariant* value)
 {
   for (int i = 0; i < int(ARRAY_LENGTH(sPluginPropertyIdentifiers)); i++) {
     if (name == sPluginPropertyIdentifiers[i]) {
       NPN_ReleaseVariantValue(&sPluginPropertyValues[i]);
       DuplicateNPVariant(sPluginPropertyValues[i], *value);
       return true;
     }
   }
   return false;
 }
 bool
 scriptableRemoveProperty(NPObject* npobj, NPIdentifier name)
 {
   for (int i = 0; i < int(ARRAY_LENGTH(sPluginPropertyIdentifiers)); i++) {
     if (name == sPluginPropertyIdentifiers[i]) {
       NPN_ReleaseVariantValue(&sPluginPropertyValues[i]);
       return true;
     }
   }
   return false;
 }
 bool
 scriptableEnumerate(NPObject* npobj, NPIdentifier** identifier, uint32_t* count)
 {
   const int bufsize = sizeof(NPIdentifier) * ARRAY_LENGTH(sPluginMethodIdentifierNames);
   NPIdentifier* ids = (NPIdentifier*) NPN_MemAlloc(bufsize);
   if (!ids)
     return false;
   memcpy(ids, sPluginMethodIdentifiers, bufsize);
   *identifier = ids;
   *count = ARRAY_LENGTH(sPluginMethodIdentifierNames);
   return true;
 }
 bool
 scriptableConstruct(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   return false;
 }
 //
 // test functions
 //
 static bool
 compareVariants(NPP instance, const NPVariant* var1, const NPVariant* var2)
 {
   bool success = true;
   InstanceData* id = static_cast<InstanceData*>(instance->pdata);
   if (var1->type != var2->type) {
     id->err << "Variant types don't match; got " << var1->type <<
         " expected " << var2->type;
     return false;
   }
   switch (var1->type) {
     case NPVariantType_Int32: {
         int32_t result = NPVARIANT_TO_INT32(*var1);
         int32_t expected = NPVARIANT_TO_INT32(*var2);
         if (result != expected) {
           id->err << "Variant values don't match; got " << result <<
               " expected " << expected;
           success = false;
         }
         break;
       }
     case NPVariantType_Double: {
         double result = NPVARIANT_TO_DOUBLE(*var1);
         double expected = NPVARIANT_TO_DOUBLE(*var2);
         if (result != expected) {
           id->err << "Variant values don't match (double)";
           success = false;
         }
         break;
       }
     case NPVariantType_Void: {
         // void values are always equivalent
         break;
       }
     case NPVariantType_Null: {
         // null values are always equivalent
         break;
       }
     case NPVariantType_Bool: {
         bool result = NPVARIANT_TO_BOOLEAN(*var1);
         bool expected = NPVARIANT_TO_BOOLEAN(*var2);
         if (result != expected) {
           id->err << "Variant values don't match (bool)";
           success = false;
         }
         break;
       }
     case NPVariantType_String: {
         const NPString* result = &NPVARIANT_TO_STRING(*var1);
         const NPString* expected = &NPVARIANT_TO_STRING(*var2);
         if (strcmp(result->UTF8Characters, expected->UTF8Characters) ||
             strlen(result->UTF8Characters) != strlen(expected->UTF8Characters)) {
           id->err << "Variant values don't match; got " <<
               result->UTF8Characters << " expected " <<
               expected->UTF8Characters;
           success = false;
         }
         break;
       }
     case NPVariantType_Object: {
         uint32_t i, identifierCount = 0;
         NPIdentifier* identifiers;
         NPObject* result = NPVARIANT_TO_OBJECT(*var1);
         NPObject* expected = NPVARIANT_TO_OBJECT(*var2);
         bool enumerate_result = NPN_Enumerate(instance, expected,
             &identifiers, &identifierCount);
         if (!enumerate_result) {
           id->err << "NPN_Enumerate failed";
           success = false;
         }
         for (i = 0; i < identifierCount; i++) {
           NPVariant resultVariant, expectedVariant;
           if (!NPN_GetProperty(instance, expected, identifiers[i],
               &expectedVariant)) {
             id->err << "NPN_GetProperty returned false";
             success = false;
           }
           else {
             if (!NPN_HasProperty(instance, result, identifiers[i])) {
               id->err << "NPN_HasProperty returned false";
               success = false;
             }
             else {
               if (!NPN_GetProperty(instance, result, identifiers[i],
               &resultVariant)) {
                 id->err << "NPN_GetProperty 2 returned false";
                 success = false;
               }
               else {
                 success = compareVariants(instance, &resultVariant,
                     &expectedVariant);
                 NPN_ReleaseVariantValue(&expectedVariant);
               }
             }
             NPN_ReleaseVariantValue(&resultVariant);
           }
         }
         break;
       }
     default:
       id->err << "Unknown variant type";
       success = false;
   }
   return success;
 }
 static bool
 throwExceptionNextInvoke(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   id->throwOnNextInvoke = true;
   BOOLEAN_TO_NPVARIANT(true, *result);
   return true;
 }
 static bool
 npnInvokeDefaultTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   bool success = false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   NPObject* windowObject;
   NPN_GetValue(npp, NPNVWindowNPObject, &windowObject);
   if (!windowObject)
     return false;
   NPIdentifier objectIdentifier = variantToIdentifier(args[0]);
   if (!objectIdentifier)
     return false;
   NPVariant objectVariant;
   if (NPN_GetProperty(npp, windowObject, objectIdentifier,
       &objectVariant)) {
     if (NPVARIANT_IS_OBJECT(objectVariant)) {
       NPObject* selfObject = NPVARIANT_TO_OBJECT(objectVariant);
       if (selfObject != nullptr) {
         NPVariant resultVariant;
         if (NPN_InvokeDefault(npp, selfObject, argCount > 1 ? &args[1] : nullptr,
             argCount - 1, &resultVariant)) {
           *result = resultVariant;
           success = true;
         }
       }
     }
     NPN_ReleaseVariantValue(&objectVariant);
   }
   NPN_ReleaseObject(windowObject);
   return success;
 }
 static bool
 npnInvokeTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   id->err.str("");
   if (argCount < 2)
     return false;
   NPIdentifier function = variantToIdentifier(args[0]);
   if (!function)
     return false;
   NPObject* windowObject;
   NPN_GetValue(npp, NPNVWindowNPObject, &windowObject);
   if (!windowObject)
     return false;
   NPVariant invokeResult;
   bool invokeReturn = NPN_Invoke(npp, windowObject, function,
       argCount > 2 ? &args[2] : nullptr, argCount - 2, &invokeResult);
   bool compareResult = compareVariants(npp, &invokeResult, &args[1]);
   NPN_ReleaseObject(windowObject);
   NPN_ReleaseVariantValue(&invokeResult);
   BOOLEAN_TO_NPVARIANT(invokeReturn && compareResult, *result);
   return true;
 }
 static bool
 npnEvaluateTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   bool success = false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   if (argCount != 1)
     return false;
   if (!NPVARIANT_IS_STRING(args[0]))
     return false;
   NPObject* windowObject;
   NPN_GetValue(npp, NPNVWindowNPObject, &windowObject);
   if (!windowObject)
     return false;
   success = NPN_Evaluate(npp, windowObject, (NPString*)&NPVARIANT_TO_STRING(args[0]), result);
   NPN_ReleaseObject(windowObject);
   return success;
 }
 static bool
 setUndefinedValueTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   NPError err = NPN_SetValue(npp, (NPPVariable)0x0, 0x0);
   BOOLEAN_TO_NPVARIANT((err == NPERR_NO_ERROR), *result);
   return true;
 }
 static bool
 identifierToStringTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 1)
     return false;
   NPIdentifier identifier = variantToIdentifier(args[0]);
   if (!identifier)
     return false;
   NPUTF8* utf8String = NPN_UTF8FromIdentifier(identifier);
   if (!utf8String)
     return false;
   STRINGZ_TO_NPVARIANT(utf8String, *result);
   return true;
 }
 static bool
 queryPrivateModeState(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPBool pms = false;
   NPN_GetValue(static_cast<TestNPObject*>(npobj)->npp, NPNVprivateModeBool, &pms);
   BOOLEAN_TO_NPVARIANT(pms, *result);
   return true;
 }
 static bool
 lastReportedPrivateModeState(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   InstanceData* id = static_cast<InstanceData*>(static_cast<TestNPObject*>(npobj)->npp->pdata);
   BOOLEAN_TO_NPVARIANT(id->lastReportedPrivateModeState, *result);
   return true;
 }
 static bool
 hasWidget(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   InstanceData* id = static_cast<InstanceData*>(static_cast<TestNPObject*>(npobj)->npp->pdata);
   BOOLEAN_TO_NPVARIANT(id->hasWidget, *result);
   return true;
 }
 static bool
 getEdge(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 1)
     return false;
   if (!NPVARIANT_IS_INT32(args[0]))
     return false;
   int32_t edge = NPVARIANT_TO_INT32(args[0]);
   if (edge < EDGE_LEFT || edge > EDGE_BOTTOM)
     return false;
   InstanceData* id = static_cast<InstanceData*>(static_cast<TestNPObject*>(npobj)->npp->pdata);
   int32_t r = pluginGetEdge(id, RectEdge(edge));
   if (r == NPTEST_INT32_ERROR)
     return false;
   INT32_TO_NPVARIANT(r, *result);
   return true;
 }
 static bool
 getClipRegionRectCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   InstanceData* id = static_cast<InstanceData*>(static_cast<TestNPObject*>(npobj)->npp->pdata);
   int32_t r = pluginGetClipRegionRectCount(id);
   if (r == NPTEST_INT32_ERROR)
     return false;
   INT32_TO_NPVARIANT(r, *result);
   return true;
 }
 static bool
 getClipRegionRectEdge(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 2)
     return false;
   if (!NPVARIANT_IS_INT32(args[0]))
     return false;
   int32_t rectIndex = NPVARIANT_TO_INT32(args[0]);
   if (rectIndex < 0)
     return false;
   if (!NPVARIANT_IS_INT32(args[1]))
     return false;
   int32_t edge = NPVARIANT_TO_INT32(args[1]);
   if (edge < EDGE_LEFT || edge > EDGE_BOTTOM)
     return false;
   InstanceData* id = static_cast<InstanceData*>(static_cast<TestNPObject*>(npobj)->npp->pdata);
   int32_t r = pluginGetClipRegionRectEdge(id, rectIndex, RectEdge(edge));
   if (r == NPTEST_INT32_ERROR)
     return false;
   INT32_TO_NPVARIANT(r, *result);
   return true;
 }
 static bool
 startWatchingInstanceCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   if (sWatchingInstanceCount)
     return false;
   sWatchingInstanceCount = true;
   sInstanceCount = 0;
   ++sCurrentInstanceCountWatchGeneration;
   return true;
 }
 static bool
 getInstanceCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   if (!sWatchingInstanceCount)
     return false;
   INT32_TO_NPVARIANT(sInstanceCount, *result);
   return true;
 }
 static bool
 stopWatchingInstanceCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   if (!sWatchingInstanceCount)
     return false;
   sWatchingInstanceCount = false;
   return true;
 }
 static bool
 getLastMouseX(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   INT32_TO_NPVARIANT(id->lastMouseX, *result);
   return true;
 }
 static bool
 getLastMouseY(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   INT32_TO_NPVARIANT(id->lastMouseY, *result);
   return true;
 }
 static bool
 getPaintCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   INT32_TO_NPVARIANT(id->paintCount, *result);
   return true;
 }
 static bool
 getWidthAtLastPaint(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   INT32_TO_NPVARIANT(id->widthAtLastPaint, *result);
   return true;
 }
 static bool
 setInvalidateDuringPaint(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 1)
     return false;
   if (!NPVARIANT_IS_BOOLEAN(args[0]))
     return false;
   bool doInvalidate = NPVARIANT_TO_BOOLEAN(args[0]);
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   id->invalidateDuringPaint = doInvalidate;
   return true;
 }
 static bool
 setSlowPaint(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 1)
     return false;
   if (!NPVARIANT_IS_BOOLEAN(args[0]))
     return false;
   bool slow = NPVARIANT_TO_BOOLEAN(args[0]);
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   id->slowPaint = slow;
   return true;
 }
 static bool
 getError(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   if (id->err.str().length() == 0) {
     char *outval = NPN_StrDup(SUCCESS_STRING);
     STRINGZ_TO_NPVARIANT(outval, *result);
   } else {
     char *outval = NPN_StrDup(id->err.str().c_str());
     STRINGZ_TO_NPVARIANT(outval, *result);
   }
   return true;
 }
 static bool
 doInternalConsistencyCheck(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   string error;
   pluginDoInternalConsistencyCheck(id, error);
   NPUTF8* utf8String = (NPUTF8*)NPN_MemAlloc(error.length() + 1);
   if (!utf8String) {
     return false;
   }
   memcpy(utf8String, error.c_str(), error.length() + 1);
   STRINGZ_TO_NPVARIANT(utf8String, *result);
   return true;
 }
 static bool
 convertPointX(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 4)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   if (!NPVARIANT_IS_INT32(args[0]))
     return false;
   int32_t sourceSpace = NPVARIANT_TO_INT32(args[0]);
   if (!NPVARIANT_IS_INT32(args[1]))
     return false;
   double sourceX = static_cast<double>(NPVARIANT_TO_INT32(args[1]));
   if (!NPVARIANT_IS_INT32(args[2]))
     return false;
   double sourceY = static_cast<double>(NPVARIANT_TO_INT32(args[2]));
   if (!NPVARIANT_IS_INT32(args[3]))
     return false;
   int32_t destSpace = NPVARIANT_TO_INT32(args[3]);
   double resultX, resultY;
   NPN_ConvertPoint(npp, sourceX, sourceY, (NPCoordinateSpace)sourceSpace, &resultX, &resultY, (NPCoordinateSpace)destSpace);
   DOUBLE_TO_NPVARIANT(resultX, *result);
   return true;
 }
 static bool
 convertPointY(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 4)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   if (!NPVARIANT_IS_INT32(args[0]))
     return false;
   int32_t sourceSpace = NPVARIANT_TO_INT32(args[0]);
   if (!NPVARIANT_IS_INT32(args[1]))
     return false;
   double sourceX = static_cast<double>(NPVARIANT_TO_INT32(args[1]));
   if (!NPVARIANT_IS_INT32(args[2]))
     return false;
   double sourceY = static_cast<double>(NPVARIANT_TO_INT32(args[2]));
   if (!NPVARIANT_IS_INT32(args[3]))
     return false;
   int32_t destSpace = NPVARIANT_TO_INT32(args[3]);
   double resultX, resultY;
   NPN_ConvertPoint(npp, sourceX, sourceY, (NPCoordinateSpace)sourceSpace, &resultX, &resultY, (NPCoordinateSpace)destSpace);
   DOUBLE_TO_NPVARIANT(resultY, *result);
   return true;
 }
 static bool
 streamTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   // .streamTest(url, doPost, doNull, writeCallback, notifyCallback, redirectCallback, allowRedirects)
   if (7 != argCount)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   if (!NPVARIANT_IS_STRING(args[0]))
     return false;
   NPString url = NPVARIANT_TO_STRING(args[0]);
   if (!NPVARIANT_IS_BOOLEAN(args[1]))
     return false;
   bool doPost = NPVARIANT_TO_BOOLEAN(args[1]);
   NPString postData = { nullptr, 0 };
   if (NPVARIANT_IS_STRING(args[2])) {
     postData = NPVARIANT_TO_STRING(args[2]);
   }
   else {
     if (!NPVARIANT_IS_NULL(args[2])) {
       return false;
     }
   }
   NPObject* writeCallback = nullptr;
   if (NPVARIANT_IS_OBJECT(args[3])) {
     writeCallback = NPVARIANT_TO_OBJECT(args[3]);
   }
   else {
     if (!NPVARIANT_IS_NULL(args[3])) {
       return false;
     }
   }
   NPObject* notifyCallback = nullptr;
   if (NPVARIANT_IS_OBJECT(args[4])) {
     notifyCallback = NPVARIANT_TO_OBJECT(args[4]);
   }
   else {
     if (!NPVARIANT_IS_NULL(args[4])) {
       return false;
     }
   }
   NPObject* redirectCallback = nullptr;
   if (NPVARIANT_IS_OBJECT(args[5])) {
     redirectCallback = NPVARIANT_TO_OBJECT(args[5]);
   }
   else {
     if (!NPVARIANT_IS_NULL(args[5])) {
       return false;
     }
   }
   if (!NPVARIANT_IS_BOOLEAN(args[6]))
     return false;
   bool allowRedirects = NPVARIANT_TO_BOOLEAN(args[6]);
   URLNotifyData* ndata = new URLNotifyData;
   ndata->cookie = "dynamic-cookie";
   ndata->writeCallback = writeCallback;
   ndata->notifyCallback = notifyCallback;
   ndata->redirectCallback = redirectCallback;
   ndata->size = 0;
   ndata->data = nullptr;
   ndata->allowRedirects = allowRedirects;
   /* null-terminate "url" */
   char* urlstr = (char*) malloc(url.UTF8Length + 1);
   strncpy(urlstr, url.UTF8Characters, url.UTF8Length);
   urlstr[url.UTF8Length] = '\0';
   NPError err;
   if (doPost) {
     err = NPN_PostURLNotify(npp, urlstr, nullptr,
                             postData.UTF8Length, postData.UTF8Characters,
                             false, ndata);
   }
   else {
     err = NPN_GetURLNotify(npp, urlstr, nullptr, ndata);
   }
   free(urlstr);
   if (NPERR_NO_ERROR == err) {
     if (ndata->writeCallback) {
       NPN_RetainObject(ndata->writeCallback);
     }
     if (ndata->notifyCallback) {
       NPN_RetainObject(ndata->notifyCallback);
     }
     if (ndata->redirectCallback) {
       NPN_RetainObject(ndata->redirectCallback);
     }
     BOOLEAN_TO_NPVARIANT(true, *result);
   }
   else {
     delete ndata;
     BOOLEAN_TO_NPVARIANT(false, *result);
   }
   return true;
 }
 static bool
 setPluginWantsAllStreams(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (1 != argCount)
     return false;
   if (!NPVARIANT_IS_BOOLEAN(args[0]))
     return false;
   bool wantsAllStreams = NPVARIANT_TO_BOOLEAN(args[0]);
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   id->wantsAllStreams = wantsAllStreams;
   return true;
 }
 static bool
 crashPlugin(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   IntentionalCrash();
   VOID_TO_NPVARIANT(*result);
   return true;
 }
 static bool
 crashOnDestroy(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   id->crashOnDestroy = true;
   VOID_TO_NPVARIANT(*result);
   return true;
 }
 static bool
 setColor(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 1)
     return false;
   if (!NPVARIANT_IS_STRING(args[0]))
     return false;
   const NPString* str = &NPVARIANT_TO_STRING(args[0]);
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   id->scriptableObject->drawColor =
     parseHexColor(str->UTF8Characters, str->UTF8Length);
   NPRect r;
   r.left = 0;
   r.top = 0;
   r.right = id->window.width;
   r.bottom = id->window.height;
   if (id->asyncDrawing == AD_NONE) {
     NPN_InvalidateRect(npp, &r);
   } else if (id->asyncDrawing == AD_BITMAP) {
     drawAsyncBitmapColor(id);
   }
 #ifdef XP_WIN
   else if (id->asyncDrawing == AD_DXGI) {
     pluginDrawAsyncDxgiColor(id);
   }
 #endif
   VOID_TO_NPVARIANT(*result);
   return true;
 }
 void notifyDidPaint(InstanceData* instanceData)
 {
   ++instanceData->paintCount;
   instanceData->widthAtLastPaint = instanceData->window.width;
   if (instanceData->invalidateDuringPaint) {
     NPRect r;
     r.left = 0;
     r.top = 0;
     r.right = instanceData->window.width;
     r.bottom = instanceData->window.height;
     NPN_InvalidateRect(instanceData->npp, &r);
   }
   if (instanceData->slowPaint) {
     XPSleep(1);
   }
   if (instanceData->runScriptOnPaint) {
     NPObject* o = nullptr;
     NPN_GetValue(instanceData->npp, NPNVPluginElementNPObject, &o);
     if (o) {
       NPVariant param;
       STRINGZ_TO_NPVARIANT("paintscript", param);
       NPVariant result;
       NPN_Invoke(instanceData->npp, o, NPN_GetStringIdentifier("getAttribute"),
                  &param, 1, &result);
       if (NPVARIANT_IS_STRING(result)) {
         NPObject* windowObject;
         NPN_GetValue(instanceData->npp, NPNVWindowNPObject, &windowObject);
         if (windowObject) {
           NPVariant evalResult;
           NPN_Evaluate(instanceData->npp, windowObject,
                        (NPString*)&NPVARIANT_TO_STRING(result), &evalResult);
           NPN_ReleaseVariantValue(&evalResult);
           NPN_ReleaseObject(windowObject);
         }
       }
       NPN_ReleaseVariantValue(&result);
       NPN_ReleaseObject(o);
     }
   }
 }
 static const NPClass kTestSharedNPClass = {
   NP_CLASS_STRUCT_VERSION,
   // Everything else is nullptr
 };
 static bool getJavaCodebase(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0) {
     return false;
   }
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   char *outval = NPN_StrDup(id->javaCodebase.c_str());
   STRINGZ_TO_NPVARIANT(outval, *result);
   return true;
 }
 static bool getObjectValue(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   NPObject* o = NPN_CreateObject(npp,
                                  const_cast<NPClass*>(&kTestSharedNPClass));
   if (!o)
     return false;
   OBJECT_TO_NPVARIANT(o, *result);
   return true;
 }
 static bool checkObjectValue(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   VOID_TO_NPVARIANT(*result);
   if (1 != argCount)
     return false;
   if (!NPVARIANT_IS_OBJECT(args[0]))
     return false;
   NPObject* o = NPVARIANT_TO_OBJECT(args[0]);
   BOOLEAN_TO_NPVARIANT(o->_class == &kTestSharedNPClass, *result);
   return true;
 }
 static bool enableFPExceptions(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   VOID_TO_NPVARIANT(*result);
 #if defined(XP_WIN) && defined(_M_IX86)
   _control87(0, _MCW_EM);
   return true;
 #else
   return false;
 #endif
 }
 // caller is responsible for freeing return buffer
 static char* URLForInstanceWindow(NPP instance) {
   char *outString = nullptr;
   NPObject* windowObject = nullptr;
   NPError err = NPN_GetValue(instance, NPNVWindowNPObject, &windowObject);
   if (err != NPERR_NO_ERROR || !windowObject)
     return nullptr;
   NPIdentifier locationIdentifier = NPN_GetStringIdentifier("location");
   NPVariant locationVariant;
   if (NPN_GetProperty(instance, windowObject, locationIdentifier, &locationVariant)) {
     NPObject *locationObject = locationVariant.value.objectValue;
     if (locationObject) {
       NPIdentifier hrefIdentifier = NPN_GetStringIdentifier("href");
       NPVariant hrefVariant;
       if (NPN_GetProperty(instance, locationObject, hrefIdentifier, &hrefVariant)) {
         const NPString* hrefString = &NPVARIANT_TO_STRING(hrefVariant);
         if (hrefString) {
           outString = (char *)malloc(hrefString->UTF8Length + 1);
           if (outString) {
             strcpy(outString, hrefString->UTF8Characters);
             outString[hrefString->UTF8Length] = '\0';
           }
         }
         NPN_ReleaseVariantValue(&hrefVariant);
       }
     }
     NPN_ReleaseVariantValue(&locationVariant);
   }
   NPN_ReleaseObject(windowObject);
   return outString;
 }
 static bool
 setCookie(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 1)
     return false;
   if (!NPVARIANT_IS_STRING(args[0]))
     return false;
   const NPString* cookie = &NPVARIANT_TO_STRING(args[0]);
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   char* url = URLForInstanceWindow(npp);
   if (!url)
     return false;
   NPError err = NPN_SetValueForURL(npp, NPNURLVCookie, url, cookie->UTF8Characters, cookie->UTF8Length);
   free(url);
   return (err == NPERR_NO_ERROR);
 }
 static bool
 getCookie(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   char* url = URLForInstanceWindow(npp);
   if (!url)
     return false;
   char* cookie = nullptr;
   unsigned int length = 0;
   NPError err = NPN_GetValueForURL(npp, NPNURLVCookie, url, &cookie, &length);
   free(url);
   if (err != NPERR_NO_ERROR || !cookie)
     return false;
   STRINGZ_TO_NPVARIANT(cookie, *result);
   return true;
 }
 static bool
 getAuthInfo(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 5)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   if (!NPVARIANT_IS_STRING(args[0]) || !NPVARIANT_IS_STRING(args[1]) ||
       !NPVARIANT_IS_INT32(args[2]) || !NPVARIANT_IS_STRING(args[3]) ||
       !NPVARIANT_IS_STRING(args[4]))
     return false;
   const NPString* protocol = &NPVARIANT_TO_STRING(args[0]);
   const NPString* host = &NPVARIANT_TO_STRING(args[1]);
   uint32_t port = NPVARIANT_TO_INT32(args[2]);
   const NPString* scheme = &NPVARIANT_TO_STRING(args[3]);
   const NPString* realm = &NPVARIANT_TO_STRING(args[4]);
   char* username = nullptr;
   char* password = nullptr;
   uint32_t ulen = 0, plen = 0;
   NPError err = NPN_GetAuthenticationInfo(npp,
       protocol->UTF8Characters,
       host->UTF8Characters,
       port,
       scheme->UTF8Characters,
       realm->UTF8Characters,
       &username,
       &ulen,
       &password,
       &plen);
   if (err != NPERR_NO_ERROR) {
     return false;
   }
   char* outstring = (char*)NPN_MemAlloc(ulen + plen + 2);
   memset(outstring, 0, ulen + plen + 2);
   strncpy(outstring, username, ulen);
   strcat(outstring, "|");
   strncat(outstring, password, plen);
   STRINGZ_TO_NPVARIANT(outstring, *result);
   NPN_MemFree(username);
   NPN_MemFree(password);
   return true;
 }
 static void timerCallback(NPP npp, uint32_t timerID)
 {
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   currentTimerEventCount++;
   timerEvent event = timerEvents[currentTimerEventCount];
   NPObject* windowObject;
   NPN_GetValue(npp, NPNVWindowNPObject, &windowObject);
   if (!windowObject)
     return;
   NPVariant rval;
   if (timerID != id->timerID[event.timerIdReceive]) {
     id->timerTestResult = false;
   }
   if (currentTimerEventCount == totalTimerEvents - 1) {
     NPVariant arg;
     BOOLEAN_TO_NPVARIANT(id->timerTestResult, arg);
     NPN_Invoke(npp, windowObject, NPN_GetStringIdentifier(id->timerTestScriptCallback.c_str()), &arg, 1, &rval);
     NPN_ReleaseVariantValue(&arg);
   }
   NPN_ReleaseObject(windowObject);
   if (event.timerIdSchedule > -1) {
     id->timerID[event.timerIdSchedule] = NPN_ScheduleTimer(npp, event.timerInterval, event.timerRepeat, timerCallback);
   }
   if (event.timerIdUnschedule > -1) {
     NPN_UnscheduleTimer(npp, id->timerID[event.timerIdUnschedule]);
   }
 }
 static bool
 timerTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   currentTimerEventCount = 0;
   if (argCount < 1 || !NPVARIANT_IS_STRING(args[0]))
     return false;
   const NPString* argstr = &NPVARIANT_TO_STRING(args[0]);
   id->timerTestScriptCallback = argstr->UTF8Characters;
   id->timerTestResult = true;
   timerEvent event = timerEvents[currentTimerEventCount];
   id->timerID[event.timerIdSchedule] = NPN_ScheduleTimer(npp, event.timerInterval, event.timerRepeat, timerCallback);
   return id->timerID[event.timerIdSchedule] != 0;
 }
 #ifdef XP_WIN
 void
 ThreadProc(void* cookie)
 #else
 void*
 ThreadProc(void* cookie)
 #endif
 {
   NPObject* npobj = (NPObject*)cookie;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   id->asyncTestPhase = 1;
   NPN_PluginThreadAsyncCall(npp, asyncCallback, (void*)npobj);
 #ifndef XP_WIN
   return nullptr;
 #endif
 }
 void
 asyncCallback(void* cookie)
 {
   NPObject* npobj = (NPObject*)cookie;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   switch (id->asyncTestPhase) {
     // async callback triggered from same thread
     case 0:
 #ifdef XP_WIN
       if (_beginthread(ThreadProc, 0, (void*)npobj) == -1)
         id->asyncCallbackResult = false;
 #else
       pthread_t tid;
       if (pthread_create(&tid, 0, ThreadProc, (void*)npobj))
         id->asyncCallbackResult = false;
 #endif
       break;
     // async callback triggered from different thread
     default:
       NPObject* windowObject;
       NPN_GetValue(npp, NPNVWindowNPObject, &windowObject);
       if (!windowObject)
         return;
       NPVariant arg, rval;
       BOOLEAN_TO_NPVARIANT(id->asyncCallbackResult, arg);
       NPN_Invoke(npp, windowObject, NPN_GetStringIdentifier(id->asyncTestScriptCallback.c_str()), &arg, 1, &rval);
       NPN_ReleaseVariantValue(&arg);
       NPN_ReleaseObject(windowObject);
       break;
   }
 }
 static bool
 asyncCallbackTest(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   if (argCount < 1 || !NPVARIANT_IS_STRING(args[0]))
     return false;
   const NPString* argstr = &NPVARIANT_TO_STRING(args[0]);
   id->asyncTestScriptCallback = argstr->UTF8Characters;
   id->asyncTestPhase = 0;
   id->asyncCallbackResult = true;
   NPN_PluginThreadAsyncCall(npp, asyncCallback, (void*)npobj);
   return true;
 }
 static bool
 GCRaceInvoke(NPObject*, NPIdentifier, const NPVariant*, uint32_t, NPVariant*)
 {
   return false;
 }
 static bool
 GCRaceInvokeDefault(NPObject* o, const NPVariant* args, uint32_t argCount,
 		    NPVariant* result)
 {
   if (1 != argCount || !NPVARIANT_IS_INT32(args[0]) ||
 != NPVARIANT_TO_INT32(args[0]))
     return false;
   return true;
 }
 static const NPClass kGCRaceClass = {
   NP_CLASS_STRUCT_VERSION,
   nullptr,
   nullptr,
   nullptr,
   nullptr,
   GCRaceInvoke,
   GCRaceInvokeDefault,
   nullptr,
   nullptr,
   nullptr,
   nullptr,
   nullptr,
   nullptr
 };
 struct GCRaceData
 {
   GCRaceData(NPP npp, NPObject* callback, NPObject* localFunc)
     : npp_(npp)
     , callback_(callback)
     , localFunc_(localFunc)
   {
     NPN_RetainObject(callback_);
     NPN_RetainObject(localFunc_);
   }
   ~GCRaceData()
   {
     NPN_ReleaseObject(callback_);
     NPN_ReleaseObject(localFunc_);
   }
   NPP npp_;
   NPObject* callback_;
   NPObject* localFunc_;
 };
 static void
 FinishGCRace(void* closure)
 {
   GCRaceData* rd = static_cast<GCRaceData*>(closure);
   XPSleep(5);
   NPVariant arg;
   OBJECT_TO_NPVARIANT(rd->localFunc_, arg);
   NPVariant result;
   bool ok = NPN_InvokeDefault(rd->npp_, rd->callback_, &arg, 1, &result);
   if (!ok)
     return;
   NPN_ReleaseVariantValue(&result);
   delete rd;
 }
 bool
 checkGCRace(NPObject* npobj, const NPVariant* args, uint32_t argCount,
 	    NPVariant* result)
 {
   if (1 != argCount || !NPVARIANT_IS_OBJECT(args[0]))
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   NPObject* localFunc =
     NPN_CreateObject(npp, const_cast<NPClass*>(&kGCRaceClass));
   GCRaceData* rd =
     new GCRaceData(npp, NPVARIANT_TO_OBJECT(args[0]), localFunc);
   NPN_PluginThreadAsyncCall(npp, FinishGCRace, rd);
   OBJECT_TO_NPVARIANT(localFunc, *result);
   return true;
 }
 bool
 hangPlugin(NPObject* npobj, const NPVariant* args, uint32_t argCount,
            NPVariant* result)
 {
   mozilla::NoteIntentionalCrash("plugin");
   bool busyHang = false;
   if ((argCount == 1) && NPVARIANT_IS_BOOLEAN(args[0])) {
     busyHang = NPVARIANT_TO_BOOLEAN(args[0]);
   }
   if (busyHang) {
     const time_t start = std::time(nullptr);
     while ((std::time(nullptr) - start) < 100000) {
       volatile int dummy = 0;
       for (int i=0; i<1000; ++i) {
         dummy++;
       }
     }
   } else {
 #ifdef XP_WIN
   Sleep(100000000);
     Sleep(100000000);
 #else
   pause();
     pause();
 #endif
   }
   // NB: returning true here means that we weren't terminated, and
   // thus the hang detection/handling didn't work correctly.  The
   // test harness will succeed in calling this function, and the
   // test will fail.
   return true;
 }
 bool
 stallPlugin(NPObject* npobj, const NPVariant* args, uint32_t argCount,
            NPVariant* result)
 {
   uint32_t stallTimeSeconds = 0;
   if ((argCount == 1) && NPVARIANT_IS_INT32(args[0])) {
     stallTimeSeconds = (uint32_t) NPVARIANT_TO_INT32(args[0]);
   }
 #ifdef XP_WIN
   Sleep(stallTimeSeconds * 1000U);
 #else
   sleep(stallTimeSeconds);
 #endif
   return true;
 }
 #if defined(MOZ_WIDGET_GTK)
 bool
 getClipboardText(NPObject* npobj, const NPVariant* args, uint32_t argCount,
                  NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   string sel = pluginGetClipboardText(id);
   uint32_t len = sel.size();
   char* selCopy = static_cast<char*>(NPN_MemAlloc(1 + len));
   if (!selCopy)
     return false;
   memcpy(selCopy, sel.c_str(), len);
   selCopy[len] = '\0';
   STRINGN_TO_NPVARIANT(selCopy, len, *result);
   // *result owns str now
   return true;
 }
 bool
 crashPluginInNestedLoop(NPObject* npobj, const NPVariant* args,
                         uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   return pluginCrashInNestedLoop(id);
 }
 bool
 destroySharedGfxStuff(NPObject* npobj, const NPVariant* args,
                         uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   return pluginDestroySharedGfxStuff(id);
 }
 #else
 bool
 getClipboardText(NPObject* npobj, const NPVariant* args, uint32_t argCount,
                  NPVariant* result)
 {
   // XXX Not implemented!
   return false;
 }
 bool
 crashPluginInNestedLoop(NPObject* npobj, const NPVariant* args,
                         uint32_t argCount, NPVariant* result)
 {
   // XXX Not implemented!
   return false;
 }
 bool
 destroySharedGfxStuff(NPObject* npobj, const NPVariant* args,
                         uint32_t argCount, NPVariant* result)
 {
   // XXX Not implemented!
   return false;
 }
 #endif
 bool
 callOnDestroy(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   if (id->callOnDestroy)
     return false;
   if (1 != argCount || !NPVARIANT_IS_OBJECT(args[0]))
     return false;
   id->callOnDestroy = NPVARIANT_TO_OBJECT(args[0]);
   NPN_RetainObject(id->callOnDestroy);
   return true;
 }
 // On Linux at least, a windowed plugin resize causes Flash Player to
 // reconnect to the browser window.  This method simulates that.
 bool
 reinitWidget(NPObject* npobj, const NPVariant* args, uint32_t argCount,
              NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   if (!id->hasWidget)
     return false;
   pluginWidgetInit(id, id->window.window);
   return true;
 }
 bool
 propertyAndMethod(NPObject* npobj, const NPVariant* args, uint32_t argCount,
                   NPVariant* result)
 {
   INT32_TO_NPVARIANT(5, *result);
   return true;
 }
 // Returns top-level window activation state as indicated by Cocoa NPAPI's
 // NPCocoaEventWindowFocusChanged events - 'true' if active, 'false' if not.
 // Throws an exception if no events have been received and thus this state
 // is unknown.
 bool
 getTopLevelWindowActivationState(NPObject* npobj, const NPVariant* args, uint32_t argCount,
                                  NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   // Throw an exception for unknown state.
   if (id->topLevelWindowActivationState == ACTIVATION_STATE_UNKNOWN) {
     return false;
   }
   if (id->topLevelWindowActivationState == ACTIVATION_STATE_ACTIVATED) {
     BOOLEAN_TO_NPVARIANT(true, *result);
   } else if (id->topLevelWindowActivationState == ACTIVATION_STATE_DEACTIVATED) {
     BOOLEAN_TO_NPVARIANT(false, *result);
   }
   return true;
 }
 bool
 getTopLevelWindowActivationEventCount(NPObject* npobj, const NPVariant* args, uint32_t argCount,
                                       NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   INT32_TO_NPVARIANT(id->topLevelWindowActivationEventCount, *result);
   return true;
 }
 // Returns top-level window activation state as indicated by Cocoa NPAPI's
 // NPCocoaEventWindowFocusChanged events - 'true' if active, 'false' if not.
 // Throws an exception if no events have been received and thus this state
 // is unknown.
 bool
 getFocusState(NPObject* npobj, const NPVariant* args, uint32_t argCount,
               NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   // Throw an exception for unknown state.
   if (id->focusState == ACTIVATION_STATE_UNKNOWN) {
     return false;
   }
   if (id->focusState == ACTIVATION_STATE_ACTIVATED) {
     BOOLEAN_TO_NPVARIANT(true, *result);
   } else if (id->focusState == ACTIVATION_STATE_DEACTIVATED) {
     BOOLEAN_TO_NPVARIANT(false, *result);
   }
   return true;
 }
 bool
 getFocusEventCount(NPObject* npobj, const NPVariant* args, uint32_t argCount,
                    NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   INT32_TO_NPVARIANT(id->focusEventCount, *result);
   return true;
 }
 bool
 getEventModel(NPObject* npobj, const NPVariant* args, uint32_t argCount,
               NPVariant* result)
 {
   if (argCount != 0)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   INT32_TO_NPVARIANT(id->eventModel, *result);
   return true;
 }
 static bool
 ReflectorHasMethod(NPObject* npobj, NPIdentifier name)
 {
   return false;
 }
 static bool
 ReflectorHasProperty(NPObject* npobj, NPIdentifier name)
 {
   return true;
 }
 static bool
 ReflectorGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result)
 {
   if (NPN_IdentifierIsString(name)) {
     char* s = NPN_UTF8FromIdentifier(name);
     STRINGZ_TO_NPVARIANT(s, *result);
     return true;
   }
   INT32_TO_NPVARIANT(NPN_IntFromIdentifier(name), *result);
   return true;
 }
 static const NPClass kReflectorNPClass = {
   NP_CLASS_STRUCT_VERSION,
   nullptr,
   nullptr,
   nullptr,
   ReflectorHasMethod,
   nullptr,
   nullptr,
   ReflectorHasProperty,
   ReflectorGetProperty,
   nullptr,
   nullptr,
   nullptr,
   nullptr
 };
 bool
 getReflector(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (0 != argCount)
     return false;
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   NPObject* reflector =
     NPN_CreateObject(npp,
 		     const_cast<NPClass*>(&kReflectorNPClass)); // retains
   OBJECT_TO_NPVARIANT(reflector, *result);
   return true;
 }
 bool isVisible(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   BOOLEAN_TO_NPVARIANT(id->window.clipRect.top != 0 ||
 		       id->window.clipRect.left != 0 ||
 		       id->window.clipRect.bottom != 0 ||
 		       id->window.clipRect.right != 0, *result);
   return true;
 }
 bool getWindowPosition(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   NPObject* window = nullptr;
   NPError err = NPN_GetValue(npp, NPNVWindowNPObject, &window);
   if (NPERR_NO_ERROR != err || !window)
     return false;
   NPIdentifier arrayID = NPN_GetStringIdentifier("Array");
   NPVariant arrayFunctionV;
   bool ok = NPN_GetProperty(npp, window, arrayID, &arrayFunctionV);
   NPN_ReleaseObject(window);
   if (!ok)
     return false;
   if (!NPVARIANT_IS_OBJECT(arrayFunctionV)) {
     NPN_ReleaseVariantValue(&arrayFunctionV);
     return false;
   }
   NPObject* arrayFunction = NPVARIANT_TO_OBJECT(arrayFunctionV);
   NPVariant elements[4];
   INT32_TO_NPVARIANT(id->window.x, elements[0]);
   INT32_TO_NPVARIANT(id->window.y, elements[1]);
   INT32_TO_NPVARIANT(id->window.width, elements[2]);
   INT32_TO_NPVARIANT(id->window.height, elements[3]);
   ok = NPN_InvokeDefault(npp, arrayFunction, elements, 4, result);
   NPN_ReleaseObject(arrayFunction);
   return ok;
 }
 bool constructObject(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount == 0 || !NPVARIANT_IS_OBJECT(args[0]))
     return false;
   NPObject* ctor = NPVARIANT_TO_OBJECT(args[0]);
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   return NPN_Construct(npp, ctor, args + 1, argCount - 1, result);
 }
 bool setSitesWithData(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 1 || !NPVARIANT_IS_STRING(args[0]))
     return false;
   // Clear existing data.
   delete sSitesWithData;
   const NPString* str = &NPVARIANT_TO_STRING(args[0]);
   if (str->UTF8Length == 0)
     return true;
   // Parse the comma-delimited string into a vector.
   sSitesWithData = new list<siteData>;
   const char* iterator = str->UTF8Characters;
   const char* end = iterator + str->UTF8Length;
   while (1) {
     const char* next = strchr(iterator, ',');
     if (!next)
       next = end;
     // Parse out the three tokens into a siteData struct.
     const char* siteEnd = strchr(iterator, ':');
     *((char*) siteEnd) = '\0';
     const char* flagsEnd = strchr(siteEnd + 1, ':');
     *((char*) flagsEnd) = '\0';
     *((char*) next) = '\0';
     siteData data;
     data.site = string(iterator);
     data.flags = atoi(siteEnd + 1);
     data.age = atoi(flagsEnd + 1);
     sSitesWithData->push_back(data);
     if (next == end)
       break;
     iterator = next + 1;
   }
   return true;
 }
 bool setSitesWithDataCapabilities(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 1 || !NPVARIANT_IS_BOOLEAN(args[0]))
     return false;
   sClearByAgeSupported = NPVARIANT_TO_BOOLEAN(args[0]);
   return true;
 }
 bool getLastKeyText(NPObject* npobj, const NPVariant* args, uint32_t argCount,
                     NPVariant* result)
 {
   if (argCount != 0) {
     return false;
   }
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   char *outval = NPN_StrDup(id->lastKeyText.c_str());
   STRINGZ_TO_NPVARIANT(outval, *result);
   return true;
 }
 bool getNPNVdocumentOrigin(NPObject* npobj, const NPVariant* args, uint32_t argCount,
                            NPVariant* result)
 {
   if (argCount != 0) {
     return false;
   }
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   char *origin = nullptr;
   NPError err = NPN_GetValue(npp, NPNVdocumentOrigin, &origin);
   if (err != NPERR_NO_ERROR) {
     return false;
   }
   STRINGZ_TO_NPVARIANT(origin, *result);
   return true;
 }
 bool getMouseUpEventCount(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0) {
     return false;
   }
   NPP npp = static_cast<TestNPObject*>(npobj)->npp;
   InstanceData* id = static_cast<InstanceData*>(npp->pdata);
   INT32_TO_NPVARIANT(id->mouseUpEventCount, *result);
   return true;
 }
 bool queryContentsScaleFactor(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result)
 {
   if (argCount != 0)
     return false;
   double scaleFactor = 1.0;
 #if defined(XP_MACOSX)
   NPError err = NPN_GetValue(static_cast<TestNPObject*>(npobj)->npp,
                              NPNVcontentsScaleFactor, &scaleFactor);
   if (err != NPERR_NO_ERROR) {
     return false;
   }
 #endif
   DOUBLE_TO_NPVARIANT(scaleFactor, *result);
   return true;
 }

The Tor Browser / annotate

dom/plugins/test/testplugin/nptest.cpp@6474c204b198 (annotated)

dom/plugins/test/testplugin/nptest.cpp