Track NPObject ownership by the originating plugins' NPP identifier. [4/6] (Chrome)

webkit/renderer/cpp_variant_unittest.cc

 // Copyright (c) 2012 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.
 
 #include <vector>
 
 #include "base/compiler_specific.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebBindings.h"
 #include "webkit/renderer/cpp_variant.h"
 
 using WebKit::WebBindings;
 using webkit_glue::CppVariant;
 
 // Creates a std::string from an NPVariant of string type.  If the NPVariant
 // is not a string, empties the std::string.
@@ skipping 51 matching lines @@
 
   ++g_deallocate_call_count;
   free(npobj);
 }
 
 static NPClass void_class = { NP_CLASS_STRUCT_VERSION,
                               MockNPAllocate,
                               MockNPDeallocate,
                               0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
-NPObject* MakeVoidObject() {
-  g_allocate_call_count = 0;
-  g_deallocate_call_count = 0;
-  return WebBindings::createObject(NULL, &void_class);
-}
+class CppVariantTest : public testing::Test {
+public:
+  CppVariantTest() : npp_(new struct _NPP) {}
+  virtual ~CppVariantTest() {}
 
-TEST(CppVariantTest, NewVariantHasNullType) {
+  virtual void SetUp() OVERRIDE {
+    WebBindings::registerObjectOwner(npp_.get());
+  }
+
+  virtual void TearDown() OVERRIDE {
+    WebBindings::unregisterObjectOwner(npp_.get());
+  }
+
+  struct _NPP* npp() { return npp_.get(); }
+
+  NPObject* MakeVoidObject() {
+    g_allocate_call_count = 0;
+    g_deallocate_call_count = 0;
+    return WebBindings::createObject(npp_.get(), &void_class);
+  }
+
+private:
+  scoped_ptr<struct _NPP> npp_;
+};
+
+TEST_F(CppVariantTest, NewVariantHasNullType) {
   CppVariant value;
   EXPECT_EQ(NPVariantType_Null, value.type);
 }
 
-TEST(CppVariantTest, SetNullSetsType) {
+TEST_F(CppVariantTest, SetNullSetsType) {
   CppVariant value;
   value.Set(17);
   value.SetNull();
   EXPECT_EQ(NPVariantType_Null, value.type);
 }
 
-TEST(CppVariantTest, CopyConstructorDoesDeepCopy) {
+TEST_F(CppVariantTest, CopyConstructorDoesDeepCopy) {
   CppVariant source;
   source.Set("test string");
   CppVariant dest = source;
   EXPECT_EQ(NPVariantType_String, dest.type);
   EXPECT_EQ(NPVariantType_String, source.type);
 
   // Ensure that the string was copied, not just the pointer.
   EXPECT_NE(source.value.stringValue.UTF8Characters,
     dest.value.stringValue.UTF8Characters);
 
   CheckString(source, dest);
 }
 
-TEST(CppVariantTest, CopyConstructorIncrementsRefCount) {
+TEST_F(CppVariantTest, CopyConstructorIncrementsRefCount) {
   CppVariant source;
   NPObject *object = MakeVoidObject();
   source.Set(object);
   // 2 references so far.
   EXPECT_EQ(2U, source.value.objectValue->referenceCount);
 
   CppVariant dest = source;
   EXPECT_EQ(3U, dest.value.objectValue->referenceCount);
   EXPECT_EQ(1, g_allocate_call_count);
   WebBindings::releaseObject(object);
   source.SetNull();
   CheckObject(dest);
 }
 
-TEST(CppVariantTest, AssignmentDoesDeepCopy) {
+TEST_F(CppVariantTest, AssignmentDoesDeepCopy) {
   CppVariant source;
   source.Set("test string");
   CppVariant dest;
   dest = source;
   EXPECT_EQ(NPVariantType_String, dest.type);
   EXPECT_EQ(NPVariantType_String, source.type);
 
   // Ensure that the string was copied, not just the pointer.
   EXPECT_NE(source.value.stringValue.UTF8Characters,
     dest.value.stringValue.UTF8Characters);
 
   CheckString(source, dest);
 }
 
-TEST(CppVariantTest, AssignmentIncrementsRefCount) {
+TEST_F(CppVariantTest, AssignmentIncrementsRefCount) {
   CppVariant source;
   NPObject *object = MakeVoidObject();
   source.Set(object);
   // 2 references so far.
   EXPECT_EQ(2U, source.value.objectValue->referenceCount);
 
   CppVariant dest;
   dest = source;
   EXPECT_EQ(3U, dest.value.objectValue->referenceCount);
   EXPECT_EQ(1, g_allocate_call_count);
 
   WebBindings::releaseObject(object);
   source.SetNull();
   CheckObject(dest);
 }
 
-TEST(CppVariantTest, DestroyingCopyDoesNotCorruptSource) {
+TEST_F(CppVariantTest, DestroyingCopyDoesNotCorruptSource) {
   CppVariant source;
   source.Set("test string");
   std::string before;
   MakeStdString(source, &before);
   {
     CppVariant dest = source;
   }
   CheckString(before, source);
 
   NPObject *object = MakeVoidObject();
   source.Set(object);
   {
     CppVariant dest2 = source;
   }
   WebBindings::releaseObject(object);
   CheckObject(source);
 }
 
-TEST(CppVariantTest, CopiesTypeAndValueToNPVariant) {
+TEST_F(CppVariantTest, CopiesTypeAndValueToNPVariant) {
   NPVariant np;
   CppVariant cpp;
 
   cpp.Set(true);
   cpp.CopyToNPVariant(&np);
   EXPECT_EQ(cpp.type, np.type);
   EXPECT_EQ(cpp.value.boolValue, np.value.boolValue);
   WebBindings::releaseVariantValue(&np);
 
   cpp.Set(17);
@@ skipping 20 matching lines @@
 
   NPObject *object = MakeVoidObject();
   cpp.Set(object);
   cpp.CopyToNPVariant(&np);
   WebBindings::releaseObject(object);
   cpp.SetNull();
   CheckObject(np);
   WebBindings::releaseVariantValue(&np);
 }
 
-TEST(CppVariantTest, SetsTypeAndValueFromNPVariant) {
+TEST_F(CppVariantTest, SetsTypeAndValueFromNPVariant) {
   NPVariant np;
   CppVariant cpp;
 
   VOID_TO_NPVARIANT(np);
   cpp.Set(np);
   EXPECT_EQ(np.type, cpp.type);
   WebBindings::releaseVariantValue(&np);
 
   NULL_TO_NPVARIANT(np);
   cpp.Set(np);
@@ skipping 37 matching lines @@
   WebBindings::releaseVariantValue(&np);
 
   NPObject *obj = MakeVoidObject();
   OBJECT_TO_NPVARIANT(obj, np);  // Doesn't make a copy.
   cpp.Set(np);
   // Use this or WebBindings::releaseObject but NOT both.
   WebBindings::releaseVariantValue(&np);
   CheckObject(cpp);
 }
 
-TEST(CppVariantTest, SetsSimpleTypesAndValues) {
+TEST_F(CppVariantTest, SetsSimpleTypesAndValues) {
   CppVariant cpp;
   cpp.Set(true);
   EXPECT_EQ(NPVariantType_Bool, cpp.type);
   EXPECT_TRUE(cpp.value.boolValue);
 
   cpp.Set(5);
   EXPECT_EQ(NPVariantType_Int32, cpp.type);
   EXPECT_EQ(5, cpp.value.intValue);
 
   cpp.Set(1.234);
@@ skipping 25 matching lines @@
   cpp.Set(np_intl_str);
   expected = std::string("\xce\xb1\xe4\xb8\x80\xf0\x90\x90\x84");
   CheckString(expected, cpp);
 
   NPObject* obj = MakeVoidObject();
   cpp.Set(obj);
   WebBindings::releaseObject(obj);
   CheckObject(cpp);
 }
 
-TEST(CppVariantTest, FreeDataSetsToVoid) {
+TEST_F(CppVariantTest, FreeDataSetsToVoid) {
   CppVariant cpp;
   EXPECT_EQ(NPVariantType_Null, cpp.type);
   cpp.Set(12);
   EXPECT_EQ(NPVariantType_Int32, cpp.type);
   cpp.FreeData();
   EXPECT_EQ(NPVariantType_Void, cpp.type);
 }
 
-TEST(CppVariantTest, FreeDataReleasesObject) {
+TEST_F(CppVariantTest, FreeDataReleasesObject) {
   CppVariant cpp;
   NPObject* object = MakeVoidObject();
   cpp.Set(object);
   EXPECT_EQ(2U, object->referenceCount);
   cpp.FreeData();
   EXPECT_EQ(1U, object->referenceCount);
   EXPECT_EQ(0, g_deallocate_call_count);
 
   cpp.Set(object);
   WebBindings::releaseObject(object);
   EXPECT_EQ(0, g_deallocate_call_count);
   cpp.FreeData();
   EXPECT_EQ(1, g_deallocate_call_count);
 }
 
-TEST(CppVariantTest, IsTypeFunctionsWork) {
+TEST_F(CppVariantTest, IsTypeFunctionsWork) {
   CppVariant cpp;
   // These should not happen in practice, since voids are not supported
   // This test must be first since it just clobbers internal data without
   // releasing.
   VOID_TO_NPVARIANT(cpp);
   EXPECT_FALSE(cpp.isBool());
   EXPECT_FALSE(cpp.isInt32());
   EXPECT_FALSE(cpp.isDouble());
   EXPECT_FALSE(cpp.isNumber());
   EXPECT_FALSE(cpp.isString());
@@ skipping 89 matching lines @@
     const char* s = "string";
     size_t length = strlen(s);
     char* mem = static_cast<char*>(malloc(length + 1));
     base::strlcpy(mem, s, length + 1);
     STRINGZ_TO_NPVARIANT(mem, *result);
   }
 
   return true;
 }
 
-TEST(CppVariantTest, ToVector) {
+TEST_F(CppVariantTest, ToVector) {
   NPClass array_like_class = {
       NP_CLASS_STRUCT_VERSION,
       0, // NPAllocateFunctionPtr allocate;
       0, // NPDeallocateFunctionPtr deallocate;
       0, // NPInvalidateFunctionPtr invalidate;
       0, // NPHasMethodFunctionPtr hasMethod;
       0, // NPInvokeFunctionPtr invoke;
       0, // NPInvokeDefaultFunctionPtr invokeDefault;
       MockNPHasPropertyFunction, // NPHasPropertyFunctionPtr hasProperty;
       MockNPGetPropertyFunction, // NPGetPropertyFunctionPtr getProperty;
       0, // NPSetPropertyFunctionPtr setProperty;
       0, // NPRemovePropertyFunctionPtr removeProperty;
       0, // NPEnumerationFunctionPtr enumerate;
       0 // NPConstructFunctionPtr construct;
       };
 
-  NPObject* obj = WebBindings::createObject(NULL, &array_like_class);
+  NPObject* obj = WebBindings::createObject(npp(), &array_like_class);
 
   CppVariant cpp;
   cpp.Set(obj);
 
   std::vector<CppVariant> cpp_vector = cpp.ToVector();
   EXPECT_EQ(4u, cpp_vector.size());
 
   EXPECT_TRUE(cpp_vector[0].isDouble());
   EXPECT_EQ(0, cpp_vector[0].ToDouble());
 
   EXPECT_TRUE(cpp_vector[1].isBool());
   EXPECT_EQ(true, cpp_vector[1].ToBoolean());
 
   EXPECT_TRUE(cpp_vector[2].isNull());
 
   EXPECT_TRUE(cpp_vector[3].isString());
   CheckString("string", cpp_vector[3]);
 
   WebBindings::releaseObject(obj);
 }