Reviewed by Tim O.
[WebKit-https.git] / WebKitTools / DumpRenderTree / TestNetscapePlugIn.subproj / PluginObject.c
index 65d6457..d05cc14 100644 (file)
  WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR 
  OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #import "PluginObject.h"
 
-void pluginInvalidate ();
-bool pluginHasProperty (NPClass *theClass, NPIdentifier name);
-bool pluginHasMethod (NPClass *theClass, NPIdentifier name);
-void pluginGetProperty (PluginObject *obj, NPIdentifier name, NPVariant *variant);
-void pluginSetProperty (PluginObject *obj, NPIdentifier name, const NPVariant *variant);
-void pluginInvoke (PluginObject *obj, NPIdentifier name, NPVariant *args, uint32_t argCount, NPVariant *result);
-void pluginInvokeDefault (PluginObject *obj, NPVariant *args, uint32_t argCount, NPVariant *result);
-NPObject *pluginAllocate (NPP npp, NPClass *theClass);
-void pluginDeallocate (PluginObject *obj);
-
-static NPClass _pluginFunctionPtrs = { 
+static void pluginInvalidate(NPObject *obj);
+static bool pluginHasProperty(NPObject *obj, NPIdentifier name);
+static bool pluginHasMethod(NPObject *obj, NPIdentifier name);
+static bool pluginGetProperty(NPObject *obj, NPIdentifier name, NPVariant *variant);
+static bool pluginSetProperty(NPObject *obj, NPIdentifier name, const NPVariant *variant);
+static bool pluginInvoke(NPObject *obj, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result);
+static bool pluginInvokeDefault(NPObject *obj, const NPVariant *args, uint32_t argCount, NPVariant *result);
+static NPObject *pluginAllocate(NPP npp, NPClass *theClass);
+static void pluginDeallocate(NPObject *obj);
+
+NPNetscapeFuncs *browser;
+
+static NPClass pluginClass = { 
     NP_CLASS_STRUCT_VERSION,
-    (NPAllocateFunctionPtr) pluginAllocate, 
-    (NPDeallocateFunctionPtr) pluginDeallocate, 
-    (NPInvalidateFunctionPtr) pluginInvalidate,
-    (NPHasMethodFunctionPtr) pluginHasMethod,
-    (NPInvokeFunctionPtr) pluginInvoke,
-    (NPInvokeDefaultFunctionPtr) pluginInvokeDefault,
-    (NPHasPropertyFunctionPtr) pluginHasProperty,
-    (NPGetPropertyFunctionPtr) pluginGetProperty,
-    (NPSetPropertyFunctionPtr) pluginSetProperty,
+    pluginAllocate, 
+    pluginDeallocate, 
+    pluginInvalidate,
+    pluginHasMethod,
+    pluginInvoke,
+    pluginInvokeDefault,
+    pluginHasProperty,
+    pluginGetProperty,
+    pluginSetProperty,
 };
  
 NPClass *getPluginClass(void)
 {
-    return &_pluginFunctionPtrs;
+    return &pluginClass;
 }
 
 static bool identifiersInitialized = false;
@@ -71,92 +74,150 @@ static const NPUTF8 *pluginPropertyIdentifierNames[NUM_PROPERTY_IDENTIFIERS] = {
 };
 
 #define ID_TEST_CALLBACK_METHOD     0
-#define NUM_METHOD_IDENTIFIERS      1
+#define ID_TEST_GETURL              1
+#define ID_REMOVE_DEFAULT_METHOD    2
+#define ID_TEST_DOM_ACCESS          3
+
+#define NUM_METHOD_IDENTIFIERS      4
 
 static NPIdentifier pluginMethodIdentifiers[NUM_METHOD_IDENTIFIERS];
 static const NPUTF8 *pluginMethodIdentifierNames[NUM_METHOD_IDENTIFIERS] = {
-    "testCallback"
+    "testCallback",
+    "getURL",
+    "removeDefaultMethod",
+    "testDOMAccess"
 };
 
-static void initializeIdentifiers()
+static NPUTF8* createCStringFromNPVariant(const NPVariant *variant)
 {
-    browser->getstringidentifiers (pluginPropertyIdentifierNames, NUM_PROPERTY_IDENTIFIERS, pluginPropertyIdentifiers);
-    browser->getstringidentifiers (pluginMethodIdentifierNames, NUM_METHOD_IDENTIFIERS, pluginMethodIdentifiers);
-};
+    size_t length = NPVARIANT_TO_STRING(*variant).UTF8Length;
+    NPUTF8* result = malloc(length + 1);
+    memcpy(result, NPVARIANT_TO_STRING(*variant).UTF8Characters, length);
+    result[length] = '\0';
+    return result;
+}
 
-bool pluginHasProperty (NPClass *theClass, NPIdentifier name)
+static void initializeIdentifiers(void)
 {
-    for (int i = 0; i < NUM_PROPERTY_IDENTIFIERS; i++) {
+    browser->getstringidentifiers(pluginPropertyIdentifierNames, NUM_PROPERTY_IDENTIFIERS, pluginPropertyIdentifiers);
+    browser->getstringidentifiers(pluginMethodIdentifierNames, NUM_METHOD_IDENTIFIERS, pluginMethodIdentifiers);
+}
+
+static bool pluginHasProperty(NPObject *obj, NPIdentifier name)
+{
+    for (int i = 0; i < NUM_PROPERTY_IDENTIFIERS; i++)
         if (name == pluginPropertyIdentifiers[i])
             return true;
-    }
     return false;
 }
 
-bool pluginHasMethod (NPClass *theClass, NPIdentifier name)
+static bool pluginHasMethod(NPObject *obj, NPIdentifier name)
 {
-    for (int i = 0; i < NUM_METHOD_IDENTIFIERS; i++) {
+    for (int i = 0; i < NUM_METHOD_IDENTIFIERS; i++)
         if (name == pluginMethodIdentifiers[i])
             return true;
-    }
     return false;
 }
 
-void pluginGetProperty (PluginObject *obj, NPIdentifier name, NPVariant *variant)
+static bool pluginGetProperty(NPObject *obj, NPIdentifier name, NPVariant *variant)
 {
     if (name == pluginPropertyIdentifiers[ID_PROPERTY_PROPERTY]) {
-        // just return "property"
-        NPString propertyNameString;
-        propertyNameString.UTF8Characters = "property";
-        propertyNameString.UTF8Length = sizeof("property") - 1;
-        variant->type = NPVariantType_String;
-        variant->value.stringValue = propertyNameString;
-    } else
-        variant->type = NPVariantType_Void;
+        STRINGZ_TO_NPVARIANT("property", *variant);
+        return true;
+    }
+    return false;
 }
 
-void pluginSetProperty (PluginObject *obj, NPIdentifier name, const NPVariant *variant)
+static bool pluginSetProperty(NPObject *obj, NPIdentifier name, const NPVariant *variant)
 {
+    return false;
 }
 
-void pluginInvoke (PluginObject *obj, NPIdentifier name, NPVariant *args, unsigned argCount, NPVariant *result)
+static void testDOMAccess(PluginObject *obj)
 {
+    // Get plug-in's DOM element
+    NPObject *elementObject;
+    if (browser->getvalue(obj->npp, NPNVPluginElementNPObject, &elementObject) == NPERR_NO_ERROR) {
+        // Get style
+        NPVariant styleVariant;
+        NPIdentifier styleIdentifier = browser->getstringidentifier("style");
+        if (browser->getproperty(obj->npp, elementObject, styleIdentifier, &styleVariant) && NPVARIANT_IS_OBJECT(styleVariant)) {
+            // Set style.border
+            NPIdentifier borderIdentifier = browser->getstringidentifier("border");
+            NPVariant borderVariant;
+            STRINGZ_TO_NPVARIANT("3px solid red", borderVariant);
+            browser->setproperty(obj->npp, NPVARIANT_TO_OBJECT(styleVariant), borderIdentifier, &borderVariant);
+            browser->releasevariantvalue(&styleVariant);
+        }
+        
+        browser->releaseobject(elementObject);
+    }
+}
+
+static bool pluginInvoke(NPObject *header, NPIdentifier name, const NPVariant *args, uint32_t argCount, NPVariant *result)
+{
+    PluginObject *obj = (PluginObject *)header;
     if (name == pluginMethodIdentifiers[ID_TEST_CALLBACK_METHOD]) {
         // call whatever method name we're given
-        if (argCount > 0 && args->type == NPVariantType_String) {
-            NPVariant browserResult;
-            
+        if (argCount > 0 && NPVARIANT_IS_STRING(args[0])) {
             NPObject *windowScriptObject;
             browser->getvalue(obj->npp, NPPVpluginScriptableNPObject, &windowScriptObject);
 
-            NPString argString = args[0].value.stringValue;
-            int size = argString.UTF8Length + 1;
-            NPUTF8 callbackString[size];
-            strncpy(callbackString, argString.UTF8Characters, argString.UTF8Length);
-            callbackString[size - 1] = '\0';
+            NPUTF8* callbackString = createCStringFromNPVariant(&args[0]);
+            NPIdentifier callbackIdentifier = browser->getstringidentifier(callbackString);
+            free(callbackString);
+
+            NPVariant browserResult;
+            browser->invoke(obj->npp, windowScriptObject, callbackIdentifier, 0, 0, &browserResult);
+            browser->releasevariantvalue(&browserResult);
+
+            VOID_TO_NPVARIANT(*result);
+            return true;
+        }
+    } else if (name == pluginMethodIdentifiers[ID_TEST_GETURL]) {
+        if (argCount == 2 && NPVARIANT_IS_STRING(args[0]) && NPVARIANT_IS_STRING(args[1])) {
+            NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
+            NPUTF8* targetString = createCStringFromNPVariant(&args[1]);
+            browser->geturl(obj->npp, urlString, targetString);
+            free(urlString);
+            free(targetString);
+
+            VOID_TO_NPVARIANT(*result);
+            return true;
+        } else if (argCount == 1 && NPVARIANT_IS_STRING(args[0])) {
+            NPUTF8* urlString = createCStringFromNPVariant(&args[0]);
+            browser->geturl(obj->npp, urlString, 0);
+            free(urlString);
 
-            NPIdentifier callbackMethodID = browser->getstringidentifier(callbackString);
-            browser->invoke(obj->npp, windowScriptObject, callbackMethodID, 0, 0, &browserResult);
+            VOID_TO_NPVARIANT(*result);
+            return true;
         }
+    } else if (name == pluginMethodIdentifiers[ID_REMOVE_DEFAULT_METHOD]) {
+        pluginClass.invokeDefault = 0;
+        VOID_TO_NPVARIANT(*result);
+        return true;
+    } else if (name == pluginMethodIdentifiers[ID_TEST_DOM_ACCESS]) {
+        testDOMAccess(obj);
+        VOID_TO_NPVARIANT(*result);
+        return true;
     }
 
-    result->type = NPVariantType_Void;
+    return false;
 }
 
-void pluginInvokeDefault (PluginObject *obj, NPVariant *args, unsigned argCount, NPVariant *result)
+static bool pluginInvokeDefault(NPObject *obj, const NPVariant *args, uint32_t argCount, NPVariant *result)
 {
-    result->type = NPVariantType_Void;
+    INT32_TO_NPVARIANT(1, *result);
+    return true;
 }
 
-void pluginInvalidate ()
+static void pluginInvalidate(NPObject *obj)
 {
-    // Make sure we've released any remainging references to JavaScript
-    // objects.
 }
 
-NPObject *pluginAllocate (NPP npp, NPClass *theClass)
+static NPObject *pluginAllocate(NPP npp, NPClass *theClass)
 {
-    PluginObject *newInstance = (PluginObject *)malloc (sizeof(PluginObject));
+    PluginObject *newInstance = malloc(sizeof(PluginObject));
     
     if (!identifiersInitialized) {
         identifiersInitialized = true;
@@ -168,8 +229,7 @@ NPObject *pluginAllocate (NPP npp, NPClass *theClass)
     return (NPObject *)newInstance;
 }
 
-void pluginDeallocate (PluginObject *obj) 
+static void pluginDeallocate(NPObject *obj) 
 {
-    free ((void *)obj);
+    free(obj);
 }
-