Add NPN_Evaluate and NPN_Push/PopPopupsEnabledState support

dom/plugins/PPluginInstance.ipdl

@@ -113,6 +113,12 @@ parent:
 
   async NPN_InvalidateRect(NPRect rect);
 
+  rpc NPN_PushPopupsEnabledState(bool aState)
+    returns (bool aSuccess);
+
+  rpc NPN_PopPopupsEnabledState()
+    returns (bool aSuccess);
+
 child:
   /**
    * Represents NPP_URLNotify

dom/plugins/PPluginScriptableObject.ipdl

@@ -67,6 +67,11 @@ rpc protocol PPluginScriptableObject
 {
   manager PPluginInstance;
 
+parent:
+  rpc NPN_Evaluate(nsCString aScript)
+    returns (Variant aResult,
+             bool aSuccess);
+
 both:
   // NPClass methods
   rpc Invalidate();

dom/plugins/PluginInstanceParent.cpp

@@ -581,29 +581,44 @@ PluginInstanceParent::NPP_URLNotify(const char* url, NPReason reason,
 PluginScriptableObjectParent*
 PluginInstanceParent::GetActorForNPObject(NPObject* aObject)
 {
-  NS_ASSERTION(aObject, "Null pointer!");
+    NS_ASSERTION(aObject, "Null pointer!");
 
-  if (aObject->_class == PluginScriptableObjectParent::GetClass()) {
-      // One of ours!
-      ParentNPObject* object = static_cast<ParentNPObject*>(aObject);
-      NS_ASSERTION(object->parent, "Null actor!");
-      return object->parent;
-  }
+    if (aObject->_class == PluginScriptableObjectParent::GetClass()) {
+        // One of ours!
+        ParentNPObject* object = static_cast<ParentNPObject*>(aObject);
+        NS_ASSERTION(object->parent, "Null actor!");
+        return object->parent;
+    }
 
-  PRUint32 count = mScriptableObjects.Length();
-  for (PRUint32 index = 0; index < count; index++) {
-      nsAutoPtr<PluginScriptableObjectParent>& actor =
-          mScriptableObjects[index];
-      if (actor->GetObject() == aObject) {
-          return actor;
-      }
-  }
+    PRUint32 count = mScriptableObjects.Length();
+    for (PRUint32 index = 0; index < count; index++) {
+        nsAutoPtr<PluginScriptableObjectParent>& actor =
+            mScriptableObjects[index];
+        if (actor->GetObject() == aObject) {
+            return actor;
+        }
+    }
 
-  PluginScriptableObjectParent* actor =
-      static_cast<PluginScriptableObjectParent*>(
-          CallPPluginScriptableObjectConstructor());
-  NS_ENSURE_TRUE(actor, nsnull);
+    PluginScriptableObjectParent* actor =
+        static_cast<PluginScriptableObjectParent*>(
+            CallPPluginScriptableObjectConstructor());
+    NS_ENSURE_TRUE(actor, nsnull);
 
-  actor->Initialize(const_cast<PluginInstanceParent*>(this), aObject);
-  return actor;
+    actor->Initialize(const_cast<PluginInstanceParent*>(this), aObject);
+    return actor;
+}
+
+bool
+PluginInstanceParent::AnswerNPN_PushPopupsEnabledState(const bool& aState,
+                                                       bool* aSuccess)
+{
+    *aSuccess = mNPNIface->pushpopupsenabledstate(mNPP, aState ? 1 : 0);
+    return true;
+}
+
+bool
+PluginInstanceParent::AnswerNPN_PopPopupsEnabledState(bool* aSuccess)
+{
+    *aSuccess = mNPNIface->poppopupsenabledstate(mNPP);
+    return true;
 }

dom/plugins/PluginInstanceParent.h

@@ -153,6 +153,13 @@ public:
     virtual bool
     RecvNPN_InvalidateRect(const NPRect& rect);
 
+    virtual bool
+    AnswerNPN_PushPopupsEnabledState(const bool& aState,
+                                     bool* aSuccess);
+
+    virtual bool
+    AnswerNPN_PopPopupsEnabledState(bool* aSuccess);
+
     NPError NPP_SetWindow(const NPWindow* aWindow);
 
     NPError NPP_GetValue(NPPVariable variable, void *ret_value);

dom/plugins/PluginModuleChild.cpp

@@ -947,15 +947,26 @@ _invokedefault(NPP aNPP,
 
 bool NP_CALLBACK
 _evaluate(NPP aNPP,
-          NPObject* aNPObj,
+          NPObject* aObject,
           NPString* aScript,
           NPVariant* aResult)
 {
     _MOZ_LOG(__FUNCTION__);
     AssertPluginThread();
 
-    NS_NOTYETIMPLEMENTED("Implement me!");
-    return false;
+    if (!(aNPP && aObject && aScript && aResult)) {
+        NS_ERROR("Bad arguments!");
+        return false;
+    }
+
+    PluginScriptableObjectChild* actor =
+      InstCast(aNPP)->GetActorForNPObject(aObject);
+    if (!actor) {
+        NS_ERROR("Failed to create actor?!");
+        return false;
+    }
+
+    return actor->Evaluate(aScript, aResult);
 }
 
 bool NP_CALLBACK
@@ -1105,7 +1116,11 @@ _pushpopupsenabledstate(NPP aNPP,
 {
     _MOZ_LOG(__FUNCTION__);
     AssertPluginThread();
-    NS_NOTYETIMPLEMENTED("Implement me!");
+    bool retval;
+    if (InstCast(aNPP)->CallNPN_PushPopupsEnabledState(aEnabled ? true : false,
+                                                       &retval)) {
+        return retval;
+    }
     return false;
 }
 
@@ -1114,7 +1129,10 @@ _poppopupsenabledstate(NPP aNPP)
 {
     _MOZ_LOG(__FUNCTION__);
     AssertPluginThread();
-    NS_NOTYETIMPLEMENTED("Implement me!");
+    bool retval;
+    if (InstCast(aNPP)->CallNPN_PopPopupsEnabledState(&retval)) {
+        return retval;
+    }
     return false;
 }
 

dom/plugins/PluginScriptableObjectChild.cpp

@@ -1084,3 +1084,22 @@ PluginScriptableObjectChild::AnswerConstruct(const nsTArray<Variant>& aArgs,
   *aSuccess = true;
   return true;
 }
+
+bool
+PluginScriptableObjectChild::Evaluate(NPString* aScript,
+                                      NPVariant* aResult)
+{
+  nsDependentCString script("");
+  if (aScript->UTF8Characters && aScript->UTF8Length) {
+    script.Rebind(aScript->UTF8Characters, aScript->UTF8Length);
+  }
+
+  bool success;
+  Variant result;
+  if (!(CallNPN_Evaluate(script, &result, &success) && success)) {
+    return false;
+  }
+
+  ConvertToVariant(result, *aResult);
+  return true;
+}

dom/plugins/PluginScriptableObjectChild.h

@@ -130,6 +130,10 @@ public:
     return mInstance;
   }
 
+  bool
+  Evaluate(NPString* aScript,
+           NPVariant* aResult);
+
 private:
   static NPObject*
   ScriptableAllocate(NPP aInstance,

dom/plugins/PluginScriptableObjectParent.cpp

@@ -1330,3 +1330,50 @@ PluginScriptableObjectParent::AnswerConstruct(const nsTArray<Variant>& aArgs,
   *aResult = convertedResult;
   return true;
 }
+
+bool
+PluginScriptableObjectParent::AnswerNPN_Evaluate(const nsCString& aScript,
+                                                 Variant* aResult,
+                                                 bool* aSuccess)
+{
+  PluginInstanceParent* instance = GetInstance();
+  if (!instance) {
+    NS_ERROR("No instance?!");
+    *aResult = void_t();
+    *aSuccess = false;
+    return true;
+  }
+
+  const NPNetscapeFuncs* npn = GetNetscapeFuncs(instance);
+  if (!npn) {
+    NS_ERROR("No netscape funcs?!");
+    *aResult = void_t();
+    *aSuccess = false;
+    return true;
+  }
+
+  NPString script = { aScript.get(), aScript.Length() };
+
+  NPVariant result;
+  bool success = npn->evaluate(instance->GetNPP(), mObject, &script, &result);
+  if (!success) {
+    *aResult = void_t();
+    *aSuccess = false;
+    return true;
+  }
+
+  Variant convertedResult;
+  success = ConvertToRemoteVariant(result, convertedResult, instance);
+
+  ReleaseVariant(result, instance);
+
+  if (!success) {
+    *aResult = void_t();
+    *aSuccess = false;
+    return true;
+  }
+
+  *aSuccess = true;
+  *aResult = convertedResult;
+  return true;
+}

dom/plugins/PluginScriptableObjectParent.h

@@ -109,6 +109,11 @@ public:
                   Variant* aResult,
                   bool* aSuccess);
 
+  virtual bool
+  AnswerNPN_Evaluate(const nsCString& aScript,
+                     Variant* aResult,
+                     bool* aSuccess);
+
   void
   Initialize(PluginInstanceParent* aInstance,
              NPObject* aObject);