ppapi/shared_impl/var_tracker_unittest.cc

   1 // Copyright (c) 2011 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 "testing/gtest/include/gtest/gtest.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "ppapi/shared_impl/var.h"
   9 #include "ppapi/shared_impl/var_tracker.h"
  10 #include "ppapi/shared_impl/test_globals.h"
  11
  12 namespace ppapi {
  13
  14 namespace {
  15
  16 int mock_var_alive_count = 0;
  17
  18 class MockStringVar : public StringVar {
  19  public:
  20   MockStringVar(const std::string& str) : StringVar(str) {
  21     mock_var_alive_count++;
  22   }
  23   virtual ~MockStringVar() {
  24     mock_var_alive_count--;
  25   }
  26   bool HasValidVarID() {
  27     return GetExistingVarID() != 0;
  28   }
  29 };
  30
  31 class MockObjectVar : public Var {
  32  public:
  33   MockObjectVar() : Var() {
  34     mock_var_alive_count++;
  35   }
  36   virtual ~MockObjectVar() {
  37     mock_var_alive_count--;
  38   }
  39   virtual PP_VarType GetType() const OVERRIDE {
  40     return PP_VARTYPE_OBJECT;
  41   }
  42   bool HasValidVarID() {
  43     return GetExistingVarID() != 0;
  44   }
  45 };
  46
  47 }  // namespace
  48
  49 class VarTrackerTest : public testing::Test {
  50  public:
  51   VarTrackerTest() {}
  52
  53   // Test implementation.
  54   virtual void SetUp() OVERRIDE {
  55     ASSERT_EQ(0, mock_var_alive_count);
  56   }
  57   virtual void TearDown() OVERRIDE {
  58   }
  59
  60   VarTracker& var_tracker() { return *globals_.GetVarTracker(); }
  61
  62  private:
  63   TestGlobals globals_;
  64 };
  65
  66 // Test that ResetVarID is called when the last PP_Var ref was deleted but the
  67 // object lives on.
  68 TEST_F(VarTrackerTest, LastResourceRef) {
  69   scoped_refptr<MockStringVar> var(new MockStringVar(std::string("xyz")));
  70   PP_Var pp_var = var->GetPPVar();
  71   EXPECT_TRUE(var->HasValidVarID());
  72   EXPECT_TRUE(var_tracker().GetVar(var->GetExistingVarID()));
  73
  74   // Releasing it should keep the object (because we have a ref) but reset the
  75   // var_id_.
  76   EXPECT_TRUE(var_tracker().ReleaseVar(pp_var));
  77   EXPECT_FALSE(var->HasValidVarID());
  78   EXPECT_EQ(1, mock_var_alive_count);
  79
  80   var = NULL;
  81   EXPECT_EQ(0, mock_var_alive_count);
  82 }
  83
  84 TEST_F(VarTrackerTest, GetPluginRefAgain) {
  85   scoped_refptr<MockStringVar> var(new MockStringVar(std::string("xyz")));
  86   PP_Var pp_var = var->GetPPVar();
  87   EXPECT_TRUE(var_tracker().ReleaseVar(pp_var));
  88   EXPECT_FALSE(var->HasValidVarID());
  89   EXPECT_EQ(1, mock_var_alive_count);
  90
  91   // Obtaining PP_Var ref again, and add ref from VarTracker.
  92   pp_var = var->GetPPVar();
  93   EXPECT_TRUE(var->HasValidVarID());
  94   EXPECT_TRUE(var_tracker().GetVar(var->GetExistingVarID()));
  95   scoped_refptr<MockStringVar> another_var =
  96       static_cast<MockStringVar*>(var_tracker().GetVar(pp_var));
  97   EXPECT_EQ(1, mock_var_alive_count);
  98
  99   // Releasing it again.
 100   EXPECT_TRUE(var_tracker().ReleaseVar(pp_var));
 101   EXPECT_FALSE(var->HasValidVarID());
 102   EXPECT_EQ(1, mock_var_alive_count);
 103
 104   var = NULL;
 105   EXPECT_FALSE(var_tracker().GetVar(pp_var));
 106   EXPECT_EQ(1, mock_var_alive_count);
 107   another_var = NULL;
 108   EXPECT_FALSE(var_tracker().GetVar(pp_var));
 109   EXPECT_EQ(0, mock_var_alive_count);
 110 }
 111
 112 // Tests when the plugin is holding a ref to a PP_Var when the instance is
 113 // owned only by VarTracker.
 114 TEST_F(VarTrackerTest, PluginRefWithoutVarRef) {
 115   // Make a PP_Var with one ref held by the plugin, and release the reference.
 116   scoped_refptr<MockStringVar> var(new MockStringVar(std::string("zzz")));
 117   PP_Var pp_var = var->GetPPVar();
 118   EXPECT_EQ(1, mock_var_alive_count);
 119   var = NULL;
 120   EXPECT_EQ(1, mock_var_alive_count);
 121
 122   // The var is owned only by VarTracker. PP_Var must be still valid.
 123   EXPECT_TRUE(var_tracker().GetVar(pp_var));
 124
 125   var_tracker().ReleaseVar(pp_var);
 126   EXPECT_EQ(0, mock_var_alive_count);
 127   EXPECT_FALSE(var_tracker().GetVar(pp_var));
 128 }
 129
 130 // Tests on Var having type of PP_VARTYPE_OBJECT.
 131 TEST_F(VarTrackerTest, ObjectRef) {
 132   scoped_refptr<MockObjectVar> var(new MockObjectVar());
 133   PP_Var pp_var = var->GetPPVar();
 134   EXPECT_TRUE(var_tracker().ReleaseVar(pp_var));
 135   EXPECT_FALSE(var->HasValidVarID());
 136   EXPECT_EQ(1, mock_var_alive_count);
 137
 138   // Obtaining PP_Var ref again, and add ref from VarTracker.
 139   pp_var = var->GetPPVar();
 140   EXPECT_TRUE(var->HasValidVarID());
 141   EXPECT_TRUE(var_tracker().GetVar(var->GetExistingVarID()));
 142   scoped_refptr<MockObjectVar> another_var =
 143       static_cast<MockObjectVar*>(var_tracker().GetVar(pp_var));
 144   EXPECT_EQ(1, mock_var_alive_count);
 145
 146   // Releasing all references, then only VarTracker own the instance.
 147   var = NULL;
 148   EXPECT_TRUE(var_tracker().GetVar(pp_var));
 149   EXPECT_EQ(1, mock_var_alive_count);
 150   another_var = NULL;
 151   EXPECT_TRUE(var_tracker().GetVar(pp_var));
 152   EXPECT_EQ(1, mock_var_alive_count);
 153
 154   // Releasing plugin reference.
 155   EXPECT_TRUE(var_tracker().ReleaseVar(pp_var));
 156   EXPECT_EQ(0, mock_var_alive_count);
 157 }
 158
 159 }  // namespace ppapi