GPUProcessor uses O3D command buffer service to render to a window....

o3d/gpu_plugin/command_buffer_unittest.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/thread.h"
 #include "o3d/gpu_plugin/command_buffer.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 "o3d/gpu_plugin/system_services/shared_memory_mock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::Return;
 using testing::SetArgumentPointee;
 using testing::StrictMock;
 
 namespace o3d {
 namespace gpu_plugin {
 
 class MockSystemNPObject : public DefaultNPObject<NPObject> {
  public:
   explicit MockSystemNPObject(NPP npp) {
   }
 
-  MOCK_METHOD1(CreateSharedMemory, NPObjectPointer<NPObject>(int32));
+  MOCK_METHOD1(CreateSharedMemory, NPObjectPointer<NPObject>(int32 size));
 
   NP_UTILS_BEGIN_DISPATCHER_CHAIN(MockSystemNPObject, DefaultNPObject<NPObject>)
-    NP_UTILS_DISPATCHER(CreateSharedMemory, NPObjectPointer<NPObject>(int32))
+    NP_UTILS_DISPATCHER(CreateSharedMemory,
+                        NPObjectPointer<NPObject>(int32 size))
   NP_UTILS_END_DISPATCHER_CHAIN
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockSystemNPObject);
 };
 
 class CommandBufferTest : public testing::Test {
  protected:
   virtual void SetUp() {
     command_buffer_ = NPCreateObject<CommandBuffer>(NULL);
@@ skipping 25 matching lines @@
 
   NPObjectPointer<MockSharedMemory> expected_shared_memory =
       NPCreateObject<StrictMock<MockSharedMemory> >(NULL);
 
   EXPECT_CALL(*system_object_.Get(), CreateSharedMemory(1024))
     .WillOnce(Return(expected_shared_memory));
 
   EXPECT_CALL(*expected_shared_memory.Get(), Map())
     .WillOnce(Return(true));
 
-  EXPECT_TRUE(command_buffer_->Initialize(1024));
+  EXPECT_TRUE(command_buffer_->Initialize(256));
   EXPECT_EQ(expected_shared_memory, command_buffer_->GetRingBuffer());
 
   // Cannot reinitialize.
-  EXPECT_FALSE(command_buffer_->Initialize(1024));
+  EXPECT_FALSE(command_buffer_->Initialize(256));
   EXPECT_EQ(expected_shared_memory, command_buffer_->GetRingBuffer());
 }
 
+TEST_F(CommandBufferTest, InitializeFailsIfSizeIsTooBig) {
+  EXPECT_FALSE(command_buffer_->Initialize(0x40000000));
+}
+
 TEST_F(CommandBufferTest, InitializeFailsIfCannotCreateSharedMemory) {
   EXPECT_CALL(mock_browser_, GetWindowNPObject(NULL))
     .WillOnce(Return(window_object_.ToReturned()));
 
   EXPECT_CALL(*system_object_.Get(), CreateSharedMemory(1024))
     .WillOnce(Return(NPObjectPointer<NPObject>()));
 
-  EXPECT_FALSE(command_buffer_->Initialize(1024));
+  EXPECT_FALSE(command_buffer_->Initialize(256));
   EXPECT_EQ(NPObjectPointer<NPObject>(),
             command_buffer_->GetRingBuffer());
 }
 
 TEST_F(CommandBufferTest, InitializeFailsIfCannotMapSharedMemory) {
   EXPECT_CALL(mock_browser_, GetWindowNPObject(NULL))
     .WillOnce(Return(window_object_.ToReturned()));
 
   NPObjectPointer<MockSharedMemory> expected_shared_memory =
       NPCreateObject<StrictMock<MockSharedMemory> >(NULL);
 
   EXPECT_CALL(*system_object_.Get(), CreateSharedMemory(1024))
     .WillOnce(Return(expected_shared_memory));
 
   EXPECT_CALL(*expected_shared_memory.Get(), Map())
     .WillOnce(Return(false));
 
-  EXPECT_FALSE(command_buffer_->Initialize(1024));
+  EXPECT_FALSE(command_buffer_->Initialize(256));
   EXPECT_EQ(NPObjectPointer<NPObject>(),
             command_buffer_->GetRingBuffer());
 }
 
 TEST_F(CommandBufferTest, GetAndPutOffsetsDefaultToZero) {
   EXPECT_EQ(0, command_buffer_->GetGetOffset());
   EXPECT_EQ(0, command_buffer_->GetPutOffset());
 }
 
 class MockCallback : public CallbackRunner<Tuple0> {
  public:
   MOCK_METHOD1(RunWithParams, void(const Tuple0&));
 };
 
 TEST_F(CommandBufferTest, CanSyncGetAndPutOffset) {
   EXPECT_CALL(mock_browser_, GetWindowNPObject(NULL))
     .WillOnce(Return(window_object_.ToReturned()));
 
   NPObjectPointer<MockSharedMemory> expected_shared_memory =
       NPCreateObject<StrictMock<MockSharedMemory> >(NULL);
 
   EXPECT_CALL(*system_object_.Get(), CreateSharedMemory(1024))
     .WillOnce(Return(expected_shared_memory));
 
   EXPECT_CALL(*expected_shared_memory.Get(), Map())
     .WillOnce(Return(true));
 
-  EXPECT_TRUE(command_buffer_->Initialize(1024));
+  EXPECT_TRUE(command_buffer_->Initialize(256));
 
   StrictMock<MockCallback>* put_offset_change_callback =
       new StrictMock<MockCallback>;
   command_buffer_->SetPutOffsetChangeCallback(put_offset_change_callback);
 
   EXPECT_CALL(*put_offset_change_callback, RunWithParams(_));
   EXPECT_EQ(0, command_buffer_->SyncOffsets(2));
   EXPECT_EQ(2, command_buffer_->GetPutOffset());
 
   EXPECT_CALL(*put_offset_change_callback, RunWithParams(_));
   EXPECT_EQ(0, command_buffer_->SyncOffsets(4));
   EXPECT_EQ(4, command_buffer_->GetPutOffset());
 
   command_buffer_->SetGetOffset(2);
   EXPECT_EQ(2, command_buffer_->GetGetOffset());
   EXPECT_CALL(*put_offset_change_callback, RunWithParams(_));
   EXPECT_EQ(2, command_buffer_->SyncOffsets(6));
 
   EXPECT_EQ(-1, command_buffer_->SyncOffsets(-1));
   EXPECT_EQ(-1, command_buffer_->SyncOffsets(1024));
 }
 
 TEST_F(CommandBufferTest, ZeroHandleMapsToNull) {
   EXPECT_TRUE(NULL == command_buffer_->GetRegisteredObject(0).Get());
 }
 
+TEST_F(CommandBufferTest, NegativeHandleMapsToNull) {
+  EXPECT_TRUE(NULL == command_buffer_->GetRegisteredObject(-1).Get());
+}
+
+TEST_F(CommandBufferTest, OutOfRangeHandleMapsToNull) {
+  EXPECT_TRUE(NULL == command_buffer_->GetRegisteredObject(1).Get());
+}
+
 TEST_F(CommandBufferTest, RegisteringNullObjectReturnsZero) {
   EXPECT_EQ(0, command_buffer_->RegisterObject(NPObjectPointer<NPObject>()));
 }
 
 TEST_F(CommandBufferTest, RegistersDistinctNonZeroHandlesForObject) {
   EXPECT_EQ(1, command_buffer_->RegisterObject(window_object_));
   EXPECT_EQ(window_object_, command_buffer_->GetRegisteredObject(1));
   EXPECT_EQ(2, command_buffer_->RegisterObject(window_object_));
   EXPECT_EQ(window_object_, command_buffer_->GetRegisteredObject(2));
 }
@@ skipping 62 matching lines @@
 
 TEST_F(CommandBufferTest, DefaultTokenIsZero) {
   EXPECT_EQ(0, command_buffer_->GetToken());
 }
 
 TEST_F(CommandBufferTest, CanSetToken) {
   command_buffer_->SetToken(7);
   EXPECT_EQ(7, command_buffer_->GetToken());
 }
 
-TEST_F(CommandBufferTest, DefaultErrorIsNoError) {
-  EXPECT_EQ(CommandBuffer::ERROR_NO_ERROR, command_buffer_->ResetError());
+TEST_F(CommandBufferTest, DefaultParseErrorIsNoError) {
+  EXPECT_EQ(0, command_buffer_->ResetParseError());
 }
 
-TEST_F(CommandBufferTest, CanSetAndResetError) {
-  command_buffer_->SetError(CommandBuffer::ERROR_UNKNOWN_COMMAND);
-  EXPECT_EQ(CommandBuffer::ERROR_UNKNOWN_COMMAND,
-      command_buffer_->ResetError());
-  EXPECT_EQ(CommandBuffer::ERROR_NO_ERROR, command_buffer_->ResetError());
+TEST_F(CommandBufferTest, CanSetAndResetParseError) {
+  command_buffer_->SetParseError(1);
+  EXPECT_EQ(1, command_buffer_->ResetParseError());
+  EXPECT_EQ(0, command_buffer_->ResetParseError());
+}
+
+TEST_F(CommandBufferTest, DefaultErrorStatusIsFalse) {
+  EXPECT_FALSE(command_buffer_->GetErrorStatus());
+}
+
+TEST_F(CommandBufferTest, CanRaiseErrorStatus) {
+  command_buffer_->RaiseErrorStatus();
+  EXPECT_TRUE(command_buffer_->GetErrorStatus());
 }
 
 }  // namespace gpu_plugin
 }  // namespace o3d