1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "base/basictypes.h" 6 #include "base/memory/scoped_ptr.h" 7 #include "content/renderer/pepper/host_globals.h" 8 #include "content/renderer/pepper/host_var_tracker.h" 9 #include "content/renderer/pepper/mock_resource.h" 10 #include "content/renderer/pepper/pepper_plugin_instance_impl.h" 11 #include "content/renderer/pepper/pepper_try_catch.h" 12 #include "content/renderer/pepper/v8object_var.h" 13 #include "content/test/ppapi_unittest.h" 14 #include "gin/handle.h" 15 #include "gin/wrappable.h" 16 #include "ppapi/c/pp_var.h" 17 #include "ppapi/c/ppp_instance.h" 18 #include "third_party/WebKit/public/web/WebBindings.h" 19 20 using ppapi::V8ObjectVar; 21 22 namespace content { 23 24 namespace { 25 26 int g_v8objects_alive = 0; 27 28 class MyObject : public gin::Wrappable<MyObject> { 29 public: 30 static gin::WrapperInfo kWrapperInfo; 31 32 static v8::Handle<v8::Value> Create(v8::Isolate* isolate) { 33 return gin::CreateHandle(isolate, new MyObject()).ToV8(); 34 } 35 36 private: 37 MyObject() { ++g_v8objects_alive; } 38 virtual ~MyObject() { --g_v8objects_alive; } 39 40 DISALLOW_COPY_AND_ASSIGN(MyObject); 41 }; 42 43 gin::WrapperInfo MyObject::kWrapperInfo = {gin::kEmbedderNativeGin}; 44 45 class PepperTryCatchForTest : public PepperTryCatch { 46 public: 47 explicit PepperTryCatchForTest(PepperPluginInstanceImpl* instance) 48 : PepperTryCatch(instance, V8VarConverter::kAllowObjectVars), 49 handle_scope_(instance->GetIsolate()), 50 context_scope_(v8::Context::New(instance->GetIsolate())) {} 51 52 virtual void SetException(const char* message) OVERRIDE { NOTREACHED(); } 53 virtual bool HasException() OVERRIDE { return false; } 54 virtual v8::Handle<v8::Context> GetContext() OVERRIDE { 55 return instance_->GetIsolate()->GetCurrentContext(); 56 } 57 58 private: 59 v8::HandleScope handle_scope_; 60 v8::Context::Scope context_scope_; 61 62 DISALLOW_COPY_AND_ASSIGN(PepperTryCatchForTest); 63 }; 64 65 } // namespace 66 67 class HostVarTrackerTest : public PpapiUnittest { 68 public: 69 HostVarTrackerTest() {} 70 71 virtual void TearDown() OVERRIDE { 72 v8::Isolate::GetCurrent()->RequestGarbageCollectionForTesting( 73 v8::Isolate::kFullGarbageCollection); 74 EXPECT_EQ(0, g_v8objects_alive); 75 PpapiUnittest::TearDown(); 76 } 77 78 HostVarTracker& tracker() { return *HostGlobals::Get()->host_var_tracker(); } 79 }; 80 81 TEST_F(HostVarTrackerTest, DeleteObjectVarWithInstance) { 82 v8::Isolate* test_isolate = v8::Isolate::GetCurrent(); 83 84 // Make a second instance (the test harness already creates & manages one). 85 scoped_refptr<PepperPluginInstanceImpl> instance2( 86 PepperPluginInstanceImpl::Create(NULL, module(), NULL, GURL())); 87 PP_Instance pp_instance2 = instance2->pp_instance(); 88 89 { 90 PepperTryCatchForTest try_catch(instance2.get()); 91 // Make an object var. 92 ppapi::ScopedPPVar var = try_catch.FromV8(MyObject::Create(test_isolate)); 93 EXPECT_EQ(1, g_v8objects_alive); 94 EXPECT_EQ(1, tracker().GetLiveV8ObjectVarsForTest(pp_instance2)); 95 // Purposely leak the var. 96 var.Release(); 97 } 98 99 // Free the instance, this should release the ObjectVar. 100 instance2 = NULL; 101 EXPECT_EQ(0, tracker().GetLiveV8ObjectVarsForTest(pp_instance2)); 102 } 103 104 // Make sure that using the same v8 object should give the same PP_Var 105 // each time. 106 TEST_F(HostVarTrackerTest, ReuseVar) { 107 PepperTryCatchForTest try_catch(instance()); 108 109 v8::Handle<v8::Value> v8_object = MyObject::Create(v8::Isolate::GetCurrent()); 110 ppapi::ScopedPPVar pp_object1 = try_catch.FromV8(v8_object); 111 ppapi::ScopedPPVar pp_object2 = try_catch.FromV8(v8_object); 112 113 // The two results should be the same. 114 EXPECT_EQ(pp_object1.get().value.as_id, pp_object2.get().value.as_id); 115 116 // The objects should be able to get us back to the associated v8 object. 117 { 118 scoped_refptr<V8ObjectVar> check_object( 119 V8ObjectVar::FromPPVar(pp_object1.get())); 120 ASSERT_TRUE(check_object.get()); 121 EXPECT_EQ(instance(), check_object->instance()); 122 EXPECT_EQ(v8_object, check_object->GetHandle()); 123 } 124 125 // Remove both of the refs we made above. 126 pp_object1 = ppapi::ScopedPPVar(); 127 pp_object2 = ppapi::ScopedPPVar(); 128 129 // Releasing the resource should free the internal ref, and so making a new 130 // one now should generate a new ID. 131 ppapi::ScopedPPVar pp_object3 = try_catch.FromV8(v8_object); 132 EXPECT_NE(pp_object1.get().value.as_id, pp_object3.get().value.as_id); 133 } 134 135 } // namespace content 136