diff options
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)); |