Port refcount-leaks 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
@@ skipping 13 matching lines @@
 //
 //
 // 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.testCreateTestObject(): creates and returns a new TestObject
+// instance (see below).
+//
 // * 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).
 //
+// * plugin.testObjectCount (read-only): the number of TestObject instance
+// created.
+//
 // * plugin.testGetUndefined (read-only): returns undefined.
 //
 //
 // TestObject exposes the following interface:
 // Properties:
 // * object.testObject (read-only: another TestObject instance.
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 82 matching lines @@
 
   pp::InstancePrivate* const instance_;
   MethodMap methods_;
   PropertyMap properties_;
 };
 
 class TestObjectSO : public ScriptableBase {
  public:
   explicit TestObjectSO(pp::InstancePrivate* instance)
       : ScriptableBase(instance) {
+    ++count_;
     properties_.insert(std::make_pair(
         "testObject",
         base::Bind(&TestObjectSO::TestObjectAccessor, base::Unretained(this))));
   }
-  ~TestObjectSO() override {}
+  ~TestObjectSO() override {
+    --count_;
+  }
+
+  static int32_t count() { return count_; }
 
  private:
   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_;
   }
 
+  static int32_t count_;
+
   pp::VarPrivate test_object_;
 };
 
+int32_t TestObjectSO::count_ = 0;
+
 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(
+        "testCreateTestObject",
+        base::Bind(&InstanceSO::TestCreateTestObject, 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))));
     properties_.insert(std::make_pair(
+        "testObjectCount", base::Bind(&InstanceSO::TestObjectCountAccessor,
+                                      base::Unretained(this))));
+    properties_.insert(std::make_pair(
         "testGetUndefined", base::Bind(&InstanceSO::TestGetUndefinedAccessor,
                                        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 no argument.
+  pp::Var TestCreateTestObject(const std::vector<pp::Var>& args,
+                               pp::Var* exception) {
+    return pp::VarPrivate(instance_, new TestObjectSO(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 29 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_;
   }
 
+  void TestObjectCountAccessor(bool set, pp::Var* var) {
+    if (set)
+      return;
+    *var = pp::Var(TestObjectSO::count());
+  }
+
   void TestGetUndefinedAccessor(bool set, pp::Var* var) {
     if (set)
       return;
     *var = pp::Var();
   }
 
   pp::VarPrivate test_object_;
   pp::Var remembered_;
 };
 
@@ skipping 92 matching lines @@
 
 }  // namespace
 
 namespace pp {
 
 Module* CreateModule() {
   return new BlinkDeprecatedTestModule();
 }
 
 }  // namespace pp