Migrate a bunch of LayoutTests from NPAPI to PPAPI

ppapi/tests/blink_deprecated_test_plugin.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // A simple C++ Pepper plugin for exercising deprecated PPAPI interfaces in
 // Blink layout tests.
 //
 // Most layout tests should prefer to use the normal Blink test plugin, with the
 // MIME type application/x-blink-test-plugin. For layout tests that absolutely
 // need to test deprecated synchronous scripting interfaces, this plugin can be
 // instantiated using the application/x-blink-deprecated-test-plugin MIME type.
+//
+// The plugin exposes the following interface:
+//
+// Attributes:
+// testwindowopen: if set, the plugin will synchronously attempt to open a
+// window from DidCreateInstance, and log a message if successful.
+//
+// keydownscript: if set, the plugin will execute the value of the attribute as
+// a script on a key down.
+//
+// mousedownscript: if set, the plugin will execute the value of the attribute
+// as a script on a mouse button down.
+//
+//
+// Functions:
+// * plugin.normalize(): synchronously calls window.pluginCallback.
+//
+// * plugin.remember(value): keeps a reference on |value| in the plugin.
+//
+// * plugin.testCloneObject(): creates and returns another instance of the
+// plugin object.
+//
+// * plugin.testExecuteScript(script): synchronously evaluates |script| and
+// returns the result.
+//
+// * plugin.testGetProperty(property): returns the property named |property|
+// from the window object.
+//
+// * plugin.testPassTestObject(function, object): synchronously calls the
+// function named |function| on the window object, passing it |object| as a
+// parameter, and returns its result.
+//
+// * plugin.testScriptObjectInvoke(function, value): synchronously calls the
+// function named |function| on the window object, passing it |value| as a
+// parameter, and returns its result.
+//
+//
+// Properties:
+// * plugin.testObject (read-only): a TestObject instance (see below).
+//
+//
+// TestObject exposes the following interface:
+// Properties:
+// * object.testObject (read-only: another TestObject instance.
 
 #include <stdint.h>
 
 #include <map>
 #include <sstream>
+#include <unordered_map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/strings/stringprintf.h"
 #include "ppapi/cpp/dev/scriptable_object_deprecated.h"
+#include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/private/instance_private.h"
 #include "ppapi/cpp/private/var_private.h"
 #include "ppapi/cpp/var.h"
 
 namespace {
 
 class ScriptableBase : public pp::deprecated::ScriptableObject {
  public:
   explicit ScriptableBase(pp::InstancePrivate* instance)
@@ skipping 85 matching lines @@
   }
 
   pp::VarPrivate test_object_;
 };
 
 class InstanceSO : public ScriptableBase {
  public:
   explicit InstanceSO(pp::InstancePrivate* instance)
       : ScriptableBase(instance) {
     methods_.insert(std::make_pair(
+        "normalize",
+        base::Bind(&InstanceSO::Normalize, base::Unretained(this))));
+    methods_.insert(std::make_pair(
+        "remember",
+        base::Bind(&InstanceSO::Remember, base::Unretained(this))));
+    methods_.insert(std::make_pair(
+        "testCloneObject",
+        base::Bind(&InstanceSO::TestCloneObject, base::Unretained(this))));
+    methods_.insert(std::make_pair(
         "testExecuteScript",
         base::Bind(&InstanceSO::TestExecuteScript, base::Unretained(this))));
     methods_.insert(std::make_pair(
         "testGetProperty",
         base::Bind(&InstanceSO::TestGetProperty, base::Unretained(this))));
     methods_.insert(std::make_pair(
         "testPassTestObject",
         base::Bind(&InstanceSO::TestPassTestObject, base::Unretained(this))));
+    // Note: the semantics of testScriptObjectInvoke are identical to the
+    // semantics of testPassTestObject: call args[0] with args[1] as a
+    // parameter.
+    methods_.insert(
+        std::make_pair("testScriptObjectInvoke",
+                       base::Bind(&InstanceSO::TestPassTestObject,
+                                  base::Unretained(this))));
     properties_.insert(std::make_pair(
         "testObject", base::Bind(&InstanceSO::TestObjectAccessor,
                                  base::Unretained(this))));
   }
   ~InstanceSO() override {}
 
  private:
+  // Requires no argument.
+  pp::Var Normalize(const std::vector<pp::Var>& args, pp::Var* exception) {
+    pp::VarPrivate object = instance_->GetWindowObject();
+    return object.Call(pp::Var("pluginCallback"), exception);
+  }
+
+  // Requires 1 argument. The argument is retained into remembered_
+  pp::Var Remember(const std::vector<pp::Var>& args, pp::Var* exception) {
+    if (args.size() != 1) {
+      *exception = pp::Var("remember requires one argument");
+      return pp::Var();
+    }
+    remembered_ = args[0];
+    return pp::Var();
+  }
+
+  // Requires no argument.
+  pp::Var TestCloneObject(const std::vector<pp::Var>& args,
+                          pp::Var* exception) {
+    return pp::VarPrivate(instance_, new InstanceSO(instance_));
+  }
+
   // Requires one argument. The argument is passed through as-is to
   // pp::InstancePrivate::ExecuteScript().
   pp::Var TestExecuteScript(const std::vector<pp::Var>& args,
                             pp::Var* exception) {
     if (args.size() != 1) {
       *exception = pp::Var("testExecuteScript requires one argument");
       return pp::Var();
     }
     return instance_->ExecuteScript(args[0], exception);
   }
@@ skipping 30 matching lines @@
 
   void TestObjectAccessor(bool set, pp::Var* var) {
     if (set)
       return;
     if (test_object_.is_undefined())
       test_object_ = pp::VarPrivate(instance_, new TestObjectSO(instance_));
     *var = test_object_;
   }
 
   pp::VarPrivate test_object_;
+  pp::Var remembered_;
 };
 
 class BlinkDeprecatedTestInstance : public pp::InstancePrivate {
  public:
   explicit BlinkDeprecatedTestInstance(PP_Instance instance)
       : pp::InstancePrivate(instance) {}
   ~BlinkDeprecatedTestInstance() override {
     LogMessage("%s", "Destroying");
   }
 
-  bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
+  // pp::Instance overrides
+  bool Init(uint32_t argc, const char* argn[], const char* argv[]) override {
+    for (uint32_t i = 0; i < argc; ++i)
+      attributes_[argn[i]] = argv[i];
+
+    if (HasAttribute("testwindowopen"))
+      return TestWindowOpen();
+
+    uint32_t event_classes = 0;
+    if (HasAttribute("keydownscript"))
+        event_classes |= PP_INPUTEVENT_CLASS_KEYBOARD;
+    if (HasAttribute("mousedownscript"))
+        event_classes |= PP_INPUTEVENT_CLASS_MOUSE;
+    RequestFilteringInputEvents(event_classes);
+
     return true;
   }
 
+  virtual bool HandleInputEvent(const pp::InputEvent& event) override {
+    switch (event.GetType()) {
+      case PP_INPUTEVENT_TYPE_MOUSEDOWN:
+        if (HasAttribute("mousedownscript"))
+          ExecuteScript(attributes_["mousedownscript"]);
+        return true;
+      case PP_INPUTEVENT_TYPE_KEYDOWN:
+        if (HasAttribute("keydownscript"))
+          ExecuteScript(attributes_["keydownscript"]);
+        return true;
+      default:
+        return false;
+    }
+  }
+
   // pp::InstancePrivate overrides:
   pp::Var GetInstanceObject() override {
     if (instance_var_.is_undefined()) {
       instance_so_ = new InstanceSO(this);
       instance_var_ = pp::VarPrivate(this, instance_so_);
     }
     return instance_var_;
   }
 
+  void NotifyTestCompletion() {
+    ExecuteScript("window.testRunner.notifyDone()");
+  }
+
+  bool TestWindowOpen() {
+    pp::Var result = GetWindowObject().Call(
+        pp::Var("open"), pp::Var("about:blank"), pp::Var("_blank"));
+    if (result.is_object())
+      LogMessage("PLUGIN: WINDOW OPEN SUCCESS");
+    NotifyTestCompletion();
+    return true;
+  }
+
   void LogMessage(const char* format...) {
     va_list args;
     va_start(args, format);
     LogToConsoleWithSource(PP_LOGLEVEL_LOG,
                            pp::Var("Blink Deprecated Test Plugin"),
                            pp::Var(base::StringPrintV(format, args)));
     va_end(args);
   }
 
  private:
+  bool HasAttribute(const std::string& name) {
+    return attributes_.find(name) != attributes_.end();
+  }
+
+  std::unordered_map<std::string, std::string> attributes_;
   pp::VarPrivate instance_var_;
   // Owned by |instance_var_|.
   InstanceSO* instance_so_;
 };
 
 class BlinkDeprecatedTestModule : public pp::Module {
  public:
   BlinkDeprecatedTestModule() {}
   ~BlinkDeprecatedTestModule() override {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new BlinkDeprecatedTestInstance(instance);
   }
 };
 
 }  // namespace
 
 namespace pp {
 
 Module* CreateModule() {
   return new BlinkDeprecatedTestModule();
 }
 
 }  // namespace pp