diff --git a/browser/base/content/test/Makefile.in b/browser/base/content/test/Makefile.in index 9b45687268f4..06a25b0a05fb 100644 --- a/browser/base/content/test/Makefile.in +++ b/browser/base/content/test/Makefile.in @@ -54,6 +54,7 @@ _TEST_FILES = test_feed_discovery.html \ # browser_bug423833.js disabled temporarily since it's unreliable: bug 428712 # browser_sanitize-download-history.js disabled temporarily since it's unreliable: bug 432425 +# browser_pluginnotification.js disabled because it leaks when it can actually load a plugin instance _BROWSER_FILES = browser_bug321000.js \ browser_sanitize-timespans.js \ browser_bug405137.js \ @@ -74,7 +75,6 @@ _BROWSER_FILES = browser_bug321000.js \ browser_gestureSupport.js \ browser_feed_tab.js \ feed_tab.html \ - browser_pluginnotification.js \ plugin_unknown.html \ plugin_test.html \ plugin_both.html \ diff --git a/content/base/test/Makefile.in b/content/base/test/Makefile.in index 7823db1c48a2..d7af8f7e1270 100644 --- a/content/base/test/Makefile.in +++ b/content/base/test/Makefile.in @@ -232,7 +232,6 @@ _TEST_FILES = test_bug5141.html \ file_bug445225_multipart.txt^headers^ \ test_title.html \ test_bug453521.html \ - test_bug391728.html \ file_bug391728.html \ test_bug454325.html \ file_bug391728_2.html \ @@ -276,5 +275,9 @@ _TEST_FILES = test_bug5141.html \ # test_bug444546.html \ # bug444546.sjs \ +# Disabled because of a leak that occurs when the test plugin can actually load +# instances. +# test_bug391728.html \ + libs:: $(_TEST_FILES) $(INSTALL) $(foreach f,$^,"$f") $(DEPTH)/_tests/testing/mochitest/tests/$(relativesrcdir) diff --git a/modules/plugin/test/Makefile.in b/modules/plugin/test/Makefile.in index 2d932d0f8fb5..552fd3a1c72c 100644 --- a/modules/plugin/test/Makefile.in +++ b/modules/plugin/test/Makefile.in @@ -20,6 +20,7 @@ # # Contributor(s): # Dave Townsend +# Josh Aas # # Alternatively, the contents of this file may be used under the terms of # either the GNU General Public License Version 2 or later (the "GPL"), or @@ -50,4 +51,11 @@ XPCSHELL_TESTS = \ unit \ $(NULL) +# plugin mochitests only work on UNIX variants, including Mac OS X, at this time +ifneq (,$(filter gtk2 cocoa windows,$(MOZ_WIDGET_TOOLKIT))) +ifdef ENABLE_TESTS +DIRS += mochitest +endif +endif + include $(topsrcdir)/config/rules.mk diff --git a/modules/plugin/test/mochitest/Makefile.in b/modules/plugin/test/mochitest/Makefile.in new file mode 100644 index 000000000000..72ec45cc89fb --- /dev/null +++ b/modules/plugin/test/mochitest/Makefile.in @@ -0,0 +1,50 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is mozilla.org code. +# +# The Initial Developer of the Original Code is +# Mozilla Foundation. +# Portions created by the Initial Developer are Copyright (C) 2007 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either of the GNU General Public License Version 2 or later (the "GPL"), +# or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** + +DEPTH = ../../../.. +topsrcdir = @top_srcdir@ +srcdir = @srcdir@ +VPATH = @srcdir@ +relativesrcdir = modules/plugin/test + +include $(DEPTH)/config/autoconf.mk +include $(topsrcdir)/config/rules.mk + +_TEST_FILES = test_npruntime.xul + +libs:: $(_TEST_FILES) + $(INSTALL) $^ $(DEPTH)/_tests/testing/mochitest/chrome/$(relativesrcdir) diff --git a/modules/plugin/test/mochitest/test_npruntime.xul b/modules/plugin/test/mochitest/test_npruntime.xul new file mode 100644 index 000000000000..343f69ac5edd --- /dev/null +++ b/modules/plugin/test/mochitest/test_npruntime.xul @@ -0,0 +1,29 @@ + + + + + Basic Plugin Tests + + + diff --git a/modules/plugin/test/testplugin/Makefile.in b/modules/plugin/test/testplugin/Makefile.in index 208076d7fbe2..f37f59425c95 100644 --- a/modules/plugin/test/testplugin/Makefile.in +++ b/modules/plugin/test/testplugin/Makefile.in @@ -54,12 +54,25 @@ REQUIRES = \ NO_DIST_INSTALL = 1 NO_INSTALL = 1 -ifeq ($(OS_ARCH),WINNT) -RCFILE = nptest.rc -RESFILE = nptest.res +CPPSRCS = \ + nptest.cpp \ + nptest_utils.cpp \ + $(NULL) + +ifeq ($(MOZ_WIDGET_TOOLKIT),cocoa) +CMMSRCS = nptest_macosx.mm endif -CPPSRCS = nptest.cpp +ifeq ($(MOZ_WIDGET_TOOLKIT),gtk2) +CPPSRCS += nptest_gtk2.cpp +endif + +ifeq ($(MOZ_WIDGET_TOOLKIT),windows) +CPPSRCS += nptest_windows.cpp +RCFILE = nptest.rc +RESFILE = nptest.res +DEFFILE = $(win_srcdir)/nptest.def +endif include $(topsrcdir)/config/rules.mk diff --git a/modules/plugin/test/testplugin/nptest.cpp b/modules/plugin/test/testplugin/nptest.cpp index 78e4e078a333..9eb300bd50e4 100644 --- a/modules/plugin/test/testplugin/nptest.cpp +++ b/modules/plugin/test/testplugin/nptest.cpp @@ -1,83 +1,524 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* ***** BEGIN LICENSE BLOCK ***** - * Version: MPL 1.1/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Mozilla Public License Version - * 1.1 (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * http://www.mozilla.org/MPL/ - * - * Software distributed under the License is distributed on an "AS IS" basis, - * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License - * for the specific language governing rights and limitations under the - * License. - * - * The Original Code is mozilla.org code. - * - * The Initial Developer of the Original Code is mozilla.org - * Portions created by the Initial Developer are Copyright (C) 2008 - * the Initial Developer. All Rights Reserved. - * + * + * Copyright (c) 2008, Mozilla Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the Mozilla Corporation nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * * Contributor(s): * Dave Townsend - * - * Alternatively, the contents of this file may be used under the terms of - * either the GNU General Public License Version 2 or later (the "GPL"), or - * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the MPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the MPL, the GPL or the LGPL. - * + * Josh Aas + * * ***** END LICENSE BLOCK ***** */ -#include "npapi.h" -#include "npfunctions.h" +#include "nptest.h" +#include "nptest_utils.h" +#include "nptest_platform.h" + +#include +#include + +#define PLUGIN_NAME "Test Plug-in" +#define PLUGIN_DESCRIPTION "Plug-in for testing purposes." +#define PLUGIN_VERSION "1.0.0.0" + +// +// static data +// + +static NPNetscapeFuncs* sBrowserFuncs = NULL; +static NPClass sNPClass; + +// +// identifiers +// + +#define IDENTIFIER_TO_STRING_TEST_METHOD 0 +#define NUM_METHOD_IDENTIFIERS 1 + +static NPIdentifier sPluginMethodIdentifiers[NUM_METHOD_IDENTIFIERS]; +static const NPUTF8 *sPluginMethodIdentifierNames[NUM_METHOD_IDENTIFIERS] = { + "identifierToStringTest", +}; + +static bool sIdentifiersInitialized = false; + +static void initializeIdentifiers() +{ + if (!sIdentifiersInitialized) { + NPN_GetStringIdentifiers(sPluginMethodIdentifierNames, NUM_METHOD_IDENTIFIERS, sPluginMethodIdentifiers); + sIdentifiersInitialized = true; + } +} + +static void clearIdentifiers() +{ + memset(sPluginMethodIdentifierNames, 0, NUM_METHOD_IDENTIFIERS * sizeof(NPIdentifier)); + sIdentifiersInitialized = false; +} + +// +// function signatures +// + +bool identifierToStringTest(const NPVariant* args, uint32_t argCount, NPVariant* result); + +NPObject* scriptableAllocate(NPP npp, NPClass* aClass); +void scriptableDeallocate(NPObject* npobj); +void scriptableInvalidate(NPObject* npobj); +bool scriptableHasMethod(NPObject* npobj, NPIdentifier name); +bool scriptableInvoke(NPObject* npobj, NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result); +bool scriptableInvokeDefault(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result); +bool scriptableHasProperty(NPObject* npobj, NPIdentifier name); +bool scriptableGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result); +bool scriptableSetProperty(NPObject* npobj, NPIdentifier name, const NPVariant* value); +bool scriptableRemoveProperty(NPObject* npobj, NPIdentifier name); +bool scriptableEnumerate(NPObject* npobj, NPIdentifier** identifier, uint32_t* count); +bool scriptableConstruct(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result); + +// +// npapi plugin functions +// + +#ifdef XP_UNIX +NP_EXPORT(char*) +NP_GetPluginVersion() +{ + return PLUGIN_VERSION; +} +#endif #if defined(XP_UNIX) - -#define PLUGIN_NAME "Test Plug-in" -#define PLUGIN_DESCRIPTION "Plug-in for testing purposes." -#define PLUGIN_VERSION "1.0.0.0" - -NP_EXPORT(char*) -NP_GetPluginVersion(void) { - return PLUGIN_VERSION; -} - -NP_EXPORT(char*) -NP_GetMIMEDescription(void) { - return "application/x-test:tst:Test mimetype"; -} - -NP_EXPORT(NPError) -NP_Initialize(NPNetscapeFuncs*, NPPluginFuncs*) { - return NPERR_NO_ERROR; -} - -NP_EXPORT(NPError) -NP_Shutdown(void) { - return NPERR_NO_ERROR; -} - -NP_EXPORT(NPError) -NP_GetValue(void *future, NPPVariable aVariable, void *aValue) { - switch (aVariable) { - case NPPVpluginNameString: - *((char **)aValue) = PLUGIN_NAME; - break; - case NPPVpluginDescriptionString: - *((char **)aValue) = PLUGIN_DESCRIPTION; - break; - default: - return NPERR_INVALID_PARAM; - break; - } - return NPERR_NO_ERROR; -} - +NP_EXPORT(char*) NP_GetMIMEDescription() +#elif defined(XP_WIN) +char* NP_GetMIMEDescription() #endif +{ + return "application/x-test:tst:Test mimetype"; +} + +#ifdef XP_UNIX +NP_EXPORT(NPError) +NP_GetValue(void* future, NPPVariable aVariable, void* aValue) { + switch (aVariable) { + case NPPVpluginNameString: + *((char**)aValue) = PLUGIN_NAME; + break; + case NPPVpluginDescriptionString: + *((char**)aValue) = PLUGIN_DESCRIPTION; + break; + default: + return NPERR_INVALID_PARAM; + break; + } + return NPERR_NO_ERROR; +} +#endif + +static void fillPluginFunctionTable(NPPluginFuncs* pFuncs) +{ + pFuncs->version = 11; + pFuncs->size = sizeof(*pFuncs); + pFuncs->newp = NPP_New; + pFuncs->destroy = NPP_Destroy; + pFuncs->setwindow = NPP_SetWindow; + pFuncs->newstream = NPP_NewStream; + pFuncs->destroystream = NPP_DestroyStream; + pFuncs->asfile = NPP_StreamAsFile; + pFuncs->writeready = NPP_WriteReady; + pFuncs->write = NPP_Write; + pFuncs->print = NPP_Print; + pFuncs->event = NPP_HandleEvent; + pFuncs->urlnotify = NPP_URLNotify; + pFuncs->getvalue = NPP_GetValue; + pFuncs->setvalue = NPP_SetValue; +} + +#if defined(XP_MACOSX) +NP_EXPORT(NPError) NP_Initialize(NPNetscapeFuncs* bFuncs) +#elif defined(XP_WIN) +NPError OSCALL NP_Initialize(NPNetscapeFuncs* bFuncs) +#elif defined(XP_UNIX) +NP_EXPORT(NPError) NP_Initialize(NPNetscapeFuncs* bFuncs, NPPluginFuncs* pFuncs) +#endif +{ + sBrowserFuncs = bFuncs; + + initializeIdentifiers(); + + memset(&sNPClass, 0, sizeof(NPClass)); + sNPClass.structVersion = NP_CLASS_STRUCT_VERSION; + sNPClass.allocate = (NPAllocateFunctionPtr)scriptableAllocate; + sNPClass.deallocate = (NPDeallocateFunctionPtr)scriptableDeallocate; + sNPClass.invalidate = (NPInvalidateFunctionPtr)scriptableInvalidate; + sNPClass.hasMethod = (NPHasMethodFunctionPtr)scriptableHasMethod; + sNPClass.invoke = (NPInvokeFunctionPtr)scriptableInvoke; + sNPClass.invokeDefault = (NPInvokeDefaultFunctionPtr)scriptableInvokeDefault; + sNPClass.hasProperty = (NPHasPropertyFunctionPtr)scriptableHasProperty; + sNPClass.getProperty = (NPGetPropertyFunctionPtr)scriptableGetProperty; + sNPClass.setProperty = (NPSetPropertyFunctionPtr)scriptableSetProperty; + sNPClass.removeProperty = (NPRemovePropertyFunctionPtr)scriptableRemoveProperty; + sNPClass.enumerate = (NPEnumerationFunctionPtr)scriptableEnumerate; + sNPClass.construct = (NPConstructFunctionPtr)scriptableConstruct; + +#if defined(XP_UNIX) && !defined(XP_MACOSX) + fillPluginFunctionTable(pFuncs); +#endif + + return NPERR_NO_ERROR; +} + +#if defined(XP_MACOSX) +NP_EXPORT(NPError) NP_GetEntryPoints(NPPluginFuncs* pFuncs) +#elif defined(XP_WIN) +NPError OSCALL NP_GetEntryPoints(NPPluginFuncs* pFuncs) +#endif +#if defined(XP_MACOSX) || defined(XP_WIN) +{ + fillPluginFunctionTable(pFuncs); + return NPERR_NO_ERROR; +} +#endif + +#if defined(XP_UNIX) +NP_EXPORT(NPError) NP_Shutdown() +#elif defined(XP_WIN) +NPError OSCALL NP_Shutdown() +#endif +{ + clearIdentifiers(); + + return NPERR_NO_ERROR; +} + +NPError +NPP_New(NPMIMEType pluginType, NPP instance, uint16_t mode, int16_t argc, char* argn[], char* argv[], NPSavedData* saved) +{ + NPN_SetValue(instance, NPPVpluginWindowBool, NULL); + + // set up our our instance data + InstanceData* instanceData = (InstanceData*)malloc(sizeof(InstanceData)); + if (!instanceData) + return NPERR_OUT_OF_MEMORY_ERROR; + memset(instanceData, 0, sizeof(InstanceData)); + instanceData->npp = instance; + instance->pdata = instanceData; + + TestNPObject* scriptableObject = (TestNPObject*)NPN_CreateObject(instance, &sNPClass); + if (!scriptableObject) { + printf("NPN_CreateObject failed to create an object, can't create a plugin instance\n"); + return NPERR_GENERIC_ERROR; + } + NPN_RetainObject(scriptableObject); + scriptableObject->npp = instance; + instanceData->scriptableObject = scriptableObject; + + // do platform-specific initialization + NPError err = pluginInstanceInit(instanceData); + if (err != NPERR_NO_ERROR) + return err; + + return NPERR_NO_ERROR; +} + +NPError +NPP_Destroy(NPP instance, NPSavedData** save) +{ + InstanceData* instanceData = (InstanceData*)(instance->pdata); + NPN_ReleaseObject(instanceData->scriptableObject); + free(instanceData); + return NPERR_NO_ERROR; +} + +NPError +NPP_SetWindow(NPP instance, NPWindow* window) +{ + InstanceData* instanceData = (InstanceData*)(instance->pdata); + instanceData->window = *window; + return NPERR_NO_ERROR; +} + +NPError +NPP_NewStream(NPP instance, NPMIMEType type, NPStream* stream, NPBool seekable, uint16_t* stype) +{ + *stype = NP_ASFILEONLY; + return NPERR_NO_ERROR; +} + +NPError +NPP_DestroyStream(NPP instance, NPStream* stream, NPReason reason) +{ + return NPERR_NO_ERROR; +} + +int32_t +NPP_WriteReady(NPP instance, NPStream* stream) +{ + return 0; +} + +int32_t +NPP_Write(NPP instance, NPStream* stream, int32_t offset, int32_t len, void* buffer) +{ + return 0; +} + +void +NPP_StreamAsFile(NPP instance, NPStream* stream, const char* fname) +{ +} + +void +NPP_Print(NPP instance, NPPrint* platformPrint) +{ +} + +int16_t +NPP_HandleEvent(NPP instance, void* event) +{ + InstanceData* instanceData = (InstanceData*)(instance->pdata); + return pluginHandleEvent(instanceData, event); +} + +void +NPP_URLNotify(NPP instance, const char* url, NPReason reason, void* notifyData) +{ +} + +NPError +NPP_GetValue(NPP instance, NPPVariable variable, void* value) +{ + if (variable == NPPVpluginScriptableNPObject) { + NPObject* object = ((InstanceData*)instance->pdata)->scriptableObject; + NPN_RetainObject(object); + *((NPObject**)value) = object; + return NPERR_NO_ERROR; + } + + return NPERR_GENERIC_ERROR; +} + +NPError +NPP_SetValue(NPP instance, NPNVariable variable, void* value) +{ + return NPERR_GENERIC_ERROR; +} + +// +// npapi browser functions +// + +bool +NPN_SetProperty(NPP instance, NPObject* obj, NPIdentifier propertyName, const NPVariant* value) +{ + return sBrowserFuncs->setproperty(instance, obj, propertyName, value); +} + +NPIdentifier +NPN_GetIntIdentifier(int32_t intid) +{ + return sBrowserFuncs->getintidentifier(intid); +} + +NPIdentifier +NPN_GetStringIdentifier(const NPUTF8* name) +{ + return sBrowserFuncs->getstringidentifier(name); +} + +void +NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers) +{ + return sBrowserFuncs->getstringidentifiers(names, nameCount, identifiers); +} + +NPUTF8* +NPN_UTF8FromIdentifier(NPIdentifier identifier) +{ + return sBrowserFuncs->utf8fromidentifier(identifier); +} + +int32_t +NPN_IntFromIdentifier(NPIdentifier identifier) +{ + return sBrowserFuncs->intfromidentifier(identifier); +} + +NPError +NPN_GetValue(NPP instance, NPNVariable variable, void* value) +{ + return sBrowserFuncs->getvalue(instance, variable, value); +} + +NPError +NPN_SetValue(NPP instance, NPPVariable variable, void* value) +{ + return sBrowserFuncs->setvalue(instance, variable, value); +} + +bool +NPN_HasProperty(NPP instance, NPObject* obj, NPIdentifier propertyName) +{ + return sBrowserFuncs->hasproperty(instance, obj, propertyName); +} + +NPObject* +NPN_CreateObject(NPP instance, NPClass* aClass) +{ + return sBrowserFuncs->createobject(instance, aClass); +} + +const char* +NPN_UserAgent(NPP instance) +{ + return sBrowserFuncs->uagent(instance); +} + +NPObject* +NPN_RetainObject(NPObject* obj) +{ + return sBrowserFuncs->retainobject(obj); +} + +void +NPN_ReleaseObject(NPObject* obj) +{ + return sBrowserFuncs->releaseobject(obj); +} + +void* +NPN_MemAlloc(uint32_t size) +{ + return sBrowserFuncs->memalloc(size); +} + +void +NPN_MemFree(void* ptr) +{ + return sBrowserFuncs->memfree(ptr); +} + +// +// npruntime object functions +// + +NPObject* +scriptableAllocate(NPP npp, NPClass* aClass) +{ + TestNPObject* object = (TestNPObject*)NPN_MemAlloc(sizeof(TestNPObject)); + if (!object) + return NULL; + memset(object, 0, sizeof(TestNPObject)); + return object; +} + +void +scriptableDeallocate(NPObject* npobj) +{ + NPN_MemFree(npobj); +} + +void +scriptableInvalidate(NPObject* npobj) +{ +} + +bool +scriptableHasMethod(NPObject* npobj, NPIdentifier name) +{ + for (int i = 0; i < NUM_METHOD_IDENTIFIERS; i++) { + if (name == sPluginMethodIdentifiers[i]) + return true; + } + return false; +} + +bool +scriptableInvoke(NPObject* npobj, NPIdentifier name, const NPVariant* args, uint32_t argCount, NPVariant* result) +{ + if (name == sPluginMethodIdentifiers[IDENTIFIER_TO_STRING_TEST_METHOD]) + return identifierToStringTest(args, argCount, result); + return false; +} + +bool +scriptableInvokeDefault(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result) +{ + return false; +} + +bool +scriptableHasProperty(NPObject* npobj, NPIdentifier name) +{ + return false; +} + +bool +scriptableGetProperty(NPObject* npobj, NPIdentifier name, NPVariant* result) +{ + return false; +} + +bool +scriptableSetProperty(NPObject* npobj, NPIdentifier name, const NPVariant* value) +{ + return false; +} + +bool +scriptableRemoveProperty(NPObject* npobj, NPIdentifier name) +{ + return false; +} + +bool +scriptableEnumerate(NPObject* npobj, NPIdentifier** identifier, uint32_t* count) +{ + return false; +} + +bool +scriptableConstruct(NPObject* npobj, const NPVariant* args, uint32_t argCount, NPVariant* result) +{ + return false; +} + +// +// test functions +// + +bool +identifierToStringTest(const NPVariant* args, uint32_t argCount, NPVariant* result) +{ + if (argCount != 1) + return false; + NPIdentifier identifier = variantToIdentifier(args[0]); + if (!identifier) + return false; + NPUTF8* utf8String = NPN_UTF8FromIdentifier(identifier); + if (!utf8String) + return false; + STRINGZ_TO_NPVARIANT(utf8String, *result); + return true; +} diff --git a/modules/plugin/test/testplugin/nptest.def b/modules/plugin/test/testplugin/nptest.def new file mode 100644 index 000000000000..4c543d5b9f1a --- /dev/null +++ b/modules/plugin/test/testplugin/nptest.def @@ -0,0 +1,7 @@ +LIBRARY NPTEST + +EXPORTS + NP_GetEntryPoints @1 + NP_Initialize @2 + NP_Shutdown @3 + NP_GetMIMEDescription @4 diff --git a/modules/plugin/test/testplugin/nptest.h b/modules/plugin/test/testplugin/nptest.h new file mode 100644 index 000000000000..13dd52c2fe2d --- /dev/null +++ b/modules/plugin/test/testplugin/nptest.h @@ -0,0 +1,53 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * + * Copyright (c) 2008, Mozilla Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the Mozilla Corporation nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Contributor(s): + * Josh Aas + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef nptest_h_ +#define nptest_h_ + +#include "mozilla-config.h" + +#include "npapi.h" +#include "npfunctions.h" +#include "npruntime.h" + +typedef struct TestNPObject : NPObject { + NPP npp; +} TestNPObject; + +typedef struct InstanceData { + NPP npp; + NPWindow window; + TestNPObject* scriptableObject; +} InstanceData; + +#endif // nptest_h_ diff --git a/modules/plugin/test/testplugin/nptest_gtk2.cpp b/modules/plugin/test/testplugin/nptest_gtk2.cpp new file mode 100644 index 000000000000..b7fd96bd141c --- /dev/null +++ b/modules/plugin/test/testplugin/nptest_gtk2.cpp @@ -0,0 +1,51 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * + * Copyright (c) 2008, Mozilla Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the Mozilla Corporation nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Contributor(s): + * Josh Aas + * + * ***** END LICENSE BLOCK ***** */ + +#include "nptest_platform.h" + +NPError +pluginInstanceInit(InstanceData* instanceData) +{ + return NPERR_NO_ERROR; +} + +int16_t +pluginHandleEvent(InstanceData* instanceData, void* event) +{ + return 0; +} + +void +pluginDraw(InstanceData* instanceData) +{ +} diff --git a/modules/plugin/test/testplugin/nptest_macosx.mm b/modules/plugin/test/testplugin/nptest_macosx.mm new file mode 100644 index 000000000000..126bf56ece90 --- /dev/null +++ b/modules/plugin/test/testplugin/nptest_macosx.mm @@ -0,0 +1,167 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * + * Copyright (c) 2008, Mozilla Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the Mozilla Corporation nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Contributor(s): + * Josh Aas + * + * ***** END LICENSE BLOCK ***** */ + +#include "nptest_platform.h" +#include + +NPError +pluginInstanceInit(InstanceData* instanceData) +{ + NPP npp = instanceData->npp; + // select the right drawing model if necessary + NPBool supportsCoreGraphics = false; + if (NPN_GetValue(npp, NPNVsupportsCoreGraphicsBool, &supportsCoreGraphics) == NPERR_NO_ERROR && supportsCoreGraphics) { + NPN_SetValue(npp, NPPVpluginDrawingModel, (void*)NPDrawingModelCoreGraphics); + } else { + printf("CoreGraphics drawing model not supported, can't create a plugin instance.\n"); + return NPERR_INCOMPATIBLE_VERSION_ERROR; + } + return NPERR_NO_ERROR; +} + +int16_t +pluginHandleEvent(InstanceData* instanceData, void* event) +{ + EventRecord* carbonEvent = (EventRecord*)event; + if (carbonEvent && (carbonEvent->what == updateEvt)) { + pluginDraw(instanceData); + return 1; + } + return 0; +} + +void +pluginDraw(InstanceData* instanceData) +{ + if (!instanceData) + return; + + NPP npp = instanceData->npp; + if (!npp) + return; + + const char* uaString = NPN_UserAgent(npp); + if (!uaString) + return; + + NPWindow window = instanceData->window; + + CGContextRef cgContext = ((NP_CGContext*)(window.window))->context; + + CFStringRef uaCFString = CFStringCreateWithCString(kCFAllocatorDefault, uaString, kCFStringEncodingASCII); + + float windowWidth = window.width; + float windowHeight = window.height; + + // save the cgcontext gstate + CGContextSaveGState(cgContext); + + // we get a flipped context + CGContextTranslateCTM(cgContext, 0.0, windowHeight); + CGContextScaleCTM(cgContext, 1.0, -1.0); + + // draw a gray background for the plugin + CGContextAddRect(cgContext, CGRectMake(0, 0, windowWidth, windowHeight)); + CGContextSetGrayFillColor(cgContext, 0.5, 1.0); + CGContextDrawPath(cgContext, kCGPathFill); + + // draw a black frame around the plugin + CGContextAddRect(cgContext, CGRectMake(0, 0, windowWidth, windowHeight)); + CGContextSetGrayStrokeColor(cgContext, 0.0, 1.0); + CGContextSetLineWidth(cgContext, 6.0); + CGContextStrokePath(cgContext); + + // draw the UA string using ATSUI + CGContextSetGrayFillColor(cgContext, 0.0, 1.0); + ATSUStyle atsuStyle; + ATSUCreateStyle(&atsuStyle); + CFIndex stringLength = CFStringGetLength(uaCFString); + UniChar* unicharBuffer = (UniChar*)malloc((stringLength + 1) * sizeof(UniChar)); + CFStringGetCharacters(uaCFString, CFRangeMake(0, stringLength), unicharBuffer); + UniCharCount runLengths = kATSUToTextEnd; + ATSUTextLayout atsuLayout; + ATSUCreateTextLayoutWithTextPtr(unicharBuffer, + kATSUFromTextBeginning, + kATSUToTextEnd, + stringLength, + 1, + &runLengths, + &atsuStyle, + &atsuLayout); + ATSUAttributeTag contextTag = kATSUCGContextTag; + ByteCount byteSize = sizeof(CGContextRef); + ATSUAttributeValuePtr contextATSUPtr = &cgContext; + ATSUSetLayoutControls(atsuLayout, 1, &contextTag, &byteSize, &contextATSUPtr); + ATSUTextMeasurement lineAscent, lineDescent; + ATSUGetLineControl(atsuLayout, + kATSUFromTextBeginning, + kATSULineAscentTag, + sizeof(ATSUTextMeasurement), + &lineAscent, + &byteSize); + ATSUGetLineControl(atsuLayout, + kATSUFromTextBeginning, + kATSULineDescentTag, + sizeof(ATSUTextMeasurement), + &lineDescent, + &byteSize); + float lineHeight = FixedToFloat(lineAscent) + FixedToFloat(lineDescent); + ItemCount softBreakCount; + ATSUBatchBreakLines(atsuLayout, + kATSUFromTextBeginning, + stringLength, + FloatToFixed(windowWidth - 10.0), + &softBreakCount); + ATSUGetSoftLineBreaks(atsuLayout, + kATSUFromTextBeginning, + kATSUToTextEnd, + 0, NULL, &softBreakCount); + UniCharArrayOffset* softBreaks = (UniCharArrayOffset*)malloc(softBreakCount * sizeof(UniCharArrayOffset)); + ATSUGetSoftLineBreaks(atsuLayout, + kATSUFromTextBeginning, + kATSUToTextEnd, + softBreakCount, softBreaks, &softBreakCount); + UniCharArrayOffset currentDrawOffset = kATSUFromTextBeginning; + unsigned int i = 0; + while (i < softBreakCount) { + ATSUDrawText(atsuLayout, currentDrawOffset, softBreaks[i], FloatToFixed(5.0), FloatToFixed(windowHeight - 5.0 - (lineHeight * (i + 1.0)))); + currentDrawOffset = softBreaks[i]; + i++; + } + ATSUDrawText(atsuLayout, currentDrawOffset, kATSUToTextEnd, FloatToFixed(5.0), FloatToFixed(windowHeight - 5.0 - (lineHeight * (i + 1.0)))); + free(unicharBuffer); + free(softBreaks); + + // restore the cgcontext gstate + CGContextRestoreGState(cgContext); +} diff --git a/modules/plugin/test/testplugin/nptest_platform.h b/modules/plugin/test/testplugin/nptest_platform.h new file mode 100644 index 000000000000..2d8f2233bde5 --- /dev/null +++ b/modules/plugin/test/testplugin/nptest_platform.h @@ -0,0 +1,44 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * + * Copyright (c) 2008, Mozilla Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the Mozilla Corporation nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Contributor(s): + * Josh Aas + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef nptest_platform_h_ +#define nptest_platform_h_ + +#include "nptest.h" + +NPError pluginInstanceInit(InstanceData* instanceData); +int16_t pluginHandleEvent(InstanceData* instanceData, void* event); +// draws a gray box with a black border containing the browser UA string +void pluginDraw(InstanceData* instanceData); + +#endif // nptest_platform_h_ diff --git a/modules/plugin/test/testplugin/nptest_utils.cpp b/modules/plugin/test/testplugin/nptest_utils.cpp new file mode 100644 index 000000000000..fa91bd97ffbf --- /dev/null +++ b/modules/plugin/test/testplugin/nptest_utils.cpp @@ -0,0 +1,83 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * + * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Contributor(s): + * Josh Aas + * + * ***** END LICENSE BLOCK ***** */ + +#include "nptest_utils.h" + +#include + +NPUTF8* +createCStringFromNPVariant(const NPVariant* variant) +{ + size_t length = NPVARIANT_TO_STRING(*variant).UTF8Length; + NPUTF8* result = (NPUTF8*)malloc(length + 1); + memcpy(result, NPVARIANT_TO_STRING(*variant).UTF8Characters, length); + result[length] = '\0'; + return result; +} + +NPIdentifier +variantToIdentifier(NPVariant variant) +{ + if (NPVARIANT_IS_STRING(variant)) + return stringVariantToIdentifier(variant); + else if (NPVARIANT_IS_INT32(variant)) + return int32VariantToIdentifier(variant); + else if (NPVARIANT_IS_DOUBLE(variant)) + return doubleVariantToIdentifier(variant); + return 0; +} + +NPIdentifier +stringVariantToIdentifier(NPVariant variant) +{ + assert(NPVARIANT_IS_STRING(variant)); + NPUTF8* utf8String = createCStringFromNPVariant(&variant); + NPIdentifier identifier = NPN_GetStringIdentifier(utf8String); + free(utf8String); + return identifier; +} + +NPIdentifier +int32VariantToIdentifier(NPVariant variant) +{ + assert(NPVARIANT_IS_INT32(variant)); + int32 integer = NPVARIANT_TO_INT32(variant); + return NPN_GetIntIdentifier(integer); +} + +NPIdentifier +doubleVariantToIdentifier(NPVariant variant) +{ + assert(NPVARIANT_IS_DOUBLE(variant)); + double value = NPVARIANT_TO_DOUBLE(variant); + // sadly there is no "getdoubleidentifier" + int32 integer = static_cast(value); + return NPN_GetIntIdentifier(integer); +} diff --git a/modules/plugin/test/testplugin/nptest_utils.h b/modules/plugin/test/testplugin/nptest_utils.h new file mode 100644 index 000000000000..b39e2d57d82d --- /dev/null +++ b/modules/plugin/test/testplugin/nptest_utils.h @@ -0,0 +1,43 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * + * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Contributor(s): + * Josh Aas + * + * ***** END LICENSE BLOCK ***** */ + +#ifndef nptest_utils_h_ +#define nptest_utils_h_ + +#include "nptest.h" + +NPUTF8* createCStringFromNPVariant(const NPVariant* variant); + +NPIdentifier variantToIdentifier(NPVariant variant); +NPIdentifier stringVariantToIdentifier(NPVariant variant); +NPIdentifier int32VariantToIdentifier(NPVariant variant); +NPIdentifier doubleVariantToIdentifier(NPVariant variant); + +#endif // nptest_utils_h_ diff --git a/modules/plugin/test/testplugin/nptest_windows.cpp b/modules/plugin/test/testplugin/nptest_windows.cpp new file mode 100644 index 000000000000..b7fd96bd141c --- /dev/null +++ b/modules/plugin/test/testplugin/nptest_windows.cpp @@ -0,0 +1,51 @@ +/* ***** BEGIN LICENSE BLOCK ***** + * + * Copyright (c) 2008, Mozilla Corporation + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the Mozilla Corporation nor the names of its + * contributors may be used to endorse or promote products derived from this + * software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Contributor(s): + * Josh Aas + * + * ***** END LICENSE BLOCK ***** */ + +#include "nptest_platform.h" + +NPError +pluginInstanceInit(InstanceData* instanceData) +{ + return NPERR_NO_ERROR; +} + +int16_t +pluginHandleEvent(InstanceData* instanceData, void* event) +{ + return 0; +} + +void +pluginDraw(InstanceData* instanceData) +{ +}