content/renderer/pepper/host_var_tracker_unittest.cc

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