gin

content/renderer/pepper/host_var_tracker_unittest.cc

Index: content/renderer/pepper/host_var_tracker_unittest.cc
diff --git a/content/renderer/pepper/host_var_tracker_unittest.cc b/content/renderer/pepper/host_var_tracker_unittest.cc
index 07b759dce69343f75b727db0582887d05eb45ca8..fd9c22f23d2f7cc8ca8dd24833445030da3d1359 100644
--- a/content/renderer/pepper/host_var_tracker_unittest.cc
+++ b/content/renderer/pepper/host_var_tracker_unittest.cc
@@ -6,53 +6,53 @@
 #include "content/renderer/pepper/host_globals.h"
 #include "content/renderer/pepper/host_var_tracker.h"
 #include "content/renderer/pepper/mock_resource.h"
-#include "content/renderer/pepper/npapi_glue.h"
-#include "content/renderer/pepper/npobject_var.h"
 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
+#include "content/renderer/pepper/pepper_try_catch.h"
+#include "content/renderer/pepper/v8object_var.h"
 #include "content/test/ppapi_unittest.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppp_instance.h"
-#include "third_party/npapi/bindings/npruntime.h"
 #include "third_party/WebKit/public/web/WebBindings.h"
 
-using ppapi::NPObjectVar;
+using ppapi::V8ObjectVar;
 
 namespace content {
 
 namespace {
 
-// Tracked NPObjects -----------------------------------------------------------
+int g_v8objects_alive = 0;
 
-int g_npobjects_alive = 0;
+class MyObject : public gin::Wrappable<MyObject> {
+ public:
+  static gin::WrapperInfo kWrapperInfo;
 
-void TrackedClassDeallocate(NPObject* npobject) {
-  g_npobjects_alive--;
-  delete npobject;
-}
+  static v8::Handle<v8::Value> Create(v8::Isolate* isolate) {
+    return CreateHandle(isolate, new MyObject()).ToV8();
+  }
 
-NPClass g_tracked_npclass = {
-    NP_CLASS_STRUCT_VERSION, NULL, &TrackedClassDeallocate, NULL, NULL, NULL,
-    NULL,                    NULL, NULL,                    NULL, NULL, NULL, };
+  MyObject() { ++g_v8objects_alive; }
+  virtual ~MyObject() { --g_v8objects_alive; }
+};
 
-// Returns a new tracked NPObject with a refcount of 1. You'll want to put this
-// in a NPObjectReleaser to free this ref when the test completes.
-NPObject* NewTrackedNPObject() {
-  NPObject* object = new NPObject;
-  object->_class = &g_tracked_npclass;
-  object->referenceCount = 1;
+gin::WrapperInfo MyObject::kWrapperInfo = {gin::kEmbedderNativeGin};
 
-  g_npobjects_alive++;
-  return object;
-}
+class PepperTryCatchForTest : public PepperTryCatch {
+ public:
+  PepperTryCatchForTest(PepperPluginInstanceImpl* instance)
+      : PepperTryCatch(instance, true),
+        handle_scope_(instance->GetIsolate()),
+        context_scope_(v8::Context::New(instance->GetIsolate())) {}
+
+  virtual void SetException(const char* message) OVERRIDE { DCHECK(false); }
+  virtual v8::Handle<v8::Context> GetContext() OVERRIDE {
+    return instance_->GetIsolate()->GetCurrentContext();
+  }
 
-struct ReleaseNPObject {
-  void operator()(NPObject* o) const { blink::WebBindings::releaseObject(o); }
+ private:
+  v8::HandleScope handle_scope_;
+  v8::Context::Scope context_scope_;
 };
 
-// Handles automatically releasing a reference to the NPObject on destruction.
-// It's assumed the input has a ref already taken.
-typedef scoped_ptr<NPObject, ReleaseNPObject> NPObjectReleaser;
-
 }  // namespace
 
 class HostVarTrackerTest : public PpapiUnittest {
@@ -63,54 +63,61 @@ class HostVarTrackerTest : public PpapiUnittest {
 };
 
 TEST_F(HostVarTrackerTest, DeleteObjectVarWithInstance) {
+  v8::Isolate* test_isolate = v8::Isolate::GetCurrent();
+
   // Make a second instance (the test harness already creates & manages one).
   scoped_refptr<PepperPluginInstanceImpl> instance2(
       PepperPluginInstanceImpl::Create(NULL, module(), NULL, GURL()));
   PP_Instance pp_instance2 = instance2->pp_instance();
 
-  // Make an object var.
-  NPObjectReleaser npobject(NewTrackedNPObject());
-  NPObjectToPPVarForTest(instance2.get(), npobject.get());
-
-  EXPECT_EQ(1, g_npobjects_alive);
-  EXPECT_EQ(1, tracker().GetLiveNPObjectVarsForInstance(pp_instance2));
+  {
+    PepperTryCatchForTest try_catch(instance2.get());
+    // Make an object var.
+    ppapi::ScopedPPVar var = try_catch.FromV8(MyObject::Create(test_isolate));
+    EXPECT_EQ(1, g_v8objects_alive);
+    EXPECT_EQ(1, tracker().GetLiveV8ObjectVarsForInstance(pp_instance2));
+    // Purposely leak the var.
+    var.Release();
+  }
 
   // Free the instance, this should release the ObjectVar.
   instance2 = NULL;
-  EXPECT_EQ(0, tracker().GetLiveNPObjectVarsForInstance(pp_instance2));
+  EXPECT_EQ(0, tracker().GetLiveV8ObjectVarsForInstance(pp_instance2));
+  test_isolate->RequestGarbageCollectionForTesting(
+      v8::Isolate::kFullGarbageCollection);
+  EXPECT_EQ(0, g_v8objects_alive);
 }
 
 // Make sure that using the same NPObject should give the same PP_Var
 // each time.
 TEST_F(HostVarTrackerTest, ReuseVar) {
-  NPObjectReleaser npobject(NewTrackedNPObject());
+  v8::Isolate* test_isolate = v8::Isolate::GetCurrent();
+  PepperTryCatchForTest try_catch(instance());
 
-  PP_Var pp_object1 = NPObjectToPPVarForTest(instance(), npobject.get());
-  PP_Var pp_object2 = NPObjectToPPVarForTest(instance(), npobject.get());
+  v8::Handle<v8::Value> v8_object = MyObject::Create(test_isolate);
+  ppapi::ScopedPPVar pp_object1 = try_catch.FromV8(v8_object);
+  ppapi::ScopedPPVar pp_object2 = try_catch.FromV8(v8_object);
 
   // The two results should be the same.
-  EXPECT_EQ(pp_object1.value.as_id, pp_object2.value.as_id);
+  EXPECT_EQ(pp_object1.get().value.as_id, pp_object2.get().value.as_id);
 
-  // The objects should be able to get us back to the associated NPObject.
-  // This ObjectVar must be released before we do NPObjectToPPVarForTest again
-  // below so it gets freed and we get a new identifier.
+  // The objects should be able to get us back to the associated v8 object.
   {
-    scoped_refptr<NPObjectVar> check_object(NPObjectVar::FromPPVar(pp_object1));
+    scoped_refptr<V8ObjectVar> check_object(
+        V8ObjectVar::FromPPVar(pp_object1.get()));
     ASSERT_TRUE(check_object.get());
-    EXPECT_EQ(instance()->pp_instance(), check_object->pp_instance());
-    EXPECT_EQ(npobject.get(), check_object->np_object());
+    EXPECT_EQ(instance()->pp_instance(), check_object->instance());
+    EXPECT_EQ(v8_object, check_object->GetHandle());
   }
 
   // Remove both of the refs we made above.
-  ppapi::VarTracker* var_tracker = ppapi::PpapiGlobals::Get()->GetVarTracker();
-  var_tracker->ReleaseVar(static_cast<int32_t>(pp_object2.value.as_id));
-  var_tracker->ReleaseVar(static_cast<int32_t>(pp_object1.value.as_id));
+  pp_object1 = ppapi::ScopedPPVar();
+  pp_object2 = ppapi::ScopedPPVar();
 
   // Releasing the resource should free the internal ref, and so making a new
   // one now should generate a new ID.
-  PP_Var pp_object3 = NPObjectToPPVarForTest(instance(), npobject.get());
-  EXPECT_NE(pp_object1.value.as_id, pp_object3.value.as_id);
-  var_tracker->ReleaseVar(static_cast<int32_t>(pp_object3.value.as_id));
+  ppapi::ScopedPPVar pp_object3 = try_catch.FromV8(v8_object);
+  EXPECT_NE(pp_object1.get().value.as_id, pp_object3.get().value.as_id);
 }
 
 }  // namespace content