Replaced BaseNPObject with DefaultNPObject because...

DefaultNPObject can derive from bases other than NPObject, allowing concrete NPObjects to choose their own NPObject subclass.
DefaultNPObject does not rely on virtual functions. See change to NPGetClass in np_class.h.

Removed count() from MockNPObject because I discovered gmock checks that no mock objects exist after a test completes anyway.

TEST=none
BUG=none

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

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

27 files changed, 535 insertions, 657 deletions

diff --git a/o3d/gpu_plugin/command_buffer.cc b/o3d/gpu_plugin/command_buffer.cc
index c962f28..ca2d691 100644
--- a/o3d/gpu_plugin/command_buffer.cc
+++ b/o3d/gpu_plugin/command_buffer.cc
@@ -7,12 +7,12 @@
 namespace o3d {
 namespace gpu_plugin {
 
-CommandBuffer::CommandBuffer(NPP npp) : DispatchedNPObject(npp) {
+CommandBuffer::CommandBuffer(NPP npp) : npp_(npp) {
 }
 
 CommandBuffer::~CommandBuffer() {
   if (shared_memory_) {
-    NPBrowser::get()->UnmapSharedMemory(npp(), shared_memory_);
+    NPBrowser::get()->UnmapSharedMemory(npp_, shared_memory_);
   }
 }
 
@@ -21,27 +21,27 @@ bool CommandBuffer::Initialize(int32 size) {
     return false;
 
   NPObjectPointer<NPObject> window = NPObjectPointer<NPObject>::FromReturned(
-      NPBrowser::get()->GetWindowNPObject(npp()));
+      NPBrowser::get()->GetWindowNPObject(npp_));
   if (!window.Get())
     return false;
 
   NPObjectPointer<NPObject> chromium;
-  if (!NPGetProperty(npp(), window, "chromium", &chromium)) {
+  if (!NPGetProperty(npp_, window, "chromium", &chromium)) {
     return false;
   }
 
   NPObjectPointer<NPObject> system;
-  if (!NPGetProperty(npp(), chromium, "system", &system)) {
+  if (!NPGetProperty(npp_, chromium, "system", &system)) {
     return false;
   }
 
-  if (!NPInvoke(npp(), system, "createSharedMemory", size,
+  if (!NPInvoke(npp_, system, "createSharedMemory", size,
                 &buffer_object_)) {
     return false;
   }
 
   shared_memory_ = NPBrowser::get()->MapSharedMemory(
-      npp(), buffer_object_.Get(), size, false);
+      npp_, buffer_object_.Get(), size, false);
   if (!shared_memory_) {
     buffer_object_ = NPObjectPointer<NPObject>();
     return false;
diff --git a/o3d/gpu_plugin/command_buffer.h b/o3d/gpu_plugin/command_buffer.h
index 454e48a..1fdc299 100644
--- a/o3d/gpu_plugin/command_buffer.h
+++ b/o3d/gpu_plugin/command_buffer.h
@@ -5,14 +5,15 @@
 #ifndef O3D_GPU_PLUGIN_COMMAND_BUFFER_H_
 #define O3D_GPU_PLUGIN_COMMAND_BUFFER_H_
 
-#include "o3d/gpu_plugin/np_utils/dispatched_np_object.h"
+#include "o3d/gpu_plugin/np_utils/default_np_object.h"
+#include "o3d/gpu_plugin/np_utils/np_dispatcher.h"
 
 namespace o3d {
 namespace gpu_plugin {
 
 // An NPObject that implements a shared memory command buffer and a synchronous
 // API to manage the put and get pointers.
-class CommandBuffer : public DispatchedNPObject {
+class CommandBuffer : public DefaultNPObject<NPObject> {
  public:
   explicit CommandBuffer(NPP npp);
   virtual ~CommandBuffer();
@@ -29,8 +30,7 @@ class CommandBuffer : public DispatchedNPObject {
   // The client calls this to get the servers current get offset.
   virtual int32 GetGetOffset();
 
- protected:
-  NP_UTILS_BEGIN_DISPATCHER_CHAIN(CommandBuffer, DispatchedNPObject)
+  NP_UTILS_BEGIN_DISPATCHER_CHAIN(CommandBuffer, DefaultNPObject<NPObject>)
     NP_UTILS_DISPATCHER(Initialize, bool(int32))
     NP_UTILS_DISPATCHER(SetPutOffset, void(int32))
     NP_UTILS_DISPATCHER(GetGetOffset, int32())
@@ -38,6 +38,7 @@ class CommandBuffer : public DispatchedNPObject {
   NP_UTILS_END_DISPATCHER_CHAIN
 
  private:
+  NPP npp_;
   NPObjectPointer<NPObject> buffer_object_;
   NPSharedMemory* shared_memory_;
 };
diff --git a/o3d/gpu_plugin/command_buffer_unittest.cc b/o3d/gpu_plugin/command_buffer_unittest.cc
index 335a2cc..5931081 100644
--- a/o3d/gpu_plugin/command_buffer_unittest.cc
+++ b/o3d/gpu_plugin/command_buffer_unittest.cc
@@ -3,9 +3,9 @@
 // found in the LICENSE file.
 
 #include "o3d/gpu_plugin/command_buffer.h"
-#include "o3d/gpu_plugin/np_utils/base_np_object_mock.h"
 #include "o3d/gpu_plugin/np_utils/dynamic_np_object.h"
 #include "o3d/gpu_plugin/np_utils/np_browser_mock.h"
+#include "o3d/gpu_plugin/np_utils/np_object_mock.h"
 #include "o3d/gpu_plugin/np_utils/np_object_pointer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -19,15 +19,14 @@ using testing::StrictMock;
 namespace o3d {
 namespace gpu_plugin {
 
-class MockSystemNPObject : public DispatchedNPObject {
+class MockSystemNPObject : public DefaultNPObject<NPObject> {
  public:
-  explicit MockSystemNPObject(NPP npp) : DispatchedNPObject(npp) {
+  explicit MockSystemNPObject(NPP npp) {
   }
 
   MOCK_METHOD1(CreateSharedMemory, NPObjectPointer<NPObject>(int32));
 
- protected:
-  NP_UTILS_BEGIN_DISPATCHER_CHAIN(MockSystemNPObject, DispatchedNPObject)
+  NP_UTILS_BEGIN_DISPATCHER_CHAIN(MockSystemNPObject, DefaultNPObject<NPObject>)
     NP_UTILS_DISPATCHER(CreateSharedMemory, NPObjectPointer<NPObject>(int32))
   NP_UTILS_END_DISPATCHER_CHAIN
 
@@ -65,8 +64,8 @@ TEST_F(CommandBufferTest, InitializesCommandBuffer) {
   EXPECT_CALL(mock_browser_, GetWindowNPObject(NULL))
     .WillOnce(Return(window_object_.ToReturned()));
 
-  NPObjectPointer<BaseNPObject> expected_buffer =
-      NPCreateObject<BaseNPObject>(NULL);
+  NPObjectPointer<NPObject> expected_buffer =
+      NPCreateObject<MockNPObject>(NULL);
 
   EXPECT_CALL(*system_object_.Get(), CreateSharedMemory(1024))
     .WillOnce(Return(expected_buffer));
@@ -92,7 +91,7 @@ TEST_F(CommandBufferTest, InitializeFailsIfCannotCreateSharedMemory) {
     .WillOnce(Return(window_object_.ToReturned()));
 
   EXPECT_CALL(*system_object_.Get(), CreateSharedMemory(1024))
-    .WillOnce(Return(NPObjectPointer<BaseNPObject>()));
+    .WillOnce(Return(NPObjectPointer<NPObject>()));
 
   EXPECT_FALSE(command_buffer_object_->Initialize(1024));
   EXPECT_EQ(NPObjectPointer<NPObject>(), command_buffer_object_->GetBuffer());
@@ -102,8 +101,8 @@ TEST_F(CommandBufferTest, InitializeFailsIfCannotMapSharedMemory) {
   EXPECT_CALL(mock_browser_, GetWindowNPObject(NULL))
     .WillOnce(Return(window_object_.ToReturned()));
 
-  NPObjectPointer<BaseNPObject> expected_buffer =
-      NPCreateObject<BaseNPObject>(NULL);
+  NPObjectPointer<NPObject> expected_buffer =
+      NPCreateObject<MockNPObject>(NULL);
 
   EXPECT_CALL(*system_object_.Get(), CreateSharedMemory(1024))
     .WillOnce(Return(expected_buffer));
diff --git a/o3d/gpu_plugin/gpu_plugin.gyp b/o3d/gpu_plugin/gpu_plugin.gyp
index 3e1eb52..a466e12 100644
--- a/o3d/gpu_plugin/gpu_plugin.gyp
+++ b/o3d/gpu_plugin/gpu_plugin.gyp
@@ -27,14 +27,13 @@
         'gpu_plugin_object_win.cc',
         'gpu_plugin_object_factory.cc',
         'gpu_plugin_object_factory.h',
-        'np_utils/base_np_object.cc',
-        'np_utils/base_np_object.h',
-        'np_utils/dispatched_np_object.cc',
-        'np_utils/dispatched_np_object.h',
+        'np_utils/default_np_object.h',
         'np_utils/dynamic_np_object.cc',
         'np_utils/dynamic_np_object.h',
         'np_utils/np_browser.cc',
         'np_utils/np_browser.h',
+        'np_utils/np_class.h',
+        'np_utils/np_dispatcher.cc',
         'np_utils/np_dispatcher.h',
         'np_utils/np_dispatcher_specializations.h',
         'np_utils/np_object_pointer.h',
@@ -67,14 +66,13 @@
         'gpu_plugin_unittest.cc',
         'gpu_plugin_object_unittest.cc',
         'gpu_plugin_object_factory_unittest.cc',
-        'np_utils/base_np_object_mock.cc',
-        'np_utils/base_np_object_mock.h',
-        'np_utils/base_np_object_unittest.cc',
+        'np_utils/dispatched_np_object_unittest.cc',
+        'np_utils/dynamic_np_object_unittest.cc',
         'np_utils/np_browser_mock.h',
         'np_utils/np_browser_stub.cc',
         'np_utils/np_browser_stub.h',
-        'np_utils/dispatched_np_object_unittest.cc',
-        'np_utils/dynamic_np_object_unittest.cc',
+        'np_utils/np_class_unittest.cc',
+        'np_utils/np_object_mock.h',
         'np_utils/np_object_pointer_unittest.cc',
         'np_utils/np_plugin_object_factory_mock.h',
         'np_utils/np_plugin_object_mock.h',
diff --git a/o3d/gpu_plugin/gpu_plugin_object.cc b/o3d/gpu_plugin/gpu_plugin_object.cc
index 9187f08..329cd58 100644
--- a/o3d/gpu_plugin/gpu_plugin_object.cc
+++ b/o3d/gpu_plugin/gpu_plugin_object.cc
@@ -5,6 +5,7 @@
 #include <stdlib.h>
 
 #include "base/logging.h"
+#include "o3d/gpu_plugin/np_utils/np_utils.h"
 #include "o3d/gpu_plugin/gpu_plugin_object.h"
 
 namespace o3d {
@@ -18,7 +19,7 @@ const NPUTF8 GPUPluginObject::kPluginType[] =
     "application/vnd.google.chrome.gpu-plugin";
 
 GPUPluginObject::GPUPluginObject(NPP npp)
-    : DispatchedNPObject(npp),
+    : npp_(npp),
       status_(CREATED),
       shared_memory_(NULL) {
   memset(&window_, 0, sizeof(window_));
@@ -60,7 +61,7 @@ NPError GPUPluginObject::Destroy(NPSavedData** saved) {
     return NPERR_GENERIC_ERROR;
 
   if (shared_memory_) {
-    NPBrowser::get()->UnmapSharedMemory(npp(), shared_memory_);
+    NPBrowser::get()->UnmapSharedMemory(npp_, shared_memory_);
   }
 
   command_buffer_object_ = NPObjectPointer<CommandBuffer>();
@@ -84,7 +85,7 @@ NPObjectPointer<NPObject> GPUPluginObject::OpenCommandBuffer() {
   if (command_buffer_object_.Get())
     return command_buffer_object_;
 
-  command_buffer_object_ = NPCreateObject<CommandBuffer>(npp());
+  command_buffer_object_ = NPCreateObject<CommandBuffer>(npp_);
   if (!command_buffer_object_->Initialize(kCommandBufferSize)) {
     command_buffer_object_ = NPObjectPointer<CommandBuffer>();
   }
diff --git a/o3d/gpu_plugin/gpu_plugin_object.h b/o3d/gpu_plugin/gpu_plugin_object.h
index 5bafa0a..38b684b 100644
--- a/o3d/gpu_plugin/gpu_plugin_object.h
+++ b/o3d/gpu_plugin/gpu_plugin_object.h
@@ -19,7 +19,8 @@ namespace o3d {
 namespace gpu_plugin {
 
 // The scriptable object for the GPU plugin.
-class GPUPluginObject : public DispatchedNPObject, public PluginObject {
+class GPUPluginObject : public DefaultNPObject<NPObject>,
+                        public PluginObject {
  public:
   static const NPUTF8 kPluginType[];
 
@@ -45,8 +46,7 @@ class GPUPluginObject : public DispatchedNPObject, public PluginObject {
   // Initializes and returns the command buffer object.
   NPObjectPointer<NPObject> OpenCommandBuffer();
 
- protected:
-  NP_UTILS_BEGIN_DISPATCHER_CHAIN(GPUPluginObject, DispatchedNPObject)
+  NP_UTILS_BEGIN_DISPATCHER_CHAIN(GPUPluginObject, DefaultNPObject<NPObject>)
     NP_UTILS_DISPATCHER(OpenCommandBuffer, NPObjectPointer<NPObject>())
   NP_UTILS_END_DISPATCHER_CHAIN
 
@@ -59,6 +59,7 @@ class GPUPluginObject : public DispatchedNPObject, public PluginObject {
     DESTROYED,
   };
 
+  NPP npp_;
   Status status_;
   NPWindow window_;
   NPObjectPointer<CommandBuffer> command_buffer_object_;
diff --git a/o3d/gpu_plugin/gpu_plugin_object_factory.cc b/o3d/gpu_plugin/gpu_plugin_object_factory.cc
index 7a2e8d4..5f0a85e 100644
--- a/o3d/gpu_plugin/gpu_plugin_object_factory.cc
+++ b/o3d/gpu_plugin/gpu_plugin_object_factory.cc
@@ -4,6 +4,7 @@
 
 #include "o3d/gpu_plugin/gpu_plugin_object.h"
 #include "o3d/gpu_plugin/gpu_plugin_object_factory.h"
+#include "o3d/gpu_plugin/np_utils/np_utils.h"
 
 namespace o3d {
 namespace gpu_plugin {
diff --git a/o3d/gpu_plugin/gpu_plugin_object_unittest.cc b/o3d/gpu_plugin/gpu_plugin_object_unittest.cc
index 35bccc8..452cba5 100644
--- a/o3d/gpu_plugin/gpu_plugin_object_unittest.cc
+++ b/o3d/gpu_plugin/gpu_plugin_object_unittest.cc
@@ -4,8 +4,8 @@
 
 #include "o3d/gpu_plugin/command_buffer_mock.h"
 #include "o3d/gpu_plugin/gpu_plugin_object.h"
-#include "o3d/gpu_plugin/np_utils/base_np_object_mock.h"
 #include "o3d/gpu_plugin/np_utils/np_browser_mock.h"
+#include "o3d/gpu_plugin/np_utils/np_object_mock.h"
 #include "o3d/gpu_plugin/np_utils/np_object_pointer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -107,7 +107,7 @@ TEST_F(GPUPluginObjectTest, OpenCommandBufferReturnsInitializedCommandBuffer) {
   NPObjectPointer<MockCommandBuffer> command_buffer_object =
       NPCreateObject<StrictMock<MockCommandBuffer> >(NULL);
   EXPECT_CALL(mock_browser_, CreateObject(NULL,
-      BaseNPObject::GetNPClass<CommandBuffer>()))
+      NPGetClass<CommandBuffer>()))
     .WillOnce(Return(command_buffer_object.ToReturned()));
 
   EXPECT_CALL(*command_buffer_object.Get(), Initialize(1024))
@@ -132,7 +132,7 @@ TEST_F(GPUPluginObjectTest, OpenCommandBufferReturnsNullIfCannotInitialize) {
   NPObjectPointer<MockCommandBuffer> command_buffer_object =
       NPCreateObject<StrictMock<MockCommandBuffer> >(NULL);
   EXPECT_CALL(mock_browser_, CreateObject(NULL,
-      BaseNPObject::GetNPClass<CommandBuffer>()))
+      NPGetClass<CommandBuffer>()))
     .WillOnce(Return(command_buffer_object.ToReturned()));
 
   EXPECT_CALL(*command_buffer_object.Get(), Initialize(1024))
diff --git a/o3d/gpu_plugin/gpu_plugin_unittest.cc b/o3d/gpu_plugin/gpu_plugin_unittest.cc
index 028f1c2..5cf0b77 100644
--- a/o3d/gpu_plugin/gpu_plugin_unittest.cc
+++ b/o3d/gpu_plugin/gpu_plugin_unittest.cc
@@ -4,7 +4,7 @@
 
 #include "o3d/gpu_plugin/gpu_plugin.h"
 #include "o3d/gpu_plugin/gpu_plugin_object.h"
-#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_plugin_object_factory_mock.h"
 #include "o3d/gpu_plugin/np_utils/np_plugin_object_mock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -35,7 +35,7 @@ class GPUPluginTest : public testing::Test {
 
     plugin_object_factory_ = new StrictMock<MockPluginObjectFactory>;
 
-    np_class_ = BaseNPObject::GetNPClass<StrictMock<MockBaseNPObject> >();
+    np_class_ = NPGetClass<StrictMock<MockNPObject> >();
   }
 
   virtual void TearDown() {
diff --git a/o3d/gpu_plugin/np_utils/base_np_object.cc b/o3d/gpu_plugin/np_utils/base_np_object.cc
deleted file mode 100644
index a2d5f6b..0000000
--- a/o3d/gpu_plugin/np_utils/base_np_object.cc
+++ /dev/null
@@ -1,136 +0,0 @@
-// 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.h"
-
-namespace o3d {
-namespace gpu_plugin {
-
-BaseNPObject::BaseNPObject(NPP npp) : npp_(npp) {
-}
-
-BaseNPObject::~BaseNPObject() {
-}
-
-// The default implementations of the virtual functions return failure and clear
-// the result variant to void if appropriate.
-
-void BaseNPObject::Invalidate() {
-}
-
-bool BaseNPObject::HasMethod(NPIdentifier name) {
-  return false;
-}
-
-bool BaseNPObject::Invoke(NPIdentifier name,
-                          const NPVariant* args,
-                          uint32_t num_args,
-                          NPVariant* result) {
-  VOID_TO_NPVARIANT(*result);
-  return false;
-}
-
-bool BaseNPObject::InvokeDefault(const NPVariant* args,
-                                 uint32_t num_args,
-                                 NPVariant* result) {
-  VOID_TO_NPVARIANT(*result);
-  return false;
-}
-
-bool BaseNPObject::HasProperty(NPIdentifier name) {
-  return false;
-}
-
-bool BaseNPObject::GetProperty(NPIdentifier name, NPVariant* result) {
-  VOID_TO_NPVARIANT(*result);
-  return false;
-}
-
-bool BaseNPObject::SetProperty(NPIdentifier name, const NPVariant* value) {
-  return false;
-}
-
-bool BaseNPObject::RemoveProperty(NPIdentifier name) {
-  return false;
-}
-
-bool BaseNPObject::Enumerate(NPIdentifier** names, uint32_t* count) {
-  return false;
-}
-
-bool BaseNPObject::Construct(const NPVariant* args,
-                             uint32_t num_args,
-                             NPVariant* result) {
-  VOID_TO_NPVARIANT(*result);
-  return false;
-}
-
-// These implementations of the NPClass functions forward to the virtual
-// functions in BaseNPObject.
-
-void BaseNPObject::DeallocateImpl(NPObject* object) {
-  delete static_cast<BaseNPObject*>(object);
-}
-
-void BaseNPObject::InvalidateImpl(NPObject* object) {
-  return static_cast<BaseNPObject*>(object)->Invalidate();
-}
-
-bool BaseNPObject::HasMethodImpl(NPObject* object, NPIdentifier name) {
-  return static_cast<BaseNPObject*>(object)->HasMethod(name);
-}
-
-bool BaseNPObject::InvokeImpl(NPObject* object,
-                              NPIdentifier name,
-                              const NPVariant* args,
-                              uint32_t num_args,
-                              NPVariant* result) {
-  return static_cast<BaseNPObject*>(object)->Invoke(
-      name, args, num_args, result);
-}
-
-bool BaseNPObject::InvokeDefaultImpl(NPObject* object,
-                                     const NPVariant* args,
-                                     uint32_t num_args,
-                                     NPVariant* result) {
-  return static_cast<BaseNPObject*>(object)->InvokeDefault(
-      args, num_args, result);
-}
-
-bool BaseNPObject::HasPropertyImpl(NPObject* object, NPIdentifier name) {
-  return static_cast<BaseNPObject*>(object)->HasProperty(name);
-}
-
-bool BaseNPObject::GetPropertyImpl(NPObject* object,
-                                   NPIdentifier name,
-                                   NPVariant* result) {
-  return static_cast<BaseNPObject*>(object)->GetProperty(name, result);
-}
-
-bool BaseNPObject::SetPropertyImpl(NPObject* object,
-                                   NPIdentifier name,
-                                   const NPVariant* value) {
-  return static_cast<BaseNPObject*>(object)->SetProperty(name, value);
-}
-
-bool BaseNPObject::RemovePropertyImpl(NPObject* object, NPIdentifier name) {
-  return static_cast<BaseNPObject*>(object)->RemoveProperty(name);
-}
-
-bool BaseNPObject::EnumerateImpl(NPObject* object,
-                                 NPIdentifier** names,
-                                 uint32_t* count) {
-  return static_cast<BaseNPObject*>(object)->Enumerate(names, count);
-}
-
-bool BaseNPObject::ConstructImpl(NPObject* object,
-                                 const NPVariant* args,
-                                 uint32_t num_args,
-                                 NPVariant* result) {
-  return static_cast<BaseNPObject*>(object)->Construct(
-      args, num_args, result);
-}
-
-}  // namespace gpu_plugin
-}  // namespace o3d
diff --git a/o3d/gpu_plugin/np_utils/base_np_object.h b/o3d/gpu_plugin/np_utils/base_np_object.h
deleted file mode 100644
index b7815b8..0000000
--- a/o3d/gpu_plugin/np_utils/base_np_object.h
+++ /dev/null
@@ -1,135 +0,0 @@
-// 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.
-
-#ifndef O3D_GPU_PLUGIN_NP_UTILS_BASE_NP_OBJECT_H_
-#define O3D_GPU_PLUGIN_NP_UTILS_BASE_NP_OBJECT_H_
-
-#include "third_party/npapi/bindings/npapi.h"
-#include "third_party/npapi/bindings/npruntime.h"
-
-namespace o3d {
-namespace gpu_plugin {
-
-// This class is a base class for NPObjects implemented in C++. It forwards
-// The NPObject calls through to virtual functions implemented by the subclass.
-class BaseNPObject : public NPObject {
- public:
-  // Returns the NPClass for the concrete BaseNPObject subclass T.
-  template <typename NPObjectType>
-  static const NPClass* GetNPClass();
-
-  NPP npp() const {
-    return npp_;
-  }
-
-  // Override these in subclass.
-  virtual void Invalidate();
-
-  virtual bool HasMethod(NPIdentifier name);
-
-  virtual bool Invoke(NPIdentifier name,
-                      const NPVariant* args,
-                      uint32_t num_args,
-                      NPVariant* result);
-
-  virtual bool InvokeDefault(const NPVariant* args,
-                             uint32_t num_args,
-                             NPVariant* result);
-
-  virtual bool HasProperty(NPIdentifier name);
-
-  virtual bool GetProperty(NPIdentifier name, NPVariant* result);
-
-  virtual bool SetProperty(NPIdentifier name, const NPVariant* value);
-
-  virtual bool RemoveProperty(NPIdentifier name);
-
-  virtual bool Enumerate(NPIdentifier** names,
-                         uint32_t* count);
-
-  virtual bool Construct(const NPVariant* args,
-                         uint32_t num_args,
-                         NPVariant* result);
-
- protected:
-
-  explicit BaseNPObject(NPP npp);
-  virtual ~BaseNPObject();
-
- private:
-  // This template version of the NPClass allocate function creates a subclass
-  // of BaseNPObject.
-  template <typename NPObjectType>
-  static NPObject* AllocateImpl(NPP npp, NPClass*) {
-    return new NPObjectType(npp);
-  }
-
-  // These implementations of the NPClass functions forward to the virtual
-  // functions in BaseNPObject.
-  static void DeallocateImpl(NPObject* object);
-
-  static void InvalidateImpl(NPObject* object);
-
-  static bool HasMethodImpl(NPObject* object, NPIdentifier name);
-
-  static bool InvokeImpl(NPObject* object,
-                         NPIdentifier name,
-                         const NPVariant* args,
-                         uint32_t num_args,
-                         NPVariant* result);
-
-  static bool InvokeDefaultImpl(NPObject* object,
-                                const NPVariant* args,
-                                uint32_t num_args,
-                                NPVariant* result);
-
-  static bool HasPropertyImpl(NPObject* object, NPIdentifier name);
-
-  static bool GetPropertyImpl(NPObject* object,
-                              NPIdentifier name,
-                              NPVariant* result);
-
-  static bool SetPropertyImpl(NPObject* object,
-                              NPIdentifier name,
-                              const NPVariant* value);
-
-  static bool RemovePropertyImpl(NPObject* object, NPIdentifier name);
-
-  static bool EnumerateImpl(NPObject* object,
-                            NPIdentifier** names,
-                            uint32_t* count);
-
-  static bool ConstructImpl(NPObject* object,
-                            const NPVariant* args,
-                            uint32_t num_args,
-                            NPVariant* result);
-
-  NPP npp_;
-
-  DISALLOW_COPY_AND_ASSIGN(BaseNPObject);
-};
-
-template <typename NPObjectType>
-const NPClass* BaseNPObject::GetNPClass() {
-  static NPClass np_class = {
-    NP_CLASS_STRUCT_VERSION,
-    AllocateImpl<NPObjectType>,
-    DeallocateImpl,
-    InvalidateImpl,
-    HasMethodImpl,
-    InvokeImpl,
-    InvokeDefaultImpl,
-    HasPropertyImpl,
-    GetPropertyImpl,
-    SetPropertyImpl,
-    RemovePropertyImpl,
-    EnumerateImpl,
-    ConstructImpl,
-  };
-  return &np_class;
-};
-}  // namespace gpu_plugin
-}  // namespace o3d
-
-#endif  // O3D_GPU_PLUGIN_NP_UTILS_BASE_NP_OBJECT_H_
diff --git a/o3d/gpu_plugin/np_utils/base_np_object_mock.cc b/o3d/gpu_plugin/np_utils/base_np_object_mock.cc
deleted file mode 100644
index 5dc8dbf..0000000
--- a/o3d/gpu_plugin/np_utils/base_np_object_mock.cc
+++ /dev/null
@@ -1,13 +0,0 @@
-// 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"
-
-namespace o3d {
-namespace gpu_plugin {
-
-int MockBaseNPObject::count_ = 0;
-
-}  // namespace gpu_plugin
-}  // namespace o3d
diff --git a/o3d/gpu_plugin/np_utils/default_np_object.h b/o3d/gpu_plugin/np_utils/default_np_object.h
new file mode 100644
index 0000000..4228fcd
--- /dev/null
+++ b/o3d/gpu_plugin/np_utils/default_np_object.h
@@ -0,0 +1,86 @@
+// 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.
+
+#ifndef O3D_GPU_PLUGIN_NP_UTILS_DEFAULT_NP_OBJECT_H_
+#define O3D_GPU_PLUGIN_NP_UTILS_DEFAULT_NP_OBJECT_H_
+
+#include "third_party/npapi/bindings/npapi.h"
+#include "third_party/npapi/bindings/npruntime.h"
+
+namespace o3d {
+namespace gpu_plugin {
+
+class BaseNPDispatcher;
+
+// This class implements each of the functions in the NPClass interface. They
+// all return error by default. Note that these are not virtual functions and
+// this is not an interface. This class can be used as a mixin so that an
+// NPObject class does not need to implement every NPClass function but rather
+// inherits a default from DefaultNPObject.
+template <typename RootClass>
+class DefaultNPObject : public RootClass {
+ public:
+  void Invalidate() {}
+
+  bool HasMethod(NPIdentifier name) {
+    return false;
+  }
+
+  bool Invoke(NPIdentifier name,
+              const NPVariant* args,
+              uint32_t num_args,
+              NPVariant* result) {
+    return false;
+  }
+
+  bool InvokeDefault(const NPVariant* args,
+                     uint32_t num_args,
+                     NPVariant* result) {
+    return false;
+  }
+
+  bool HasProperty(NPIdentifier name) {
+    return false;
+  }
+
+  bool GetProperty(NPIdentifier name, NPVariant* result) {
+    return false;
+  }
+
+  bool SetProperty(NPIdentifier name, const NPVariant* value) {
+    return false;
+  }
+
+  bool RemoveProperty(NPIdentifier name) {
+    return false;
+  }
+
+  bool Enumerate(NPIdentifier** names,
+                 uint32_t* count) {
+    *names = NULL;
+    *count = 0;
+    return true;
+  }
+
+  bool Construct(const NPVariant* args,
+                 uint32_t num_args,
+                 NPVariant* result) {
+    return false;
+  }
+
+  static BaseNPDispatcher* GetDispatcherChain() {
+    return NULL;
+  }
+
+ protected:
+  DefaultNPObject() {}
+  virtual ~DefaultNPObject() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DefaultNPObject);
+};
+}  // namespace gpu_plugin
+}  // namespace o3d
+
+#endif  // O3D_GPU_PLUGIN_NP_UTILS_DEFAULT_NP_OBJECT_H_
diff --git a/o3d/gpu_plugin/np_utils/dispatched_np_object.cc b/o3d/gpu_plugin/np_utils/dispatched_np_object.cc
deleted file mode 100644
index 9f82e31..0000000
--- a/o3d/gpu_plugin/np_utils/dispatched_np_object.cc
+++ /dev/null
@@ -1,76 +0,0 @@
-// 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/dispatched_np_object.h"
-
-namespace o3d {
-namespace gpu_plugin {
-
-DispatchedNPObject::DispatchedNPObject(NPP npp)
-    : BaseNPObject(npp) {
-}
-
-bool DispatchedNPObject::HasMethod(NPIdentifier name) {
-  for (BaseNPDispatcher* dispatcher = GetDynamicDispatcherChain();
-       dispatcher;
-       dispatcher = dispatcher->next()) {
-    if (dispatcher->name() == name) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool DispatchedNPObject::Invoke(NPIdentifier name,
-                                const NPVariant* args,
-                                uint32_t num_args,
-                                NPVariant* result) {
-  VOID_TO_NPVARIANT(*result);
-
-  for (BaseNPDispatcher* dispatcher = GetDynamicDispatcherChain();
-       dispatcher;
-       dispatcher = dispatcher->next()) {
-    if (dispatcher->name() == name && dispatcher->num_args() == num_args) {
-      if (dispatcher->Invoke(this, args, num_args, result))
-        return true;
-    }
-  }
-
-  return false;
-}
-
-bool DispatchedNPObject::Enumerate(NPIdentifier** names, uint32_t* num_names) {
-  // Count the number of names.
-  *num_names = 0;
-  for (BaseNPDispatcher* dispatcher = GetDynamicDispatcherChain();
-       dispatcher;
-       dispatcher = dispatcher->next()) {
-    ++(*num_names);
-  }
-
-  // Copy names into the array.
-  *names = static_cast<NPIdentifier*>(
-      NPBrowser::get()->MemAlloc((*num_names) * sizeof(**names)));
-  int i = 0;
-  for (BaseNPDispatcher* dispatcher = GetDynamicDispatcherChain();
-       dispatcher;
-       dispatcher = dispatcher->next()) {
-    (*names)[i] = dispatcher->name();
-    ++i;
-  }
-
-  return true;
-}
-
-BaseNPDispatcher* DispatchedNPObject::GetStaticDispatcherChain() {
-  return NULL;
-}
-
-BaseNPDispatcher* DispatchedNPObject::GetDynamicDispatcherChain() {
-  return NULL;
-}
-
-}  // namespace gpu_plugin
-}  // namespace o3d
diff --git a/o3d/gpu_plugin/np_utils/dispatched_np_object.h b/o3d/gpu_plugin/np_utils/dispatched_np_object.h
deleted file mode 100644
index f2e016d5..0000000
--- a/o3d/gpu_plugin/np_utils/dispatched_np_object.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// 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.
-
-#ifndef O3D_GPU_PLUGIN_NP_UTILS_DISPATCHED_NP_OBJECT_H_
-#define O3D_GPU_PLUGIN_NP_UTILS_DISPATCHED_NP_OBJECT_H_
-
-#include "o3d/gpu_plugin/np_utils/base_np_object.h"
-#include "o3d/gpu_plugin/np_utils/np_dispatcher.h"
-
-namespace o3d {
-namespace gpu_plugin {
-
-class BaseNPDispatcher;
-
-// DispatchedNPObject is a base class for NPObjects that automatically make
-// their regular member functions available as NPObject methods. Usage:
-//
-// class MyNPObject : public DispatchedNPObject {
-//  public:
-//   int MyMethod(bool a, float b);
-//  protected:
-//   NP_UTILS_BEGIN_DISPATCHER_CHAIN(MyNPObject, DispatchedNPObject)
-//     NP_UTILS_DISPATCHER(MyMethod, int(bool, float))
-//   NP_UTILS_END_DISPATCHER_CHAIN
-// };
-//
-// Multiple member functions may be listed in the dispatcher chain. Inheritance
-// is supported. The following types are supported as return types and parameter
-// types:
-//   * bool
-//   * int
-//   * float
-//   * double
-//   * std::string
-//   * NPObject*
-//
-class DispatchedNPObject : public BaseNPObject {
- public:
-  explicit DispatchedNPObject(NPP npp);
-
-  // Returns whether a method with the given name is present in the dispatcher
-  // chain.
-  virtual bool HasMethod(NPIdentifier name);
-
-  // Search through dispatcher chain from most derived to least derived. If
-  // a member function with the same name and number of parameters is found,
-  // attempt to invoke it and return whether the invocation was successful.
-  virtual bool Invoke(NPIdentifier name,
-                      const NPVariant* args,
-                      uint32_t num_args,
-                      NPVariant* result);
-
-  // Return the names of all the methods int he dispatcher chain.
-  virtual bool Enumerate(NPIdentifier** names, uint32_t* num_names);
-
- protected:
-  // Get the dispatcher chain for this class and all its superclasses.
-  static BaseNPDispatcher* GetStaticDispatcherChain();
-
-  // Get the dispatcher chain for this object.
-  virtual BaseNPDispatcher* GetDynamicDispatcherChain();
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DispatchedNPObject);
-};
-
-}  // namespace gpu_plugin
-}  // namespace o3d
-
-#endif  // O3D_GPU_PLUGIN_NP_UTILS_DISPATCHED_NP_OBJECT_H_
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 c8ad480..b42eeaf 100644
--- a/o3d/gpu_plugin/np_utils/dispatched_np_object_unittest.cc
+++ b/o3d/gpu_plugin/np_utils/dispatched_np_object_unittest.cc
@@ -4,9 +4,10 @@
 
 #include <string>
 
-#include "o3d/gpu_plugin/np_utils/dispatched_np_object.h"
+#include "o3d/gpu_plugin/np_utils/default_np_object.h"
 #include "o3d/gpu_plugin/np_utils/np_browser_stub.h"
 #include "o3d/gpu_plugin/np_utils/np_dispatcher.h"
+#include "o3d/gpu_plugin/np_utils/np_object_mock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -19,10 +20,9 @@ namespace gpu_plugin {
 // This mock class has a dispatcher chain with an entry for each mocked
 // function. The tests that follow that invoking an NPAPI method calls the
 // corresponding mocked member function.
-class MockDispatchedNPObject : public DispatchedNPObject {
+class MockDispatchedNPObject : public DefaultNPObject<NPObject> {
  public:
-  explicit MockDispatchedNPObject(NPP npp)
-      : DispatchedNPObject(npp) {
+  explicit MockDispatchedNPObject(NPP npp) {
   }
 
   MOCK_METHOD0(VoidReturnNoParams, void());
@@ -31,7 +31,7 @@ class MockDispatchedNPObject : public DispatchedNPObject {
   MOCK_METHOD1(VoidReturnFloatParam, void(float));
   MOCK_METHOD1(VoidReturnDoubleParam, void(double));
   MOCK_METHOD1(VoidReturnStringParam, void(std::string));
-  MOCK_METHOD1(VoidReturnObjectParam, void(NPObjectPointer<BaseNPObject>));
+  MOCK_METHOD1(VoidReturnObjectParam, void(NPObjectPointer<NPObject>));
   MOCK_METHOD2(VoidReturnTwoParams, void(bool, int));
   MOCK_METHOD0(Overloaded, void());
   MOCK_METHOD1(Overloaded, void(bool));
@@ -41,18 +41,16 @@ class MockDispatchedNPObject : public DispatchedNPObject {
   MOCK_METHOD0(FloatReturn, float());
   MOCK_METHOD0(DoubleReturn, double());
   MOCK_METHOD0(StringReturn, std::string());
-  MOCK_METHOD0(ObjectReturn, NPObjectPointer<BaseNPObject>());
+  MOCK_METHOD0(ObjectReturn, NPObjectPointer<NPObject>());
 
- protected:
-  NP_UTILS_BEGIN_DISPATCHER_CHAIN(MockDispatchedNPObject, DispatchedNPObject)
+  NP_UTILS_BEGIN_DISPATCHER_CHAIN(MockDispatchedNPObject, DefaultNPObject<NPObject>)
     NP_UTILS_DISPATCHER(VoidReturnNoParams, void())
     NP_UTILS_DISPATCHER(VoidReturnBoolParam, void(bool))
     NP_UTILS_DISPATCHER(VoidReturnIntParam, void(int))
     NP_UTILS_DISPATCHER(VoidReturnFloatParam, void(float))
     NP_UTILS_DISPATCHER(VoidReturnDoubleParam, void(double))
     NP_UTILS_DISPATCHER(VoidReturnStringParam, void(std::string))
-    NP_UTILS_DISPATCHER(VoidReturnObjectParam,
-        void(NPObjectPointer<BaseNPObject>))
+    NP_UTILS_DISPATCHER(VoidReturnObjectParam, void(NPObjectPointer<NPObject>))
     NP_UTILS_DISPATCHER(VoidReturnTwoParams, void(bool, int))
     NP_UTILS_DISPATCHER(Overloaded, void())
     NP_UTILS_DISPATCHER(Overloaded, void(bool))
@@ -62,7 +60,7 @@ class MockDispatchedNPObject : public DispatchedNPObject {
     NP_UTILS_DISPATCHER(FloatReturn, float())
     NP_UTILS_DISPATCHER(DoubleReturn, double())
     NP_UTILS_DISPATCHER(StringReturn, std::string())
-    NP_UTILS_DISPATCHER(ObjectReturn, NPObjectPointer<BaseNPObject>());
+    NP_UTILS_DISPATCHER(ObjectReturn, NPObjectPointer<NPObject>());
   NP_UTILS_END_DISPATCHER_CHAIN
 };
 
@@ -70,7 +68,7 @@ class DispatchedNPObjectTest : public testing::Test {
  protected:
   virtual void SetUp() {
     object_ = NPCreateObject<StrictMock<MockDispatchedNPObject> >(NULL);
-    passed_object_ = NPCreateObject<BaseNPObject>(NULL);
+    passed_object_ = NPCreateObject<MockNPObject>(NULL);
 
     for (int i = 0; i != arraysize(args_); ++i) {
       NULL_TO_NPVARIANT(args_[i]);
@@ -82,7 +80,7 @@ class DispatchedNPObjectTest : public testing::Test {
   NPVariant args_[3];
   NPVariant result_;
   NPObjectPointer<MockDispatchedNPObject> object_;
-  NPObjectPointer<BaseNPObject> passed_object_;
+  NPObjectPointer<NPObject> passed_object_;
 };
 
 TEST_F(DispatchedNPObjectTest, CannotInvokeMissingFunction) {
@@ -222,7 +220,7 @@ TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnObjectParamWithObject) {
 TEST_F(DispatchedNPObjectTest, CanInvokeVoidReturnObjectParamWithNull) {
   EXPECT_CALL(
       *object_,
-      VoidReturnObjectParam(NPObjectPointer<BaseNPObject>()));
+      VoidReturnObjectParam(NPObjectPointer<NPObject>()));
 
   NULL_TO_NPVARIANT(args_[0]);
 
@@ -367,7 +365,7 @@ TEST_F(DispatchedNPObjectTest, CanInvokeObjectReturnWithObject) {
 
 TEST_F(DispatchedNPObjectTest, CanInvokeObjectReturnWithNull) {
   EXPECT_CALL(*object_, ObjectReturn())
-      .WillOnce(Return(NPObjectPointer<BaseNPObject>()));
+      .WillOnce(Return(NPObjectPointer<NPObject>()));
 
   EXPECT_TRUE(object_->Invoke(
       NPBrowser::get()->GetStringIdentifier("objectReturn"),
diff --git a/o3d/gpu_plugin/np_utils/dynamic_np_object.cc b/o3d/gpu_plugin/np_utils/dynamic_np_object.cc
index 3471e09..19ed6c8 100644
--- a/o3d/gpu_plugin/np_utils/dynamic_np_object.cc
+++ b/o3d/gpu_plugin/np_utils/dynamic_np_object.cc
@@ -7,7 +7,7 @@
 namespace o3d {
 namespace gpu_plugin {
 
-DynamicNPObject::DynamicNPObject(NPP npp) : BaseNPObject(npp) {
+DynamicNPObject::DynamicNPObject(NPP npp) {
 }
 
 void DynamicNPObject::Invalidate() {
diff --git a/o3d/gpu_plugin/np_utils/dynamic_np_object.h b/o3d/gpu_plugin/np_utils/dynamic_np_object.h
index a6b2cf9..0c0bde0 100644
--- a/o3d/gpu_plugin/np_utils/dynamic_np_object.h
+++ b/o3d/gpu_plugin/np_utils/dynamic_np_object.h
@@ -7,7 +7,7 @@
 
 #include <map>
 
-#include "o3d/gpu_plugin/np_utils/base_np_object.h"
+#include "o3d/gpu_plugin/np_utils/default_np_object.h"
 #include "o3d/gpu_plugin/np_utils/np_utils.h"
 
 namespace o3d {
@@ -15,16 +15,16 @@ namespace gpu_plugin {
 
 // NPObjects of this type have a dictionary of property name / variant pairs
 // that can be changed at runtime through NPAPI.
-class DynamicNPObject : public BaseNPObject {
+class DynamicNPObject : public DefaultNPObject<NPObject> {
  public:
   explicit DynamicNPObject(NPP npp);
 
-  virtual void Invalidate();
-  virtual bool HasProperty(NPIdentifier name);
-  virtual bool GetProperty(NPIdentifier name, NPVariant* result);
-  virtual bool SetProperty(NPIdentifier name, const NPVariant* value);
-  virtual bool RemoveProperty(NPIdentifier name);
-  virtual bool Enumerate(NPIdentifier** names, uint32_t* count);
+  void Invalidate();
+  bool HasProperty(NPIdentifier name);
+  bool GetProperty(NPIdentifier name, NPVariant* result);
+  bool SetProperty(NPIdentifier name, const NPVariant* value);
+  bool RemoveProperty(NPIdentifier name);
+  bool Enumerate(NPIdentifier** names, uint32_t* count);
 
  private:
   typedef std::map<NPIdentifier, SmartNPVariant> PropertyMap;
diff --git a/o3d/gpu_plugin/np_utils/np_class.h b/o3d/gpu_plugin/np_utils/np_class.h
new file mode 100644
index 0000000..cdf19d5
--- /dev/null
+++ b/o3d/gpu_plugin/np_utils/np_class.h
@@ -0,0 +1,128 @@
+// 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.
+
+#ifndef O3D_GPU_PLUGIN_NP_UTILS_NP_CLASS_H_
+#define O3D_GPU_PLUGIN_NP_UTILS_NP_CLASS_H_
+
+#include "o3d/gpu_plugin/np_utils/np_object_pointer.h"
+#include "third_party/npapi/bindings/npapi.h"
+#include "third_party/npapi/bindings/npruntime.h"
+
+// This file implements NPGetClass<T>. This function returns an NPClass
+// that can be used to instantiate an NPObject subclass T. The NPClass
+// function pointers will invoke the most derived corresponding member
+// functions in T.
+
+namespace o3d {
+namespace gpu_plugin {
+
+namespace np_class_impl {
+  // This template version of the NPClass allocate function creates a subclass
+  // of BaseNPObject.
+  template <typename NPObjectType>
+  static NPObject* Allocate(NPP npp, NPClass*) {
+    return new NPObjectType(npp);
+  }
+
+  // These implementations of the NPClass functions forward to the virtual
+  // functions in DefaultNPObject.
+  template <typename NPObjectType>
+  static void Deallocate(NPObject* object) {
+    delete static_cast<NPObjectType*>(object);
+  }
+
+  template <typename NPObjectType>
+  static void Invalidate(NPObject* object) {
+    return static_cast<NPObjectType*>(object)->Invalidate();
+  }
+
+  template <typename NPObjectType>
+  static bool HasMethod(NPObject* object, NPIdentifier name) {
+    return static_cast<NPObjectType*>(object)->HasMethod(name);
+  }
+
+  template <typename NPObjectType>
+  static bool Invoke(NPObject* object,
+                     NPIdentifier name,
+                     const NPVariant* args,
+                     uint32_t num_args,
+                     NPVariant* result) {
+    return static_cast<NPObjectType*>(object)->Invoke(
+        name, args, num_args, result);
+  }
+
+  template <typename NPObjectType>
+  static bool InvokeDefault(NPObject* object,
+                            const NPVariant* args,
+                            uint32_t num_args,
+                            NPVariant* result) {
+    return static_cast<NPObjectType*>(object)->InvokeDefault(
+        args, num_args, result);
+  }
+
+  template <typename NPObjectType>
+  static bool HasProperty(NPObject* object, NPIdentifier name) {
+    return static_cast<NPObjectType*>(object)->HasProperty(name);
+  }
+
+  template <typename NPObjectType>
+  static bool GetProperty(NPObject* object,
+                          NPIdentifier name,
+                          NPVariant* result) {
+    return static_cast<NPObjectType*>(object)->GetProperty(name, result);
+  }
+
+  template <typename NPObjectType>
+  static bool SetProperty(NPObject* object,
+                              NPIdentifier name,
+                              const NPVariant* value) {
+    return static_cast<NPObjectType*>(object)->SetProperty(name, value);
+  }
+
+  template <typename NPObjectType>
+  static bool RemoveProperty(NPObject* object, NPIdentifier name) {
+    return static_cast<NPObjectType*>(object)->RemoveProperty(name);
+  }
+
+  template <typename NPObjectType>
+  static bool Enumerate(NPObject* object,
+                            NPIdentifier** names,
+                            uint32_t* count) {
+    return static_cast<NPObjectType*>(object)->Enumerate(names, count);
+  };
+
+  template <typename NPObjectType>
+  static bool Construct(NPObject* object,
+                            const NPVariant* args,
+                            uint32_t num_args,
+                            NPVariant* result) {
+    return static_cast<NPObjectType*>(object)->Construct(
+        args, num_args, result);
+  }
+}  // namespace np_class_impl;
+
+template <typename NPObjectType>
+const NPClass* NPGetClass() {
+  static const NPClass np_class = {
+    NP_CLASS_STRUCT_VERSION,
+    np_class_impl::Allocate<NPObjectType>,
+    np_class_impl::Deallocate<NPObjectType>,
+    np_class_impl::Invalidate<NPObjectType>,
+    np_class_impl::HasMethod<NPObjectType>,
+    np_class_impl::Invoke<NPObjectType>,
+    np_class_impl::InvokeDefault<NPObjectType>,
+    np_class_impl::HasProperty<NPObjectType>,
+    np_class_impl::GetProperty<NPObjectType>,
+    np_class_impl::SetProperty<NPObjectType>,
+    np_class_impl::RemoveProperty<NPObjectType>,
+    np_class_impl::Enumerate<NPObjectType>,
+    np_class_impl::Construct<NPObjectType>,
+  };
+  return &np_class;
+};
+
+}  // namespace gpu_plugin
+}  // namespace o3d
+
+#endif  // O3D_GPU_PLUGIN_NP_UTILS_NP_CLASS_H_
diff --git a/o3d/gpu_plugin/np_utils/base_np_object_unittest.cc b/o3d/gpu_plugin/np_utils/np_class_unittest.cc
index b7e1e9f..33ef2af 100644
--- a/o3d/gpu_plugin/np_utils/base_np_object_unittest.cc
+++ b/o3d/gpu_plugin/np_utils/np_class_unittest.cc
@@ -2,8 +2,8 @@
 // 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/base_np_object.h"
+#include "o3d/gpu_plugin/np_utils/np_class.h"
+#include "o3d/gpu_plugin/np_utils/np_object_mock.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -12,22 +12,17 @@ using testing::StrictMock;
 namespace o3d {
 namespace gpu_plugin {
 
-class BaseNPObjectTest : public testing::Test {
+class NPClassTest : public testing::Test {
  protected:
   virtual void SetUp() {
-    np_class = BaseNPObject::GetNPClass<StrictMock<MockBaseNPObject> >();
+    np_class = NPGetClass<StrictMock<MockNPObject> >();
 
     // Dummy identifier is never used with real NPAPI so it can point to
     // anything.
     identifier = this;
-
-    // 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_;
@@ -37,22 +32,16 @@ class BaseNPObjectTest : public testing::Test {
   NPVariant result;
 };
 
-
-TEST_F(BaseNPObjectTest, AllocateAndDeallocateObject) {
-  EXPECT_EQ(0, MockBaseNPObject::count());
-
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, AllocateAndDeallocateObject) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
   EXPECT_TRUE(NULL != object);
 
-  EXPECT_EQ(1, MockBaseNPObject::count());
-
   np_class->deallocate(object);
-  EXPECT_EQ(0, MockBaseNPObject::count());
 }
 
-TEST_F(BaseNPObjectTest, InvalidateForwards) {
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, InvalidateForwards) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
 
   EXPECT_CALL(*object, Invalidate());
@@ -61,8 +50,8 @@ TEST_F(BaseNPObjectTest, InvalidateForwards) {
   np_class->deallocate(object);
 }
 
-TEST_F(BaseNPObjectTest, HasMethodForwards) {
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, HasMethodForwards) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
 
   EXPECT_CALL(*object, HasMethod(identifier));
@@ -71,8 +60,8 @@ TEST_F(BaseNPObjectTest, HasMethodForwards) {
   np_class->deallocate(object);
 }
 
-TEST_F(BaseNPObjectTest, InvokeForwards) {
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, InvokeForwards) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
 
   EXPECT_CALL(*object, Invoke(identifier, args, 3, &result));
@@ -81,8 +70,8 @@ TEST_F(BaseNPObjectTest, InvokeForwards) {
   np_class->deallocate(object);
 }
 
-TEST_F(BaseNPObjectTest, InvokeDefaultForwards) {
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, InvokeDefaultForwards) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
 
   EXPECT_CALL(*object, InvokeDefault(args, 3, &result));
@@ -91,8 +80,8 @@ TEST_F(BaseNPObjectTest, InvokeDefaultForwards) {
   np_class->deallocate(object);
 }
 
-TEST_F(BaseNPObjectTest, HasPropertyForwards) {
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, HasPropertyForwards) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
 
   EXPECT_CALL(*object, HasProperty(identifier));
@@ -101,8 +90,8 @@ TEST_F(BaseNPObjectTest, HasPropertyForwards) {
   np_class->deallocate(object);
 }
 
-TEST_F(BaseNPObjectTest, GetPropertyForwards) {
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, GetPropertyForwards) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
 
   EXPECT_CALL(*object, GetProperty(identifier, &result));
@@ -111,8 +100,8 @@ TEST_F(BaseNPObjectTest, GetPropertyForwards) {
   np_class->deallocate(object);
 }
 
-TEST_F(BaseNPObjectTest, SetPropertyForwards) {
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, SetPropertyForwards) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
 
   EXPECT_CALL(*object, SetProperty(identifier, &result));
@@ -121,8 +110,8 @@ TEST_F(BaseNPObjectTest, SetPropertyForwards) {
   np_class->deallocate(object);
 }
 
-TEST_F(BaseNPObjectTest, RemovePropertyForwards) {
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, RemovePropertyForwards) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
 
   EXPECT_CALL(*object, RemoveProperty(identifier));
@@ -131,8 +120,8 @@ TEST_F(BaseNPObjectTest, RemovePropertyForwards) {
   np_class->deallocate(object);
 }
 
-TEST_F(BaseNPObjectTest, EnumerateForwards) {
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, EnumerateForwards) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
 
   NPIdentifier* identifier = NULL;
@@ -143,8 +132,8 @@ TEST_F(BaseNPObjectTest, EnumerateForwards) {
   np_class->deallocate(object);
 }
 
-TEST_F(BaseNPObjectTest, ConstructForwards) {
-  MockBaseNPObject* object = static_cast<MockBaseNPObject*>(
+TEST_F(NPClassTest, ConstructForwards) {
+  MockNPObject* object = static_cast<MockNPObject*>(
       np_class->allocate(&npp_, const_cast<NPClass*>(np_class)));
 
   EXPECT_CALL(*object, Construct(args, 3, &result));
diff --git a/o3d/gpu_plugin/np_utils/np_dispatcher.cc b/o3d/gpu_plugin/np_utils/np_dispatcher.cc
new file mode 100644
index 0000000..a5b1387
--- /dev/null
+++ b/o3d/gpu_plugin/np_utils/np_dispatcher.cc
@@ -0,0 +1,87 @@
+// 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/np_dispatcher.h"
+
+namespace o3d {
+namespace gpu_plugin {
+
+bool DispatcherHasMethodHelper(BaseNPDispatcher* chain,
+                               NPObject* object,
+                               NPIdentifier name) {
+  for (BaseNPDispatcher* dispatcher = chain;
+       dispatcher;
+       dispatcher = dispatcher->next()) {
+    if (dispatcher->name() == name) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool DispatcherInvokeHelper(BaseNPDispatcher* chain,
+                            NPObject* object,
+                            NPIdentifier name,
+                            const NPVariant* args,
+                            uint32_t num_args,
+                            NPVariant* result) {
+  VOID_TO_NPVARIANT(*result);
+
+  for (BaseNPDispatcher* dispatcher = chain;
+       dispatcher;
+       dispatcher = dispatcher->next()) {
+    if (dispatcher->name() == name && dispatcher->num_args() == num_args) {
+      if (dispatcher->Invoke(object, args, num_args, result))
+        return true;
+    }
+  }
+
+  return false;
+}
+
+bool DispatcherEnumerateHelper(BaseNPDispatcher* chain,
+                               NPObject* object,
+                               NPIdentifier** names,
+                               uint32_t* num_names) {
+  // Count the number of names.
+  *num_names = 0;
+  for (BaseNPDispatcher* dispatcher = chain;
+       dispatcher;
+       dispatcher = dispatcher->next()) {
+    ++(*num_names);
+  }
+
+  // Copy names into the array.
+  *names = static_cast<NPIdentifier*>(
+      NPBrowser::get()->MemAlloc((*num_names) * sizeof(**names)));
+  int i = 0;
+  for (BaseNPDispatcher* dispatcher = chain;
+       dispatcher;
+       dispatcher = dispatcher->next()) {
+    (*names)[i] = dispatcher->name();
+    ++i;
+  }
+
+  return true;
+}
+
+BaseNPDispatcher::BaseNPDispatcher(BaseNPDispatcher* next, const NPUTF8* name)
+    : next_(next) {
+  // Convert first character to lower case if it is the ASCII range.
+  // TODO(apatrick): do this correctly for non-ASCII characters.
+  std::string java_script_style_name(name);
+  if (isupper(java_script_style_name[0])) {
+    java_script_style_name[0] = tolower(java_script_style_name[0]);
+  }
+
+  name_ = NPBrowser::get()->GetStringIdentifier(
+      java_script_style_name.c_str());
+}
+
+BaseNPDispatcher::~BaseNPDispatcher() {
+}
+
+}  // namespace gpu_plugin
+}  // namespace o3d
diff --git a/o3d/gpu_plugin/np_utils/np_dispatcher.h b/o3d/gpu_plugin/np_utils/np_dispatcher.h
index 0f55d09..023fcc2 100644
--- a/o3d/gpu_plugin/np_utils/np_dispatcher.h
+++ b/o3d/gpu_plugin/np_utils/np_dispatcher.h
@@ -11,17 +11,38 @@
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 
-// These macros are used to make dispatcher chains. See the comment for the
-// DispatchedNPObject class.
+// Dispatchers make regular member functions available as NPObject methods.
+// Usage:
+//
+// class MyNPObject : public DefaultNPObject<NPObject> {
+//  public:
+//   int MyMethod(bool a, float b);
+//   NP_UTILS_BEGIN_DISPATCHER_CHAIN(MyNPObject, DispatchedNPObject)
+//     NP_UTILS_DISPATCHER(MyMethod, int(bool, float))
+//   NP_UTILS_END_DISPATCHER_CHAIN
+// };
+//
+// Multiple member functions may be listed in the dispatcher chain. Inheritance
+// is supported. The following types are supported as return types and parameter
+// types:
+//   * bool
+//   * int
+//   * float
+//   * double
+//   * std::string
+//   * NPObject*
+//
+
+// These macros are used to make dispatcher chains.
 #define NP_UTILS_NP_UTILS_DISPATCHER_JOIN2(a, b) a ## b
 #define NP_UTILS_DISPATCHER_JOIN(a, b) NP_UTILS_NP_UTILS_DISPATCHER_JOIN2(a, b)
 #define NP_UTILS_DISPATCHER_UNIQUE                                             \
   NP_UTILS_DISPATCHER_JOIN(dispatcher, __LINE__)
 
 #define NP_UTILS_BEGIN_DISPATCHER_CHAIN(Class, BaseClass)                      \
-  static BaseNPDispatcher* GetStaticDispatcherChain() {                        \
+  static BaseNPDispatcher* GetDispatcherChain() {                              \
     typedef Class ThisClass;                                                   \
-    BaseNPDispatcher* top_dispatcher = BaseClass::GetStaticDispatcherChain();  \
+    BaseNPDispatcher* top_dispatcher = BaseClass::GetDispatcherChain();        \
 
 #define NP_UTILS_DISPATCHER(name, Signature)                                   \
     static NPDispatcher<ThisClass, Signature>                                  \
@@ -34,9 +55,25 @@
 #define NP_UTILS_END_DISPATCHER_CHAIN                                          \
     return top_dispatcher;                                                     \
   }                                                                            \
-  virtual BaseNPDispatcher* GetDynamicDispatcherChain() {                      \
-    static BaseNPDispatcher* top_dispatcher = GetStaticDispatcherChain();      \
-    return top_dispatcher;                                                     \
+  bool HasMethod(NPIdentifier name) {                                          \
+    return DispatcherHasMethodHelper(GetDispatcherChain(), this, name);        \
+  }                                                                            \
+  bool Invoke(NPIdentifier name,                                               \
+              const NPVariant* args,                                           \
+              uint32_t num_args,                                               \
+              NPVariant* result) {                                             \
+    return DispatcherInvokeHelper(GetDispatcherChain(),                        \
+                                  this,                                        \
+                                  name,                                        \
+                                  args,                                        \
+                                  num_args,                                    \
+                                  result);                                     \
+  }                                                                            \
+  bool Enumerate(NPIdentifier** names, uint32_t* num_names) {                  \
+    return DispatcherEnumerateHelper(GetDispatcherChain(),                     \
+                                     this,                                     \
+                                     names,                                    \
+                                     num_names);                               \
   }                                                                            \
 
 namespace o3d {
@@ -44,21 +81,9 @@ namespace gpu_plugin {
 
 class BaseNPDispatcher {
  public:
-  explicit BaseNPDispatcher(BaseNPDispatcher* next, const NPUTF8* name)
-      : next_(next) {
-    // Convert first character to lower case if it is the ASCII range.
-    // TODO(apatrick): do this correctly for non-ASCII characters.
-    std::string java_script_style_name(name);
-    if (isupper(java_script_style_name[0])) {
-      java_script_style_name[0] = tolower(java_script_style_name[0]);
-    }
-
-    name_ = NPBrowser::get()->GetStringIdentifier(
-        java_script_style_name.c_str());
-  }
+  BaseNPDispatcher(BaseNPDispatcher* next, const NPUTF8* name);
 
-  virtual ~BaseNPDispatcher() {
-  }
+  virtual ~BaseNPDispatcher();
 
   BaseNPDispatcher* next() const {
     return next_;
@@ -81,6 +106,22 @@ class BaseNPDispatcher {
   DISALLOW_COPY_AND_ASSIGN(BaseNPDispatcher);
 };
 
+bool DispatcherHasMethodHelper(BaseNPDispatcher* chain,
+                               NPObject* object,
+                               NPIdentifier name);
+
+bool DispatcherInvokeHelper(BaseNPDispatcher* chain,
+                            NPObject* object,
+                            NPIdentifier name,
+                            const NPVariant* args,
+                            uint32_t num_args,
+                            NPVariant* result);
+
+bool DispatcherEnumerateHelper(BaseNPDispatcher* chain,
+                               NPObject* object,
+                               NPIdentifier** names,
+                               uint32_t* num_names);
+
 // This class should never be instantiated. It is always specialized. Attempting
 // to instantiate it results in a compilation error. This might mean an
 // attempt to instantiate a dispatcher with more parameters than have been
diff --git a/o3d/gpu_plugin/np_utils/np_dispatcher_specializations.h b/o3d/gpu_plugin/np_utils/np_dispatcher_specializations.h
index 2aa5d3a..62fb8c4 100644
--- a/o3d/gpu_plugin/np_utils/np_dispatcher_specializations.h
+++ b/o3d/gpu_plugin/np_utils/np_dispatcher_specializations.h
@@ -2,8 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// There is deliberately no sentry here. This file is included multiple times,
-// once for each dispatcher specialiation arity.
+// There is deliberately no header guard here. This file is included multiple
+// times, once for each dispatcher specialiation arity. Do not include this
+// file directly. Include np_dispatcher.h instead.
 
 template <typename NPObjectType PARAM_TYPENAMES>
 class NPDispatcher<NPObjectType, void(PARAM_TYPES)>
diff --git a/o3d/gpu_plugin/np_utils/base_np_object_mock.h b/o3d/gpu_plugin/np_utils/np_object_mock.h
index 80ccb4c..7e53262 100644
--- a/o3d/gpu_plugin/np_utils/base_np_object_mock.h
+++ b/o3d/gpu_plugin/np_utils/np_object_mock.h
@@ -2,27 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef O3D_GPU_PLUGIN_NP_UTILS_BASE_NP_OBJECT_MOCK_H_
-#define O3D_GPU_PLUGIN_NP_UTILS_BASE_NP_OBJECT_MOCK_H_
+#ifndef O3D_GPU_PLUGIN_NP_UTILS_NP_OBJECT_MOCK_H_
+#define O3D_GPU_PLUGIN_NP_UTILS_NP_OBJECT_MOCK_H_
 
-#include "o3d/gpu_plugin/np_utils/base_np_object.h"
+#include "third_party/npapi/bindings/npapi.h"
+#include "third_party/npapi/bindings/npruntime.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace o3d {
 namespace gpu_plugin {
 
-class MockBaseNPObject : public BaseNPObject {
+class MockNPObject : public NPObject {
  public:
-  explicit MockBaseNPObject(NPP npp) : BaseNPObject(npp) {
-    ++count_;
-  }
-
-  ~MockBaseNPObject() {
-    --count_;
-  }
-
-  static int count() {
-    return count_;
+  explicit MockNPObject(NPP npp) {
   }
 
   MOCK_METHOD0(Invalidate, void());
@@ -38,10 +30,10 @@ class MockBaseNPObject : public BaseNPObject {
   MOCK_METHOD3(Construct, bool(const NPVariant*, uint32_t, NPVariant*));
 
  private:
-  static int count_;
+  DISALLOW_COPY_AND_ASSIGN(MockNPObject);
 };
 
 }  // namespace gpu_plugin
 }  // namespace o3d
 
-#endif  // O3D_GPU_PLUGIN_NP_UTILS_BASE_NP_OBJECT_MOCK_H_
+#endif  // O3D_GPU_PLUGIN_NP_UTILS_NP_OBJECT_MOCK_H_
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 c1464f7..0cd5081 100644
--- a/o3d/gpu_plugin/np_utils/np_object_pointer_unittest.cc
+++ b/o3d/gpu_plugin/np_utils/np_object_pointer_unittest.cc
@@ -2,7 +2,8 @@
 // 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_class.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_object_pointer.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -14,21 +15,18 @@ using testing::StrictMock;
 namespace o3d {
 namespace gpu_plugin {
 
-class DerivedNPObject : public MockBaseNPObject {
+class DerivedNPObject : public MockNPObject {
  public:
-  explicit DerivedNPObject(NPP npp) : MockBaseNPObject(npp) {
+  explicit DerivedNPObject(NPP npp) : MockNPObject(npp) {
   }
 };
 
 class NPObjectPointerTest : public testing::Test {
  protected:
   virtual void SetUp() {
-    np_class_ = BaseNPObject::GetNPClass<StrictMock<MockBaseNPObject> >();
+    np_class_ = NPGetClass<StrictMock<MockNPObject> >();
 
-    // Make sure no MockBaseNPObject objects exist before test.
-    ASSERT_EQ(0, MockBaseNPObject::count());
-
-    raw_pointer_ = static_cast<MockBaseNPObject*>(
+    raw_pointer_ = static_cast<MockNPObject*>(
       NPBrowser::get()->CreateObject(NULL, np_class_));
 
     raw_derived_pointer_ = static_cast<DerivedNPObject*>(
@@ -38,26 +36,23 @@ class NPObjectPointerTest : public testing::Test {
   virtual void TearDown() {
     NPBrowser::get()->ReleaseObject(raw_pointer_);
     NPBrowser::get()->ReleaseObject(raw_derived_pointer_);
-
-    // Make sure no MockBaseNPObject leaked an object.
-    ASSERT_EQ(0, MockBaseNPObject::count());
   }
 
   StubNPBrowser stub_browser_;
   const NPClass* np_class_;
-  MockBaseNPObject* raw_pointer_;
+  MockNPObject* raw_pointer_;
   DerivedNPObject* raw_derived_pointer_;
 };
 
 TEST_F(NPObjectPointerTest, PointerIsNullByDefault) {
-  NPObjectPointer<MockBaseNPObject> p;
+  NPObjectPointer<MockNPObject> p;
   ASSERT_TRUE(NULL == p.Get());
 }
 
 TEST_F(NPObjectPointerTest, PointerCanBeExplicitlyConstructedFromRawPointer) {
   EXPECT_EQ(1, raw_pointer_->referenceCount);
   {
-    NPObjectPointer<MockBaseNPObject> p(raw_pointer_);
+    NPObjectPointer<MockNPObject> p(raw_pointer_);
     ASSERT_TRUE(raw_pointer_ == p.Get());
     EXPECT_EQ(2, raw_pointer_->referenceCount);
   }
@@ -66,15 +61,15 @@ TEST_F(NPObjectPointerTest, PointerCanBeExplicitlyConstructedFromRawPointer) {
 
 TEST_F(NPObjectPointerTest,
     PointerCanBeExplicitlyConstructedFromNullRawPointer) {
-  NPObjectPointer<MockBaseNPObject> p(NULL);
+  NPObjectPointer<MockNPObject> p(NULL);
   ASSERT_TRUE(NULL == p.Get());
 }
 
 TEST_F(NPObjectPointerTest, PointerCanBeCopyConstructed) {
-  NPObjectPointer<MockBaseNPObject> p1(raw_pointer_);
+  NPObjectPointer<MockNPObject> p1(raw_pointer_);
   EXPECT_EQ(2, raw_pointer_->referenceCount);
   {
-    NPObjectPointer<MockBaseNPObject> p2(p1);
+    NPObjectPointer<MockNPObject> p2(p1);
     ASSERT_TRUE(raw_pointer_ == p2.Get());
     EXPECT_EQ(3, raw_pointer_->referenceCount);
   }
@@ -85,7 +80,7 @@ TEST_F(NPObjectPointerTest, PointerCanBeConstructedFromDerived) {
   NPObjectPointer<DerivedNPObject> p1(raw_derived_pointer_);
   EXPECT_EQ(2, raw_derived_pointer_->referenceCount);
   {
-    NPObjectPointer<MockBaseNPObject> p2(p1);
+    NPObjectPointer<MockNPObject> p2(p1);
     ASSERT_TRUE(raw_derived_pointer_ == p2.Get());
     EXPECT_EQ(3, raw_derived_pointer_->referenceCount);
   }
@@ -94,20 +89,20 @@ TEST_F(NPObjectPointerTest, PointerCanBeConstructedFromDerived) {
 
 TEST_F(NPObjectPointerTest,
     PointerCanBeCopyConstructedFromNull) {
-  NPObjectPointer<MockBaseNPObject> p(NULL);
+  NPObjectPointer<MockNPObject> p(NULL);
   ASSERT_TRUE(NULL == p.Get());
 }
 
 TEST_F(NPObjectPointerTest, PointerCanBeAssigned) {
-  NPObjectPointer<MockBaseNPObject> p1(raw_pointer_);
+  NPObjectPointer<MockNPObject> p1(raw_pointer_);
   EXPECT_EQ(2, raw_pointer_->referenceCount);
   {
-    NPObjectPointer<MockBaseNPObject> p2;
+    NPObjectPointer<MockNPObject> p2;
     p2 = p1;
     ASSERT_TRUE(raw_pointer_ == p2.Get());
     EXPECT_EQ(3, raw_pointer_->referenceCount);
 
-    p2 = NPObjectPointer<MockBaseNPObject>();
+    p2 = NPObjectPointer<MockNPObject>();
     ASSERT_TRUE(NULL == p2.Get());
     EXPECT_EQ(2, raw_pointer_->referenceCount);
 
@@ -119,7 +114,7 @@ TEST_F(NPObjectPointerTest, PointerCanBeAssigned) {
 }
 
 TEST_F(NPObjectPointerTest, PointerCanBeAssignedToSelf) {
-  NPObjectPointer<MockBaseNPObject> p(raw_pointer_);
+  NPObjectPointer<MockNPObject> p(raw_pointer_);
   NPBrowser::get()->ReleaseObject(raw_pointer_);
   EXPECT_EQ(1, raw_pointer_->referenceCount);
   p = p;
@@ -131,12 +126,12 @@ TEST_F(NPObjectPointerTest, PointerCanBeAssignedDerived) {
   NPObjectPointer<DerivedNPObject> p1(raw_derived_pointer_);
   EXPECT_EQ(2, raw_derived_pointer_->referenceCount);
   {
-    NPObjectPointer<MockBaseNPObject> p2;
+    NPObjectPointer<MockNPObject> p2;
     p2 = p1;
     ASSERT_TRUE(raw_derived_pointer_ == p2.Get());
     EXPECT_EQ(3, raw_derived_pointer_->referenceCount);
 
-    p2 = NPObjectPointer<MockBaseNPObject>();
+    p2 = NPObjectPointer<MockNPObject>();
     ASSERT_TRUE(NULL == p2.Get());
     EXPECT_EQ(2, raw_derived_pointer_->referenceCount);
 
@@ -148,7 +143,7 @@ TEST_F(NPObjectPointerTest, PointerCanBeAssignedDerived) {
 }
 
 TEST_F(NPObjectPointerTest, DerivedPointerCanBeAssignedToSelf) {
-  NPObjectPointer<MockBaseNPObject> p1(raw_derived_pointer_);
+  NPObjectPointer<MockNPObject> p1(raw_derived_pointer_);
   NPObjectPointer<DerivedNPObject> p2(raw_derived_pointer_);
   NPBrowser::get()->ReleaseObject(raw_derived_pointer_);
   NPBrowser::get()->ReleaseObject(raw_derived_pointer_);
@@ -160,21 +155,21 @@ TEST_F(NPObjectPointerTest, DerivedPointerCanBeAssignedToSelf) {
 }
 
 TEST_F(NPObjectPointerTest, CanComparePointersForEqual) {
-  NPObjectPointer<MockBaseNPObject> p1(raw_pointer_);
+  NPObjectPointer<MockNPObject> p1(raw_pointer_);
   NPObjectPointer<DerivedNPObject> p2(raw_derived_pointer_);
   EXPECT_TRUE(p1 == p1);
   EXPECT_FALSE(p1 == p2);
   EXPECT_FALSE(p2 == p1);
-  EXPECT_FALSE(p1 == NPObjectPointer<MockBaseNPObject>());
+  EXPECT_FALSE(p1 == NPObjectPointer<MockNPObject>());
 }
 
 TEST_F(NPObjectPointerTest, CanComparePointersForNotEqual) {
-  NPObjectPointer<MockBaseNPObject> p1(raw_pointer_);
+  NPObjectPointer<MockNPObject> p1(raw_pointer_);
   NPObjectPointer<DerivedNPObject> p2(raw_derived_pointer_);
   EXPECT_FALSE(p1 != p1);
   EXPECT_TRUE(p1 != p2);
   EXPECT_TRUE(p2 != p1);
-  EXPECT_TRUE(p1 != NPObjectPointer<MockBaseNPObject>());
+  EXPECT_TRUE(p1 != NPObjectPointer<MockNPObject>());
 }
 
 TEST_F(NPObjectPointerTest, ArrowOperatorCanBeUsedToAccessNPObjectMembers) {
@@ -182,12 +177,12 @@ TEST_F(NPObjectPointerTest, ArrowOperatorCanBeUsedToAccessNPObjectMembers) {
 
   EXPECT_CALL(*raw_pointer_, HasProperty(name)).WillOnce(Return(true));
 
-  NPObjectPointer<MockBaseNPObject> p(raw_pointer_);
+  NPObjectPointer<MockNPObject> p(raw_pointer_);
   EXPECT_TRUE(p->HasProperty(name));
 }
 
 TEST_F(NPObjectPointerTest, StarOperatorReturnsNPObjectReference) {
-  NPObjectPointer<MockBaseNPObject> p(raw_pointer_);
+  NPObjectPointer<MockNPObject> p(raw_pointer_);
   EXPECT_EQ(raw_pointer_, &*p);
 }
 
@@ -195,21 +190,21 @@ TEST_F(NPObjectPointerTest, PointerCanBeConstructedFromReturnedNPObject) {
   NPBrowser::get()->RetainObject(raw_pointer_);
   EXPECT_EQ(2, raw_pointer_->referenceCount);
   {
-    NPObjectPointer<MockBaseNPObject> p(
-      NPObjectPointer<MockBaseNPObject>::FromReturned(raw_pointer_));
+    NPObjectPointer<MockNPObject> p(
+      NPObjectPointer<MockNPObject>::FromReturned(raw_pointer_));
     EXPECT_EQ(2, raw_pointer_->referenceCount);
   }
   EXPECT_EQ(1, raw_pointer_->referenceCount);
 }
 
 TEST_F(NPObjectPointerTest, PointerCanBeConstructedFromReturnedNullNPObject) {
-  NPObjectPointer<MockBaseNPObject> p(
-    NPObjectPointer<MockBaseNPObject>::FromReturned(NULL));
+  NPObjectPointer<MockNPObject> p(
+    NPObjectPointer<MockNPObject>::FromReturned(NULL));
   EXPECT_TRUE(NULL == p.Get());
 }
 
 TEST_F(NPObjectPointerTest, PointerCanBeReturnedAsARawNPObject) {
-  NPObjectPointer<MockBaseNPObject> p(raw_pointer_);
+  NPObjectPointer<MockNPObject> p(raw_pointer_);
   EXPECT_EQ(raw_pointer_, p.ToReturned());
 
   // Check reference count is incremented before return for caller.
@@ -219,7 +214,7 @@ TEST_F(NPObjectPointerTest, PointerCanBeReturnedAsARawNPObject) {
 }
 
 TEST_F(NPObjectPointerTest, NULLPointerCanBeReturnedAsARawNPObject) {
-  NPObjectPointer<MockBaseNPObject> p;
+  NPObjectPointer<MockNPObject> p;
   EXPECT_TRUE(NULL == p.ToReturned());
 }
 
diff --git a/o3d/gpu_plugin/np_utils/np_utils.h b/o3d/gpu_plugin/np_utils/np_utils.h
index baec913..4aee86c 100644
--- a/o3d/gpu_plugin/np_utils/np_utils.h
+++ b/o3d/gpu_plugin/np_utils/np_utils.h
@@ -8,6 +8,7 @@
 #include <string>
 
 #include "o3d/gpu_plugin/np_utils/np_browser.h"
+#include "o3d/gpu_plugin/np_utils/np_class.h"
 #include "o3d/gpu_plugin/np_utils/np_object_pointer.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
@@ -30,7 +31,7 @@ bool NPVariantToValue(NPObjectPointer<T>* value,
     return true;
   } else if (NPVARIANT_IS_OBJECT(variant)) {
     NPObject* object = NPVARIANT_TO_OBJECT(variant);
-    if (object->_class == BaseNPObject::GetNPClass<T>()) {
+    if (object->_class == NPGetClass<T>()) {
       *value = NPObjectPointer<T>(static_cast<T*>(
           NPVARIANT_TO_OBJECT(variant)));
       return true;
@@ -78,7 +79,7 @@ class SmartNPVariant : public NPVariant {
  public:
   SmartNPVariant();
   SmartNPVariant(const SmartNPVariant& rhs);
-  SmartNPVariant(const NPVariant& rhs);
+  explicit SmartNPVariant(const NPVariant& rhs);
 
   template <typename T>
   explicit SmartNPVariant(const T& v) {
@@ -261,7 +262,7 @@ bool NPRemoveProperty(NPP npp,
 
 template <typename NPObjectType>
 NPObjectPointer<NPObjectType> NPCreateObject(NPP npp) {
-  const NPClass* np_class = BaseNPObject::GetNPClass<NPObjectType>();
+  const NPClass* np_class = NPGetClass<NPObjectType>();
   NPObjectType* object = static_cast<NPObjectType*>(
       NPBrowser::get()->CreateObject(npp, np_class));
   return NPObjectPointer<NPObjectType>::FromReturned(object);
diff --git a/o3d/gpu_plugin/np_utils/np_utils_unittest.cc b/o3d/gpu_plugin/np_utils/np_utils_unittest.cc
index 6376153..8b3b5ee 100644
--- a/o3d/gpu_plugin/np_utils/np_utils_unittest.cc
+++ b/o3d/gpu_plugin/np_utils/np_utils_unittest.cc
@@ -2,7 +2,7 @@
 // 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"
@@ -22,16 +22,6 @@ 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_;
@@ -106,7 +96,7 @@ TEST_F(NPUtilsTest, TestStringNPVariantToValue) {
 
 TEST_F(NPUtilsTest, TestObjectNPVariantToValue) {
   NPObjectPointer<NPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
   NPObjectPointer<NPObject> v;
 
   OBJECT_TO_NPVARIANT(object.Get(), variant_);
@@ -130,8 +120,8 @@ TEST_F(NPUtilsTest, TestNullNPVariantToValue) {
 
 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_));
@@ -141,8 +131,8 @@ TEST_F(NPUtilsTest, TestDerivedObjectNPVariantToValue) {
 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_));
@@ -186,7 +176,7 @@ TEST_F(NPUtilsTest, TestStringValueToNPVariant) {
 
 TEST_F(NPUtilsTest, TestObjectValueToNPVariant) {
   NPObjectPointer<NPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
 
   ValueToNPVariant(object, &variant_);
   EXPECT_TRUE(NPVARIANT_IS_OBJECT(variant_));
@@ -202,7 +192,7 @@ TEST_F(NPUtilsTest, TestNullValueToNPVariant) {
 
 TEST_F(NPUtilsTest, CanCopyObjectSmartVariant) {
   NPObjectPointer<NPObject> object =
-      NPCreateObject<StrictMock<MockBaseNPObject> >(NULL);
+      NPCreateObject<StrictMock<MockNPObject> >(NULL);
   EXPECT_EQ(1, object->referenceCount);
   {
     SmartNPVariant v1(object);
@@ -263,8 +253,8 @@ Matcher<const NPVariant&> VariantMatches(const 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));
@@ -274,8 +264,8 @@ TEST_F(NPUtilsTest, CanDetermineIfObjectHasMethod) {
 
 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_);
 
@@ -288,8 +278,8 @@ TEST_F(NPUtilsTest, CanInvokeVoidMethodWithNativeTypes) {
 
 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_);
 
@@ -302,8 +292,8 @@ TEST_F(NPUtilsTest, InvokeVoidMethodCanFail) {
 
 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_);
 
@@ -318,8 +308,8 @@ TEST_F(NPUtilsTest, CanInvokeNonVoidMethodWithNativeTypes) {
 
 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_);
 
@@ -333,8 +323,8 @@ TEST_F(NPUtilsTest, InvokeNonVoidMethodCanFail) {
 
 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_);
 
@@ -348,8 +338,8 @@ TEST_F(NPUtilsTest, InvokeNonVoidMethodFailsIfResultIsIncompatible) {
 
 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));
@@ -359,8 +349,8 @@ TEST_F(NPUtilsTest, CanDetermineIfObjectHasProperty) {
 
 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_);
 
@@ -374,8 +364,8 @@ TEST_F(NPUtilsTest, CanGetPropertyValue) {
 
 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_);
 
@@ -389,8 +379,8 @@ TEST_F(NPUtilsTest, NPGetPropertyReportsFailureIfResultTypeIsDifferent) {
 
 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));
@@ -401,8 +391,8 @@ TEST_F(NPUtilsTest, NPGetPropertyReportsFailureFromGetProperty) {
 
 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));
@@ -412,8 +402,8 @@ TEST_F(NPUtilsTest, CanSetPropertyValue) {
 
 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));
@@ -423,8 +413,8 @@ TEST_F(NPUtilsTest, NPSetPropertyReportsFailureFromSetProperty) {
 
 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));