Replaced BaseNPObject with DefaultNPObject because......

o3d/gpu_plugin/np_utils/np_utils_unittest.cc

 // Copyright (c) 2006-2008 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 "o3d/gpu_plugin/np_utils/base_np_object_mock.h"
+#include "o3d/gpu_plugin/np_utils/np_object_mock.h"
 #include "o3d/gpu_plugin/np_utils/np_browser_stub.h"
 #include "o3d/gpu_plugin/np_utils/np_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::MakeMatcher;
 using testing::Matcher;
 using testing::Pointee;
 using testing::Return;
 using testing::SetArgumentPointee;
 using testing::StrictMock;
 
 namespace o3d {
 namespace gpu_plugin {
 
 class NPUtilsTest : public testing::Test {
  protected:
-  virtual void SetUp() {
-    // Make sure no MockBaseNPObject objects exist before test.
-    ASSERT_EQ(0, MockBaseNPObject::count());
-  }
-
-  virtual void TearDown() {
-    // Make sure no MockBaseNPObject leaked an object.
-    ASSERT_EQ(0, MockBaseNPObject::count());
-  }
-
   StubNPBrowser stub_browser_;
   NPP_t npp_;
   NPVariant variant_;
 };
 
 TEST_F(NPUtilsTest, TestBoolNPVariantToValue) {
   bool v;
 
   BOOLEAN_TO_NPVARIANT(false, variant_);
   EXPECT_TRUE(NPVariantToValue(&v, variant_));
@@ skipping 54 matching lines @@
   STRINGZ_TO_NPVARIANT("hello", variant_);
   EXPECT_TRUE(NPVariantToValue(&v, variant_));
   EXPECT_EQ(std::string("hello"), v);
 
   BOOLEAN_TO_NPVARIANT(false, variant_);
   EXPECT_FALSE(NPVariantToValue(&v, variant_));
 }
 
 TEST_F(NPUtilsTest, TestObjectNPVariantToValue) {
   NPObjectPointer<NPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
   NPObjectPointer<NPObject> v;
 
   OBJECT_TO_NPVARIANT(object.Get(), variant_);
   EXPECT_TRUE(NPVariantToValue(&v, variant_));
   EXPECT_EQ(object, v);
 
   BOOLEAN_TO_NPVARIANT(false, variant_);
   EXPECT_FALSE(NPVariantToValue(&v, variant_));
 }
 
 TEST_F(NPUtilsTest, TestNullNPVariantToValue) {
   NPObjectPointer<NPObject> v;
 
   NULL_TO_NPVARIANT(variant_);
   EXPECT_TRUE(NPVariantToValue(&v, variant_));
   EXPECT_TRUE(NPObjectPointer<NPObject>() == v);
 
   BOOLEAN_TO_NPVARIANT(false, variant_);
   EXPECT_FALSE(NPVariantToValue(&v, variant_));
 }
 
 TEST_F(NPUtilsTest, TestDerivedObjectNPVariantToValue) {
   NPObjectPointer<NPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
-  NPObjectPointer<StrictMock<MockBaseNPObject> > v;
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
+  NPObjectPointer<StrictMock<MockNPObject> > v;
 
   OBJECT_TO_NPVARIANT(object.Get(), variant_);
   EXPECT_TRUE(NPVariantToValue(&v, variant_));
   EXPECT_EQ(object, v);
 }
 
 TEST_F(NPUtilsTest,
     TestDerivedObjectNPVariantToValueFailsIfValueHasDifferentType) {
   NPObjectPointer<NPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
-  NPObjectPointer<MockBaseNPObject> v;
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> v;
 
   OBJECT_TO_NPVARIANT(object.Get(), variant_);
   EXPECT_FALSE(NPVariantToValue(&v, variant_));
 }
 
 TEST_F(NPUtilsTest, TestBoolValueToNPVariant) {
   ValueToNPVariant(true, &variant_);
   EXPECT_TRUE(NPVARIANT_IS_BOOLEAN(variant_));
   EXPECT_TRUE(NPVARIANT_TO_BOOLEAN(variant_));
 
@@ skipping 23 matching lines @@
 TEST_F(NPUtilsTest, TestStringValueToNPVariant) {
   ValueToNPVariant(std::string("hello"), &variant_);
   EXPECT_TRUE(NPVARIANT_IS_STRING(variant_));
   EXPECT_EQ(std::string("hello"),
             std::string(variant_.value.stringValue.UTF8Characters,
                         variant_.value.stringValue.UTF8Length));
 }
 
 TEST_F(NPUtilsTest, TestObjectValueToNPVariant) {
   NPObjectPointer<NPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   ValueToNPVariant(object, &variant_);
   EXPECT_TRUE(NPVARIANT_IS_OBJECT(variant_));
   EXPECT_EQ(object.Get(), NPVARIANT_TO_OBJECT(variant_));
 
   NPBrowser::get()->ReleaseVariantValue(&variant_);
 }
 
 TEST_F(NPUtilsTest, TestNullValueToNPVariant) {
   ValueToNPVariant(NPObjectPointer<NPObject>(), &variant_);
   EXPECT_TRUE(NPVARIANT_IS_NULL(variant_));
 }
 
 TEST_F(NPUtilsTest, CanCopyObjectSmartVariant) {
   NPObjectPointer<NPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
   EXPECT_EQ(1, object->referenceCount);
   {
     SmartNPVariant v1(object);
     EXPECT_EQ(2, object->referenceCount);
     {
       SmartNPVariant v2(v1);
       EXPECT_EQ(3, object->referenceCount);
     }
     EXPECT_EQ(2, object->referenceCount);
   }
@@ skipping 40 matching lines @@
   T value_;
 };
 
 template <typename T>
 Matcher<const NPVariant&> VariantMatches(const T& value) {
   return MakeMatcher(new VariantMatcher<T>(value));
 }
 
 TEST_F(NPUtilsTest, CanDetermineIfObjectHasMethod) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   EXPECT_CALL(*object, HasMethod(name))
     .WillOnce(Return(true));
 
   EXPECT_TRUE(NPHasMethod(NULL, object, "foo"));
 }
 
 TEST_F(NPUtilsTest, CanInvokeVoidMethodWithNativeTypes) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   VOID_TO_NPVARIANT(variant_);
 
   EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int32>(7)), 1, _))
     .WillOnce(DoAll(SetArgumentPointee<3>(variant_),
                     Return(true)));
 
   EXPECT_TRUE(NPInvokeVoid(NULL, object, "foo", 7));
 }
 
 TEST_F(NPUtilsTest, InvokeVoidMethodCanFail) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   VOID_TO_NPVARIANT(variant_);
 
   EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int32>(7)), 1, _))
     .WillOnce(DoAll(SetArgumentPointee<3>(variant_),
                     Return(false)));
 
   EXPECT_FALSE(NPInvokeVoid(NULL, object, "foo", 7));
 }
 
 TEST_F(NPUtilsTest, CanInvokeNonVoidMethodWithNativeTypes) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   DOUBLE_TO_NPVARIANT(1.5, variant_);
 
   EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int32>(7)), 1, _))
     .WillOnce(DoAll(SetArgumentPointee<3>(variant_),
                     Return(true)));
 
   double r;
   EXPECT_TRUE(NPInvoke(NULL, object, "foo", 7, &r));
   EXPECT_EQ(1.5, r);
 }
 
 TEST_F(NPUtilsTest, InvokeNonVoidMethodCanFail) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   DOUBLE_TO_NPVARIANT(1.5, variant_);
 
   EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int32>(7)), 1, _))
     .WillOnce(DoAll(SetArgumentPointee<3>(variant_),
                     Return(false)));
 
   double r;
   EXPECT_FALSE(NPInvoke(NULL, object, "foo", 7, &r));
 }
 
 TEST_F(NPUtilsTest, InvokeNonVoidMethodFailsIfResultIsIncompatible) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   DOUBLE_TO_NPVARIANT(1.5, variant_);
 
   EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int32>(7)), 1, _))
     .WillOnce(DoAll(SetArgumentPointee<3>(variant_),
                     Return(true)));
 
   int r;
   EXPECT_FALSE(NPInvoke(NULL, object, "foo", 7, &r));
 }
 
 TEST_F(NPUtilsTest, CanDetermineIfObjectHasProperty) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   EXPECT_CALL(*object, HasProperty(name))
     .WillOnce(Return(true));
 
   EXPECT_TRUE(NPHasProperty(NULL, object, "foo"));
 }
 
 TEST_F(NPUtilsTest, CanGetPropertyValue) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   DOUBLE_TO_NPVARIANT(1.5, variant_);
 
   EXPECT_CALL(*object, GetProperty(name, _))
     .WillOnce(DoAll(SetArgumentPointee<1>(variant_),
                     Return(true)));
 
   double r;
   EXPECT_TRUE(NPGetProperty(NULL, object, "foo", &r));
 }
 
 TEST_F(NPUtilsTest, NPGetPropertyReportsFailureIfResultTypeIsDifferent) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   DOUBLE_TO_NPVARIANT(1.5, variant_);
 
   EXPECT_CALL(*object, GetProperty(name, _))
     .WillOnce(DoAll(SetArgumentPointee<1>(variant_),
                     Return(true)));
 
   bool r;
   EXPECT_FALSE(NPGetProperty(NULL, object, "foo", &r));
 }
 
 TEST_F(NPUtilsTest, NPGetPropertyReportsFailureFromGetProperty) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   EXPECT_CALL(*object, GetProperty(name, _))
     .WillOnce(Return(false));
 
   double r;
   EXPECT_FALSE(NPGetProperty(NULL, object, "foo", &r));
 }
 
 TEST_F(NPUtilsTest, CanSetPropertyValue) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   EXPECT_CALL(*object, SetProperty(name, Pointee(VariantMatches(1.5))))
     .WillOnce(Return(true));
 
   EXPECT_TRUE(NPSetProperty(NULL, object, "foo", 1.5));
 }
 
 TEST_F(NPUtilsTest, NPSetPropertyReportsFailureFromSetProperty) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   EXPECT_CALL(*object, SetProperty(name, Pointee(VariantMatches(1.5))))
     .WillOnce(Return(false));
 
   EXPECT_FALSE(NPSetProperty(NULL, object, "foo", 1.5));
 }
 
 TEST_F(NPUtilsTest, CanRemovePropertyValue) {
   NPIdentifier name = NPBrowser::get()->GetStringIdentifier("foo");
-  NPObjectPointer<MockBaseNPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+  NPObjectPointer<MockNPObject> object =
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   EXPECT_CALL(*object, RemoveProperty(name))
     .WillOnce(Return(true));
 
   EXPECT_TRUE(NPRemoveProperty(NULL, object, "foo"));
 }
 
 }  // namespace gpu_plugin
 }  // namespace o3d