Added GPU plugin object, an NPObject to which a plugin instance's NPP calls are forwarded.

TEST=none
BUG=none

Review URL: http://codereview.chromium.org/173386

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@24364 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 414 insertions, 342 deletions

diff --git a/o3d/gpu_plugin/np_utils/dispatched_np_object_unittest.cc b/o3d/gpu_plugin/np_utils/dispatched_np_object_unittest.cc
index 791491e..b9edd67 100644
--- a/o3d/gpu_plugin/np_utils/dispatched_np_object_unittest.cc
+++ b/o3d/gpu_plugin/np_utils/dispatched_np_object_unittest.cc
@@ -68,6 +68,8 @@ class MockDispatchedNPObject : public DispatchedNPObject {
 class NPObjectDispatcherTest : public testing::Test {
  protected:
   virtual void SetUp() {
+    InitializeNPNTestStub();
+    
     object_ = new StrictMock<MockDispatchedNPObject>;
 
     for (int i = 0; i != arraysize(args_); ++i) {
@@ -78,6 +80,7 @@ class NPObjectDispatcherTest : public testing::Test {
 
   virtual void TearDown() {
     delete object_;
+    ShutdownNPNTestStub();
   }
 
   NPVariant args_[3];
@@ -325,7 +328,7 @@ TEST_F(NPObjectDispatcherTest, CanInvokeStringReturn) {
             std::string(str.UTF8Characters, str.UTF8Length));
 
   // Callee is responsible for releasing string.
-  NPN_ReleaseVariantValue(&result_);
+  gpu_plugin::NPN_ReleaseVariantValue(&result_);
 }
 
 TEST_F(NPObjectDispatcherTest, CanInvokeObjectReturnWithObject) {
diff --git a/o3d/gpu_plugin/np_utils/np_object_pointer.h b/o3d/gpu_plugin/np_utils/np_object_pointer.h
index 6d8d2e0..045bc57 100644
--- a/o3d/gpu_plugin/np_utils/np_object_pointer.h
+++ b/o3d/gpu_plugin/np_utils/np_object_pointer.h
@@ -5,6 +5,7 @@
 #ifndef O3D_GPU_PLUGIN_NP_UTILS_NP_OBJECT_POINTER_H_
 #define O3D_GPU_PLUGIN_NP_UTILS_NP_OBJECT_POINTER_H_
 
+#include "o3d/gpu_plugin/np_utils/npn_funcs.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
@@ -19,29 +20,29 @@ class NPObjectPointer {
 
   NPObjectPointer(const NPObjectPointer& rhs) : object_(rhs.object_) {
     if (object_) {
-      NPN_RetainObject(object_);
+      gpu_plugin::NPN_RetainObject(object_);
     }
   }
 
   explicit NPObjectPointer(NPObjectType* p) : object_(p) {
     if (object_) {
-      NPN_RetainObject(object_);
+      gpu_plugin::NPN_RetainObject(object_);
     }
   }
 
   ~NPObjectPointer() {
     if (object_) {
-      NPN_ReleaseObject(object_);
+      gpu_plugin::NPN_ReleaseObject(object_);
     }
   }
 
   NPObjectPointer& operator=(const NPObjectPointer& rhs) {
     if (object_) {
-      NPN_ReleaseObject(object_);
+      gpu_plugin::NPN_ReleaseObject(object_);
     }
     object_ = rhs.object_;
     if (object_) {
-      NPN_RetainObject(object_);
+      gpu_plugin::NPN_RetainObject(object_);
     }
     return *this;
   }
@@ -51,7 +52,7 @@ class NPObjectPointer {
   static NPObjectPointer FromReturned(NPObjectType* p) {
     NPObjectPointer pointer(p);
     if (p) {
-      NPN_ReleaseObject(p);
+      gpu_plugin::NPN_ReleaseObject(p);
     }
     return pointer;
   }
diff --git a/o3d/gpu_plugin/np_utils/np_object_pointer_unittest.cc b/o3d/gpu_plugin/np_utils/np_object_pointer_unittest.cc
index 3e96bd3..7daf218 100644
--- a/o3d/gpu_plugin/np_utils/np_object_pointer_unittest.cc
+++ b/o3d/gpu_plugin/np_utils/np_object_pointer_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "o3d/gpu_plugin/np_utils/base_np_object_mock.h"
 #include "o3d/gpu_plugin/np_utils/np_object_pointer.h"
+#include "o3d/gpu_plugin/np_utils/npn_test_stub.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -16,6 +17,8 @@ namespace gpu_plugin {
 class NPObjectPointerTest : public testing::Test {
  protected:
   virtual void SetUp() {
+    InitializeNPNTestStub();
+
     np_class_ = const_cast<NPClass*>(
         BaseNPObject::GetNPClass<StrictMock<MockBaseNPObject> >());
 
@@ -23,14 +26,16 @@ class NPObjectPointerTest : public testing::Test {
     ASSERT_EQ(0, MockBaseNPObject::count());
 
     raw_pointer_ = static_cast<MockBaseNPObject*>(
-      NPN_CreateObject(NULL, np_class_));
+      gpu_plugin::NPN_CreateObject(NULL, np_class_));
   }
 
   virtual void TearDown() {
-    NPN_ReleaseObject(raw_pointer_);
+    gpu_plugin::NPN_ReleaseObject(raw_pointer_);
 
     // Make sure no MockBaseNPObject leaked an object.
     ASSERT_EQ(0, MockBaseNPObject::count());
+
+    ShutdownNPNTestStub();
   }
 
   NPClass* np_class_;
@@ -105,7 +110,7 @@ TEST_F(NPObjectPointerTest, ArrowOperatorCanBeUsedToAccessNPObjectMembers) {
 }
 
 TEST_F(NPObjectPointerTest, PointerCanBeConstructedFromReturnedNPObject) {
-  NPN_RetainObject(raw_pointer_);
+  gpu_plugin::NPN_RetainObject(raw_pointer_);
   EXPECT_EQ(2, raw_pointer_->referenceCount);
   {
     NPObjectPointer<MockBaseNPObject> p(
diff --git a/o3d/gpu_plugin/np_utils/np_variant_utils.cc b/o3d/gpu_plugin/np_utils/np_variant_utils.cc
index c8ec811..3a7332e 100644
--- a/o3d/gpu_plugin/np_utils/np_variant_utils.cc
+++ b/o3d/gpu_plugin/np_utils/np_variant_utils.cc
@@ -97,7 +97,7 @@ void ValueToNPVariant(const std::string& value, NPVariant* variant) {
 
 void ValueToNPVariant(NPObject* value, NPVariant* variant) {
   if (value) {
-    NPN_RetainObject(value);
+    gpu_plugin::NPN_RetainObject(value);
     OBJECT_TO_NPVARIANT(value, *variant);
   } else {
     NULL_TO_NPVARIANT(*variant);
diff --git a/o3d/gpu_plugin/np_utils/np_variant_utils.h b/o3d/gpu_plugin/np_utils/np_variant_utils.h
index 4272ffb..f0f1c6a 100644
--- a/o3d/gpu_plugin/np_utils/np_variant_utils.h
+++ b/o3d/gpu_plugin/np_utils/np_variant_utils.h
@@ -7,6 +7,7 @@
 
 #include <string>
 
+#include "o3d/gpu_plugin/np_utils/npn_funcs.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
@@ -51,7 +52,7 @@ class SmartNPVariant {
   }
 
   void Release() {
-    NPN_ReleaseVariantValue(&variant_);
+    gpu_plugin::NPN_ReleaseVariantValue(&variant_);
     VOID_TO_NPVARIANT(variant_);
   }
 
@@ -73,8 +74,8 @@ class SmartNPVariant {
 
 inline bool NPInvokeVoid(NPP npp, NPObject* object, NPIdentifier name) {
   SmartNPVariant result;
-  return NPN_Invoke(npp, object, name, NULL, 0,
-                    &result.GetVariant());
+  return gpu_plugin::NPN_Invoke(npp, object, name, NULL, 0,
+                                &result.GetVariant());
 }
 
 template<typename R>
@@ -94,8 +95,8 @@ bool NPInvokeVoid(NPP npp, NPObject* object, NPIdentifier name,
   SmartNPVariant args[1];
   args[0].SetValue(p0);
   SmartNPVariant result;
-  return NPN_Invoke(npp, object, name, &args[0].GetVariant(), 1,
-                    &result.GetVariant());
+  return gpu_plugin::NPN_Invoke(npp, object, name, &args[0].GetVariant(), 1,
+                                &result.GetVariant());
 }
 
 template<typename R, typename P0>
@@ -104,8 +105,8 @@ bool NPInvoke(NPP npp, NPObject* object, NPIdentifier name,
   SmartNPVariant args[1];
   args[0].SetValue(p0);
   SmartNPVariant result;
-  if (NPN_Invoke(npp, object, name, &args[0].GetVariant(), 1,
-                 &result.GetVariant())) {
+  if (gpu_plugin::NPN_Invoke(npp, object, name, &args[0].GetVariant(), 1,
+                             &result.GetVariant())) {
     return result.GetValue(r);
   }
   return false;
@@ -118,8 +119,8 @@ bool NPInvokeVoid(NPP npp, NPObject* object, NPIdentifier name,
   args[0].SetValue(p0);
   args[1].SetValue(p1);
   SmartNPVariant result;
-  return NPN_Invoke(npp, object, name, &args[0].GetVariant(), 2,
-                    &result.GetVariant());
+  return gpu_plugin::NPN_Invoke(npp, object, name, &args[0].GetVariant(), 2,
+                                &result.GetVariant());
 }
 
 template<typename R, typename P0, typename P1>
@@ -129,8 +130,8 @@ bool NPInvoke(NPP npp, NPObject* object, NPIdentifier name,
   args[0].SetValue(p0);
   args[1].SetValue(p1);
   SmartNPVariant result;
-  if (NPN_Invoke(npp, object, name, &args[0].GetVariant(), 2,
-                 &result.GetVariant())) {
+  if (gpu_plugin::NPN_Invoke(npp, object, name, &args[0].GetVariant(), 2,
+                             &result.GetVariant())) {
     return result.GetValue(r);
   }
   return false;
diff --git a/o3d/gpu_plugin/np_utils/np_variant_utils_unittest.cc b/o3d/gpu_plugin/np_utils/np_variant_utils_unittest.cc
index fdf40ce..4e47d22 100644
--- a/o3d/gpu_plugin/np_utils/np_variant_utils_unittest.cc
+++ b/o3d/gpu_plugin/np_utils/np_variant_utils_unittest.cc
@@ -1,299 +1,304 @@
-// 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_variant_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 NPVariantUtilsTest : public testing::Test {

- protected:

-  virtual void SetUp() {

-    np_class_ = const_cast<NPClass*>(

-        BaseNPObject::GetNPClass<StrictMock<MockBaseNPObject> >());

-

-    // 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());

-  }

-

-  NPP_t npp_;

-  NPClass* np_class_;

-  NPVariant variant_;

-};

-

-TEST_F(NPVariantUtilsTest, TestBoolNPVariantToValue) {

-  bool v;

-

-  BOOLEAN_TO_NPVARIANT(false, variant_);

-  EXPECT_TRUE(NPVariantToValue(&v, variant_));

-  EXPECT_FALSE(v);

-

-  BOOLEAN_TO_NPVARIANT(true, variant_);

-  EXPECT_TRUE(NPVariantToValue(&v, variant_));

-  EXPECT_TRUE(v);

-

-  INT32_TO_NPVARIANT(7, variant_);

-  EXPECT_FALSE(NPVariantToValue(&v, variant_));

-}

-

-TEST_F(NPVariantUtilsTest, TestIntNPVariantToValue) {

-  INT32_TO_NPVARIANT(7, variant_);

-

-  int v1;

-  EXPECT_TRUE(NPVariantToValue(&v1, variant_));

-  EXPECT_EQ(7, v1);

-

-  float v2;

-  EXPECT_TRUE(NPVariantToValue(&v2, variant_));

-  EXPECT_EQ(7.0f, v2);

-

-  double v3;

-  EXPECT_TRUE(NPVariantToValue(&v3, variant_));

-  EXPECT_EQ(7.0, v3);

-

-  BOOLEAN_TO_NPVARIANT(false, variant_);

-  EXPECT_FALSE(NPVariantToValue(&v1, variant_));

-}

-

-TEST_F(NPVariantUtilsTest, TestFloatNPVariantToValue) {

-  float v;

-

-  DOUBLE_TO_NPVARIANT(7.0, variant_);

-  EXPECT_TRUE(NPVariantToValue(&v, variant_));

-  EXPECT_EQ(7.0f, v);

-

-  BOOLEAN_TO_NPVARIANT(false, variant_);

-  EXPECT_FALSE(NPVariantToValue(&v, variant_));

-}

-

-TEST_F(NPVariantUtilsTest, TestDoubleNPVariantToValue) {

-  double v;

-

-  DOUBLE_TO_NPVARIANT(7.0, variant_);

-  EXPECT_TRUE(NPVariantToValue(&v, variant_));

-  EXPECT_EQ(7.0, v);

-

-  BOOLEAN_TO_NPVARIANT(false, variant_);

-  EXPECT_FALSE(NPVariantToValue(&v, variant_));

-}

-

-TEST_F(NPVariantUtilsTest, TestStringNPVariantToValue) {

-  std::string v;

-

-  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(NPVariantUtilsTest, TestObjectNPVariantToValue) {

-  NPObject* object = NPN_CreateObject(NULL, np_class_);

-  NPObject* v;

-

-  OBJECT_TO_NPVARIANT(object, variant_);

-  EXPECT_TRUE(NPVariantToValue(&v, variant_));

-  EXPECT_EQ(object, v);

-

-  BOOLEAN_TO_NPVARIANT(false, variant_);

-  EXPECT_FALSE(NPVariantToValue(&v, variant_));

-

-  NPN_ReleaseObject(object);

-}

-

-TEST_F(NPVariantUtilsTest, TestNullNPVariantToValue) {

-  NPObject* v;

-

-  NULL_TO_NPVARIANT(variant_);

-  EXPECT_TRUE(NPVariantToValue(&v, variant_));

-  EXPECT_TRUE(NULL == v);

-

-  BOOLEAN_TO_NPVARIANT(false, variant_);

-  EXPECT_FALSE(NPVariantToValue(&v, variant_));

-}

-

-TEST_F(NPVariantUtilsTest, TestBoolValueToNPVariant) {

-  ValueToNPVariant(true, &variant_);

-  EXPECT_TRUE(NPVARIANT_IS_BOOLEAN(variant_));

-  EXPECT_TRUE(NPVARIANT_TO_BOOLEAN(variant_));

-

-  ValueToNPVariant(false, &variant_);

-  EXPECT_TRUE(NPVARIANT_IS_BOOLEAN(variant_));

-  EXPECT_FALSE(NPVARIANT_TO_BOOLEAN(variant_));

-}

-

-TEST_F(NPVariantUtilsTest, TestIntValueToNPVariant) {

-  ValueToNPVariant(7, &variant_);

-  EXPECT_TRUE(NPVARIANT_IS_INT32(variant_));

-  EXPECT_EQ(7, NPVARIANT_TO_INT32(variant_));

-}

-

-TEST_F(NPVariantUtilsTest, TestFloatValueToNPVariant) {

-  ValueToNPVariant(7.0f, &variant_);

-  EXPECT_TRUE(NPVARIANT_IS_DOUBLE(variant_));

-  EXPECT_EQ(7.0, NPVARIANT_TO_DOUBLE(variant_));

-}

-

-TEST_F(NPVariantUtilsTest, TestDoubleValueToNPVariant) {

-  ValueToNPVariant(7.0, &variant_);

-  EXPECT_TRUE(NPVARIANT_IS_DOUBLE(variant_));

-  EXPECT_EQ(7.0, NPVARIANT_TO_DOUBLE(variant_));

-}

-

-TEST_F(NPVariantUtilsTest, 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(NPVariantUtilsTest, TestObjectValueToNPVariant) {

-  NPObject* object = NPN_CreateObject(NULL, np_class_);

-

-  ValueToNPVariant(object, &variant_);

-  EXPECT_TRUE(NPVARIANT_IS_OBJECT(variant_));

-  EXPECT_EQ(object, NPVARIANT_TO_OBJECT(variant_));

-

-  NPN_ReleaseVariantValue(&variant_);

-  NPN_ReleaseObject(object);

-}

-

-TEST_F(NPVariantUtilsTest, TestNullValueToNPVariant) {

-  ValueToNPVariant(static_cast<NPObject*>(NULL), &variant_);

-  EXPECT_TRUE(NPVARIANT_IS_NULL(variant_));

-}

-

-template <typename T>

-class VariantMatcher : public testing::MatcherInterface<const NPVariant&> {

- public:

-  explicit VariantMatcher(const T& value) : value_(value) {

-  }

-

-  virtual bool Matches(const NPVariant& variant) const {

-    T other_value;

-    return NPVariantToValue(&other_value, variant) && other_value == value_;

-  }

-

-  virtual void DescribeTo(::std::ostream* os) const {

-    *os << "equals " << value_;

-  }

-

-  virtual void DescribeNegationTo(::std::ostream* os) const {

-    *os << "does not equal " << value_;

-  }

-

- private:

-  T value_;

-};

-

-template <typename T>

-Matcher<const NPVariant&> VariantMatches(const T& value) {

-  return MakeMatcher(new VariantMatcher<T>(value));

-}

-

-TEST_F(NPVariantUtilsTest, CanInvokeVoidMethodWithNativeTypes) {

-  NPIdentifier name = NPN_GetStringIdentifier("foo");

-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(

-      NPN_CreateObject(NULL, np_class_));

-

-  VOID_TO_NPVARIANT(variant_);

-

-  EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int>(7)), 1, _))

-    .WillOnce(DoAll(SetArgumentPointee<3>(variant_),

-                    Return(true)));

-

-  EXPECT_TRUE(NPInvokeVoid(NULL, object, name, 7));

-

-  NPN_ReleaseObject(object);

-}

-

-TEST_F(NPVariantUtilsTest, InvokeVoidMethodCanFail) {

-  NPIdentifier name = NPN_GetStringIdentifier("foo");

-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(

-      NPN_CreateObject(NULL, np_class_));

-

-  VOID_TO_NPVARIANT(variant_);

-

-  EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int>(7)), 1, _))

-    .WillOnce(DoAll(SetArgumentPointee<3>(variant_),

-                    Return(false)));

-

-  EXPECT_FALSE(NPInvokeVoid(NULL, object, name, 7));

-

-  NPN_ReleaseObject(object);

-}

-

-TEST_F(NPVariantUtilsTest, CanInvokeNonVoidMethodWithNativeTypes) {

-  NPIdentifier name = NPN_GetStringIdentifier("foo");

-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(

-      NPN_CreateObject(NULL, np_class_));

-

-  DOUBLE_TO_NPVARIANT(1.5, variant_);

-

-  EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int>(7)), 1, _))

-    .WillOnce(DoAll(SetArgumentPointee<3>(variant_),

-                    Return(true)));

-

-  double r;

-  EXPECT_TRUE(NPInvoke(NULL, object, name, 7, &r));

-  EXPECT_EQ(1.5, r);

-

-  NPN_ReleaseObject(object);

-}

-

-TEST_F(NPVariantUtilsTest, InvokeNonVoidMethodCanFail) {

-  NPIdentifier name = NPN_GetStringIdentifier("foo");

-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(

-      NPN_CreateObject(NULL, np_class_));

-

-  DOUBLE_TO_NPVARIANT(1.5, variant_);

-

-  EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int>(7)), 1, _))

-    .WillOnce(DoAll(SetArgumentPointee<3>(variant_),

-                    Return(false)));

-

-  double r;

-  EXPECT_FALSE(NPInvoke(NULL, object, name, 7, &r));

-

-  NPN_ReleaseObject(object);

-}

-

-TEST_F(NPVariantUtilsTest, InvokeNonVoidMethodFailsIfResultIsIncompatible) {

-  NPIdentifier name = NPN_GetStringIdentifier("foo");

-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(

-      NPN_CreateObject(NULL, np_class_));

-

-  DOUBLE_TO_NPVARIANT(1.5, variant_);

-

-  EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int>(7)), 1, _))

-    .WillOnce(DoAll(SetArgumentPointee<3>(variant_),

-                    Return(true)));

-

-  int r;

-  EXPECT_FALSE(NPInvoke(NULL, object, name, 7, &r));

-

-  NPN_ReleaseObject(object);

-}

-

-}  // namespace gpu_plugin

-}  // namespace o3d

+// 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_variant_utils.h"
+#include "o3d/gpu_plugin/np_utils/npn_test_stub.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 NPVariantUtilsTest : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    InitializeNPNTestStub();
+
+    np_class_ = const_cast<NPClass*>(
+        BaseNPObject::GetNPClass<StrictMock<MockBaseNPObject> >());
+
+    // 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());
+
+    ShutdownNPNTestStub();
+  }
+
+  NPP_t npp_;
+  NPClass* np_class_;
+  NPVariant variant_;
+};
+
+TEST_F(NPVariantUtilsTest, TestBoolNPVariantToValue) {
+  bool v;
+
+  BOOLEAN_TO_NPVARIANT(false, variant_);
+  EXPECT_TRUE(NPVariantToValue(&v, variant_));
+  EXPECT_FALSE(v);
+
+  BOOLEAN_TO_NPVARIANT(true, variant_);
+  EXPECT_TRUE(NPVariantToValue(&v, variant_));
+  EXPECT_TRUE(v);
+
+  INT32_TO_NPVARIANT(7, variant_);
+  EXPECT_FALSE(NPVariantToValue(&v, variant_));
+}
+
+TEST_F(NPVariantUtilsTest, TestIntNPVariantToValue) {
+  INT32_TO_NPVARIANT(7, variant_);
+
+  int v1;
+  EXPECT_TRUE(NPVariantToValue(&v1, variant_));
+  EXPECT_EQ(7, v1);
+
+  float v2;
+  EXPECT_TRUE(NPVariantToValue(&v2, variant_));
+  EXPECT_EQ(7.0f, v2);
+
+  double v3;
+  EXPECT_TRUE(NPVariantToValue(&v3, variant_));
+  EXPECT_EQ(7.0, v3);
+
+  BOOLEAN_TO_NPVARIANT(false, variant_);
+  EXPECT_FALSE(NPVariantToValue(&v1, variant_));
+}
+
+TEST_F(NPVariantUtilsTest, TestFloatNPVariantToValue) {
+  float v;
+
+  DOUBLE_TO_NPVARIANT(7.0, variant_);
+  EXPECT_TRUE(NPVariantToValue(&v, variant_));
+  EXPECT_EQ(7.0f, v);
+
+  BOOLEAN_TO_NPVARIANT(false, variant_);
+  EXPECT_FALSE(NPVariantToValue(&v, variant_));
+}
+
+TEST_F(NPVariantUtilsTest, TestDoubleNPVariantToValue) {
+  double v;
+
+  DOUBLE_TO_NPVARIANT(7.0, variant_);
+  EXPECT_TRUE(NPVariantToValue(&v, variant_));
+  EXPECT_EQ(7.0, v);
+
+  BOOLEAN_TO_NPVARIANT(false, variant_);
+  EXPECT_FALSE(NPVariantToValue(&v, variant_));
+}
+
+TEST_F(NPVariantUtilsTest, TestStringNPVariantToValue) {
+  std::string v;
+
+  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(NPVariantUtilsTest, TestObjectNPVariantToValue) {
+  NPObject* object = gpu_plugin::NPN_CreateObject(NULL, np_class_);
+  NPObject* v;
+
+  OBJECT_TO_NPVARIANT(object, variant_);
+  EXPECT_TRUE(NPVariantToValue(&v, variant_));
+  EXPECT_EQ(object, v);
+
+  BOOLEAN_TO_NPVARIANT(false, variant_);
+  EXPECT_FALSE(NPVariantToValue(&v, variant_));
+
+  gpu_plugin::NPN_ReleaseObject(object);
+}
+
+TEST_F(NPVariantUtilsTest, TestNullNPVariantToValue) {
+  NPObject* v;
+
+  NULL_TO_NPVARIANT(variant_);
+  EXPECT_TRUE(NPVariantToValue(&v, variant_));
+  EXPECT_TRUE(NULL == v);
+
+  BOOLEAN_TO_NPVARIANT(false, variant_);
+  EXPECT_FALSE(NPVariantToValue(&v, variant_));
+}
+
+TEST_F(NPVariantUtilsTest, TestBoolValueToNPVariant) {
+  ValueToNPVariant(true, &variant_);
+  EXPECT_TRUE(NPVARIANT_IS_BOOLEAN(variant_));
+  EXPECT_TRUE(NPVARIANT_TO_BOOLEAN(variant_));
+
+  ValueToNPVariant(false, &variant_);
+  EXPECT_TRUE(NPVARIANT_IS_BOOLEAN(variant_));
+  EXPECT_FALSE(NPVARIANT_TO_BOOLEAN(variant_));
+}
+
+TEST_F(NPVariantUtilsTest, TestIntValueToNPVariant) {
+  ValueToNPVariant(7, &variant_);
+  EXPECT_TRUE(NPVARIANT_IS_INT32(variant_));
+  EXPECT_EQ(7, NPVARIANT_TO_INT32(variant_));
+}
+
+TEST_F(NPVariantUtilsTest, TestFloatValueToNPVariant) {
+  ValueToNPVariant(7.0f, &variant_);
+  EXPECT_TRUE(NPVARIANT_IS_DOUBLE(variant_));
+  EXPECT_EQ(7.0, NPVARIANT_TO_DOUBLE(variant_));
+}
+
+TEST_F(NPVariantUtilsTest, TestDoubleValueToNPVariant) {
+  ValueToNPVariant(7.0, &variant_);
+  EXPECT_TRUE(NPVARIANT_IS_DOUBLE(variant_));
+  EXPECT_EQ(7.0, NPVARIANT_TO_DOUBLE(variant_));
+}
+
+TEST_F(NPVariantUtilsTest, 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(NPVariantUtilsTest, TestObjectValueToNPVariant) {
+  NPObject* object = gpu_plugin::NPN_CreateObject(NULL, np_class_);
+
+  ValueToNPVariant(object, &variant_);
+  EXPECT_TRUE(NPVARIANT_IS_OBJECT(variant_));
+  EXPECT_EQ(object, NPVARIANT_TO_OBJECT(variant_));
+
+  gpu_plugin::NPN_ReleaseVariantValue(&variant_);
+  gpu_plugin::NPN_ReleaseObject(object);
+}
+
+TEST_F(NPVariantUtilsTest, TestNullValueToNPVariant) {
+  ValueToNPVariant(static_cast<NPObject*>(NULL), &variant_);
+  EXPECT_TRUE(NPVARIANT_IS_NULL(variant_));
+}
+
+template <typename T>
+class VariantMatcher : public testing::MatcherInterface<const NPVariant&> {
+ public:
+  explicit VariantMatcher(const T& value) : value_(value) {
+  }
+
+  virtual bool Matches(const NPVariant& variant) const {
+    T other_value;
+    return NPVariantToValue(&other_value, variant) && other_value == value_;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "equals " << value_;
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "does not equal " << value_;
+  }
+
+ private:
+  T value_;
+};
+
+template <typename T>
+Matcher<const NPVariant&> VariantMatches(const T& value) {
+  return MakeMatcher(new VariantMatcher<T>(value));
+}
+
+TEST_F(NPVariantUtilsTest, CanInvokeVoidMethodWithNativeTypes) {
+  NPIdentifier name = NPN_GetStringIdentifier("foo");
+  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+      gpu_plugin::NPN_CreateObject(NULL, np_class_));
+
+  VOID_TO_NPVARIANT(variant_);
+
+  EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int>(7)), 1, _))
+    .WillOnce(DoAll(SetArgumentPointee<3>(variant_),
+                    Return(true)));
+
+  EXPECT_TRUE(NPInvokeVoid(NULL, object, name, 7));
+
+  gpu_plugin::NPN_ReleaseObject(object);
+}
+
+TEST_F(NPVariantUtilsTest, InvokeVoidMethodCanFail) {
+  NPIdentifier name = NPN_GetStringIdentifier("foo");
+  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+      gpu_plugin::NPN_CreateObject(NULL, np_class_));
+
+  VOID_TO_NPVARIANT(variant_);
+
+  EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int>(7)), 1, _))
+    .WillOnce(DoAll(SetArgumentPointee<3>(variant_),
+                    Return(false)));
+
+  EXPECT_FALSE(NPInvokeVoid(NULL, object, name, 7));
+
+  gpu_plugin::NPN_ReleaseObject(object);
+}
+
+TEST_F(NPVariantUtilsTest, CanInvokeNonVoidMethodWithNativeTypes) {
+  NPIdentifier name = NPN_GetStringIdentifier("foo");
+  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+      gpu_plugin::NPN_CreateObject(NULL, np_class_));
+
+  DOUBLE_TO_NPVARIANT(1.5, variant_);
+
+  EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int>(7)), 1, _))
+    .WillOnce(DoAll(SetArgumentPointee<3>(variant_),
+                    Return(true)));
+
+  double r;
+  EXPECT_TRUE(NPInvoke(NULL, object, name, 7, &r));
+  EXPECT_EQ(1.5, r);
+
+  gpu_plugin::NPN_ReleaseObject(object);
+}
+
+TEST_F(NPVariantUtilsTest, InvokeNonVoidMethodCanFail) {
+  NPIdentifier name = NPN_GetStringIdentifier("foo");
+  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+      gpu_plugin::NPN_CreateObject(NULL, np_class_));
+
+  DOUBLE_TO_NPVARIANT(1.5, variant_);
+
+  EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int>(7)), 1, _))
+    .WillOnce(DoAll(SetArgumentPointee<3>(variant_),
+                    Return(false)));
+
+  double r;
+  EXPECT_FALSE(NPInvoke(NULL, object, name, 7, &r));
+
+  gpu_plugin::NPN_ReleaseObject(object);
+}
+
+TEST_F(NPVariantUtilsTest, InvokeNonVoidMethodFailsIfResultIsIncompatible) {
+  NPIdentifier name = NPN_GetStringIdentifier("foo");
+  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+      gpu_plugin::NPN_CreateObject(NULL, np_class_));
+
+  DOUBLE_TO_NPVARIANT(1.5, variant_);
+
+  EXPECT_CALL(*object, Invoke(name, Pointee(VariantMatches<int>(7)), 1, _))
+    .WillOnce(DoAll(SetArgumentPointee<3>(variant_),
+                    Return(true)));
+
+  int r;
+  EXPECT_FALSE(NPInvoke(NULL, object, name, 7, &r));
+
+  gpu_plugin::NPN_ReleaseObject(object);
+}
+
+}  // namespace gpu_plugin
+}  // namespace o3d
diff --git a/o3d/gpu_plugin/np_utils/npn_test_stub.cc b/o3d/gpu_plugin/np_utils/npn_test_stub.cc
index 4e8b472..f217711 100644
--- a/o3d/gpu_plugin/np_utils/npn_test_stub.cc
+++ b/o3d/gpu_plugin/np_utils/npn_test_stub.cc
@@ -7,15 +7,19 @@
 #include <set>
 #include <string>
 
+#include "o3d/gpu_plugin/np_utils/npn_funcs.h"
 #include "o3d/gpu_plugin/np_utils/npn_test_stub.h"
+#include "webkit/glue/plugins/nphostapi.h"
 
 // Simple implementation of subset of the NPN functions for testing.
 
+namespace o3d {
+namespace gpu_plugin {
+
 namespace {
-  std::set<std::string> names;
-}
+std::set<std::string> names;
 
-NPIdentifier NPN_GetStringIdentifier(const NPUTF8* name) {
+NPIdentifier GetStringIdentifier(const NPUTF8* name) {
   std::set<std::string>::iterator it = names.find(name);
   if (it == names.end()) {
     it = names.insert(name).first;
@@ -23,42 +27,97 @@ NPIdentifier NPN_GetStringIdentifier(const NPUTF8* name) {
   return const_cast<NPUTF8*>((*it).c_str());
 }
 
-void* NPN_MemAlloc(size_t size) {
+void* MemAlloc(size_t size) {
   return malloc(size);
 }
 
-void NPN_MemFree(void* p) {
+void MemFree(void* p) {
   free(p);
 }
 
-NPObject* NPN_CreateObject(NPP npp, NPClass* cl) {
+NPObject* CreateObject(NPP npp, NPClass* cl) {
   NPObject* object = cl->allocate(npp, cl);
   object->referenceCount = 1;
   object->_class = cl;
   return object;
 }
 
-NPObject* NPN_RetainObject(NPObject* object) {
+NPObject* RetainObject(NPObject* object) {
   ++object->referenceCount;
   return object;
 }
 
-void NPN_ReleaseObject(NPObject* object) {
+void ReleaseObject(NPObject* object) {
   --object->referenceCount;
   if (object->referenceCount == 0) {
     object->_class->deallocate(object);
   }
 }
 
-void NPN_ReleaseVariantValue(NPVariant* variant) {
+void ReleaseVariantValue(NPVariant* variant) {
   if (NPVARIANT_IS_STRING(*variant)) {
     NPN_MemFree(const_cast<NPUTF8*>(variant->value.stringValue.UTF8Characters));
   } else if (NPVARIANT_IS_OBJECT(*variant)) {
-    NPN_ReleaseObject(NPVARIANT_TO_OBJECT(*variant));
+    gpu_plugin::NPN_ReleaseObject(NPVARIANT_TO_OBJECT(*variant));
   }
 }
 
-bool NPN_Invoke(NPP npp, NPObject* object, NPIdentifier name,
-                const NPVariant* args, uint32_t num_args, NPVariant* result) {
+bool Invoke(NPP npp, NPObject* object, NPIdentifier name,
+            const NPVariant* args, uint32_t num_args, NPVariant* result) {
   return object->_class->invoke(object, name, args, num_args, result);
 }
+}  // namespace anonymous
+
+void InitializeNPNTestStub() {
+  static NPNetscapeFuncs funcs = {
+    sizeof(NPNetscapeFuncs),
+    NP_VERSION_MINOR,
+    NULL,  // geturl
+    NULL,  // posturl
+    NULL,  // requestread
+    NULL,  // newstream
+    NULL,  // write
+    NULL,  // destroystream
+    NULL,  // status
+    NULL,  // uagent
+    MemAlloc,
+    MemFree,
+    NULL,  // memflush
+    NULL,  // reloadplugins
+    NULL,  // getJavaEnv
+    NULL,  // getJavaPeer
+    NULL,  // geturlnotify
+    NULL,  // posturlnotify
+    NULL,  // getvalue
+    NULL,  // setvalue
+    NULL,  // invalidaterect
+    NULL,  // invalidateregion
+    NULL,  // forceredraw
+    GetStringIdentifier,
+    NULL,  // getstringidentifiers
+    NULL,  // getintidentifier
+    NULL,  // identifierisstring
+    NULL,  // utf8fromidentifier
+    NULL,  // intfromidentifier
+    CreateObject,
+    RetainObject,
+    ReleaseObject,
+    Invoke,
+    NULL,  // invokeDefault
+    NULL,  // evaluate
+    NULL,  // getproperty
+    NULL,  // setproperty
+    NULL,  // removeproperty
+    NULL,  // hasproperty
+    NULL,  // hasmethod
+    ReleaseVariantValue,
+  };
+  SetBrowserFuncs(&funcs);
+}
+
+void ShutdownNPNTestStub() {
+  SetBrowserFuncs(NULL);
+}
+
+}  // namespace gpu_plugin
+}  // namespace o3d
diff --git a/o3d/gpu_plugin/np_utils/npn_test_stub.h b/o3d/gpu_plugin/np_utils/npn_test_stub.h
index 9567c17..6b07416 100644
--- a/o3d/gpu_plugin/np_utils/npn_test_stub.h
+++ b/o3d/gpu_plugin/np_utils/npn_test_stub.h
@@ -8,16 +8,14 @@
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
+namespace o3d {
+namespace gpu_plugin {
+
 // Simple implementation of subset of the NPN functions for testing.
+void InitializeNPNTestStub();
+void ShutdownNPNTestStub();
 
-NPIdentifier NPN_GetStringIdentifier(const NPUTF8* name);
-void* NPN_MemAlloc(size_t size);
-void NPN_MemFree(void* p);
-NPObject* NPN_CreateObject(NPP npp, NPClass* cl);
-NPObject* NPN_RetainObject(NPObject* object);
-void NPN_ReleaseObject(NPObject* object);
-void NPN_ReleaseVariantValue(NPVariant* variant);
-bool NPN_Invoke(NPP npp, NPObject* object, NPIdentifier name,
-                const NPVariant* args, uint32_t num_args, NPVariant* result);
+}  // namespace gpu_plugin
+}  // namespace o3d
 
 #endif  // O3D_GPU_PLUGIN_NP_UTILS_NPN_TEST_STUB_H_