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