Added Pepper 3D device that instantiates the GPU plugin and sends GLES2 commands to it via a command buffer.

Added API for managing buffers to Pepper 3D device.

Removed DCHECK from WebPluginImpl::SetWindow that checks against a windowless plugin being given a window handle. Please check this! Now an initially windowless plugin instance gets a handle when it requests a Pepper 3D context. Perhaps the window handle should be concealed from the underlying plugin isntance.

Removed enable_gpu gyp variable and C macro. GPU code is always built on windows but not mac or linux. It is enabled at runtime with the --enable-gpu-plugin switch.

Redesigned CommandBuffer interface so it exposes shared memory through a Buffer. This was necessary because Pepper has no notion of shared memory handles. The Buffer exposes the shared memory as both a handle (through base::SharedMemory) and the mapped address and size.

Refactored CommandBufferEngine so mapped shared memory addresses and sizes are returned with a single call rather than two separate calls.
	
Added 3D demo to pepper test plugin.

TEST=try servers
BUG=none

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

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

11 files changed, 135 insertions, 172 deletions

diff --git a/gpu/command_buffer/service/cmd_buffer_engine.h b/gpu/command_buffer/service/cmd_buffer_engine.h
index 7457a2f..09419a0 100644
--- a/gpu/command_buffer/service/cmd_buffer_engine.h
+++ b/gpu/command_buffer/service/cmd_buffer_engine.h
@@ -9,6 +9,7 @@
 #define GPU_COMMAND_BUFFER_SERVICE_CMD_BUFFER_ENGINE_H_
 
 #include "base/basictypes.h"
+#include "gpu/command_buffer/common/buffer.h"
 
 namespace gpu {
 
@@ -20,15 +21,10 @@ class CommandBufferEngine {
   virtual ~CommandBufferEngine() {
   }
 
-  // Gets the base address of a registered shared memory buffer.
+  // Gets the base address and size of a registered shared memory buffer.
   // Parameters:
   //   shm_id: the identifier for the shared memory buffer.
-  virtual void *GetSharedMemoryAddress(int32 shm_id) = 0;
-
-  // Gets the size of a registered shared memory buffer.
-  // Parameters:
-  //   shm_id: the identifier for the shared memory buffer.
-  virtual size_t GetSharedMemorySize(int32 shm_id) = 0;
+  virtual Buffer GetSharedMemoryBuffer(int32 shm_id) = 0;
 
   // Sets the token value.
   virtual void set_token(int32 token) = 0;
diff --git a/gpu/command_buffer/service/command_buffer_service.cc b/gpu/command_buffer/service/command_buffer_service.cc
index e2dffec..17e7a61 100644
--- a/gpu/command_buffer/service/command_buffer_service.cc
+++ b/gpu/command_buffer/service/command_buffer_service.cc
@@ -6,6 +6,8 @@
 
 #include <limits>
 
+#include "gpu/command_buffer/common/cmd_buffer_common.h"
+
 using ::base::SharedMemory;
 
 namespace gpu {
@@ -24,7 +26,7 @@ CommandBufferService::CommandBufferService()
 CommandBufferService::~CommandBufferService() {
 }
 
-base::SharedMemory* CommandBufferService::Initialize(int32 size) {
+bool CommandBufferService::Initialize(int32 size) {
   // Fail if already initialized.
   if (ring_buffer_.get())
     return false;
@@ -32,17 +34,24 @@ base::SharedMemory* CommandBufferService::Initialize(int32 size) {
   size_ = size;
 
   ring_buffer_.reset(new SharedMemory);
-  if (ring_buffer_->Create(std::wstring(), false, false, size_)) {
-    if (ring_buffer_->Map(size_))
-      return ring_buffer_.get();
+  size_t size_bytes = size * sizeof(CommandBufferEntry);
+  if (ring_buffer_->Create(std::wstring(), false, false, size_bytes)) {
+    if (ring_buffer_->Map(size_bytes))
+      return true;
   }
 
   ring_buffer_.reset();
-  return NULL;
+  return false;
 }
 
-SharedMemory* CommandBufferService::GetRingBuffer() {
-  return ring_buffer_.get();
+Buffer CommandBufferService::GetRingBuffer() {
+  Buffer buffer;
+  if (ring_buffer_.get()) {
+    buffer.ptr = ring_buffer_->memory();
+    buffer.size = ring_buffer_->max_size();
+    buffer.shared_memory = ring_buffer_.get();
+  }
+  return buffer;
 }
 
 int32 CommandBufferService::GetSize() {
@@ -123,14 +132,27 @@ void CommandBufferService::DestroyTransferBuffer(int32 handle) {
   }
 }
 
-::base::SharedMemory* CommandBufferService::GetTransferBuffer(int32 handle) {
+Buffer CommandBufferService::GetTransferBuffer(int32 handle) {
   if (handle < 0)
-    return NULL;
+    return Buffer();
 
   if (static_cast<size_t>(handle) >= registered_objects_.size())
-    return NULL;
+    return Buffer();
+
+  base::SharedMemory* shared_memory = registered_objects_[handle].get();
+  if (!shared_memory)
+    return Buffer();
+
+  if (!shared_memory->memory()) {
+    if (!shared_memory->Map(shared_memory->max_size()))
+      return Buffer();
+  }
 
-  return registered_objects_[handle].get();
+  Buffer buffer;
+  buffer.ptr = shared_memory->memory();
+  buffer.size = shared_memory->max_size();
+  buffer.shared_memory = shared_memory;
+  return buffer;
 }
 
 int32 CommandBufferService::GetToken() {
diff --git a/gpu/command_buffer/service/command_buffer_service.h b/gpu/command_buffer/service/command_buffer_service.h
index 6784581..18860ea 100644
--- a/gpu/command_buffer/service/command_buffer_service.h
+++ b/gpu/command_buffer/service/command_buffer_service.h
@@ -24,8 +24,8 @@ class CommandBufferService : public CommandBuffer {
   virtual ~CommandBufferService();
 
   // CommandBuffer implementation:
-  virtual base::SharedMemory* Initialize(int32 size);
-  virtual base::SharedMemory* GetRingBuffer();
+  virtual bool Initialize(int32 size);
+  virtual Buffer GetRingBuffer();
   virtual int32 GetSize();
   virtual int32 SyncOffsets(int32 put_offset);
   virtual int32 GetGetOffset();
@@ -34,7 +34,7 @@ class CommandBufferService : public CommandBuffer {
   virtual void SetPutOffsetChangeCallback(Callback0::Type* callback);
   virtual int32 CreateTransferBuffer(size_t size);
   virtual void DestroyTransferBuffer(int32 id);
-  virtual base::SharedMemory* GetTransferBuffer(int32 handle);
+  virtual Buffer GetTransferBuffer(int32 handle);
   virtual int32 GetToken();
   virtual void SetToken(int32 token);
   virtual int32 ResetParseError();
diff --git a/gpu/command_buffer/service/command_buffer_service_unittest.cc b/gpu/command_buffer/service/command_buffer_service_unittest.cc
index b5749af..98ec0ec 100644
--- a/gpu/command_buffer/service/command_buffer_service_unittest.cc
+++ b/gpu/command_buffer/service/command_buffer_service_unittest.cc
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "base/thread.h"
+#include "gpu/command_buffer/common/cmd_buffer_common.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -26,20 +27,28 @@ class CommandBufferServiceTest : public testing::Test {
 };
 
 TEST_F(CommandBufferServiceTest, NullRingBufferByDefault) {
-  EXPECT_TRUE(NULL == command_buffer_->GetRingBuffer());
+  EXPECT_TRUE(NULL == command_buffer_->GetRingBuffer().ptr);
 }
 
 TEST_F(CommandBufferServiceTest, InitializesCommandBuffer) {
-  base::SharedMemory* ring_buffer = command_buffer_->Initialize(1024);
-  EXPECT_TRUE(NULL != ring_buffer);
-  EXPECT_EQ(ring_buffer, command_buffer_->GetRingBuffer());
-  EXPECT_GT(command_buffer_->GetSize(), 0);
+  EXPECT_TRUE(command_buffer_->Initialize(1024));
+  EXPECT_TRUE(NULL != command_buffer_->GetRingBuffer().ptr);
+  EXPECT_EQ(1024, command_buffer_->GetSize());
+  EXPECT_EQ(1024 * sizeof(CommandBufferEntry),
+            command_buffer_->GetRingBuffer().size);
+}
+
+TEST_F(CommandBufferServiceTest, InitializationSizeIsInEntriesNotBytes) {
+  EXPECT_TRUE(command_buffer_->Initialize(1024));
+  EXPECT_TRUE(NULL != command_buffer_->GetRingBuffer().ptr);
+  EXPECT_GE(1024 * sizeof(CommandBufferEntry),
+            command_buffer_->GetRingBuffer().size);
 }
 
 TEST_F(CommandBufferServiceTest, InitializeFailsSecondTime) {
   SharedMemory* ring_buffer = new SharedMemory;
-  EXPECT_TRUE(NULL != command_buffer_->Initialize(1024));
-  EXPECT_TRUE(NULL == command_buffer_->Initialize(1024));
+  EXPECT_TRUE(command_buffer_->Initialize(1024));
+  EXPECT_FALSE(command_buffer_->Initialize(1024));
 }
 
 TEST_F(CommandBufferServiceTest, GetAndPutOffsetsDefaultToZero) {
@@ -77,23 +86,23 @@ TEST_F(CommandBufferServiceTest, CanSyncGetAndPutOffset) {
 }
 
 TEST_F(CommandBufferServiceTest, ZeroHandleMapsToNull) {
-  EXPECT_TRUE(NULL == command_buffer_->GetTransferBuffer(0));
+  EXPECT_TRUE(NULL == command_buffer_->GetTransferBuffer(0).ptr);
 }
 
 TEST_F(CommandBufferServiceTest, NegativeHandleMapsToNull) {
-  EXPECT_TRUE(NULL == command_buffer_->GetTransferBuffer(-1));
+  EXPECT_TRUE(NULL == command_buffer_->GetTransferBuffer(-1).ptr);
 }
 
 TEST_F(CommandBufferServiceTest, OutOfRangeHandleMapsToNull) {
-  EXPECT_TRUE(NULL == command_buffer_->GetTransferBuffer(1));
+  EXPECT_TRUE(NULL == command_buffer_->GetTransferBuffer(1).ptr);
 }
 
 TEST_F(CommandBufferServiceTest, CanCreateTransferBuffers) {
   int32 handle = command_buffer_->CreateTransferBuffer(1024);
   EXPECT_EQ(1, handle);
-  SharedMemory* buffer = command_buffer_->GetTransferBuffer(handle);
-  ASSERT_TRUE(NULL != buffer);
-  EXPECT_EQ(1024, buffer->max_size());
+  Buffer buffer = command_buffer_->GetTransferBuffer(handle);
+  ASSERT_TRUE(NULL != buffer.ptr);
+  EXPECT_EQ(1024, buffer.size);
 }
 
 TEST_F(CommandBufferServiceTest, CreateTransferBufferReturnsDistinctHandles) {
@@ -111,7 +120,7 @@ TEST_F(CommandBufferServiceTest,
 
 TEST_F(CommandBufferServiceTest, CannotUnregisterHandleZero) {
   command_buffer_->DestroyTransferBuffer(0);
-  EXPECT_TRUE(NULL == command_buffer_->GetTransferBuffer(0));
+  EXPECT_TRUE(NULL == command_buffer_->GetTransferBuffer(0).ptr);
   EXPECT_EQ(1, command_buffer_->CreateTransferBuffer(1024));
 }
 
diff --git a/gpu/command_buffer/service/common_decoder.cc b/gpu/command_buffer/service/common_decoder.cc
index 591dfb7..4d3623d 100644
--- a/gpu/command_buffer/service/common_decoder.cc
+++ b/gpu/command_buffer/service/common_decoder.cc
@@ -35,14 +35,14 @@ bool CommonDecoder::Bucket::SetData(
 void* CommonDecoder::GetAddressAndCheckSize(unsigned int shm_id,
                                             unsigned int offset,
                                             unsigned int size) {
-  void* shm_addr = engine_->GetSharedMemoryAddress(shm_id);
-  if (!shm_addr) return NULL;
-  size_t shm_size = engine_->GetSharedMemorySize(shm_id);
+  Buffer buffer = engine_->GetSharedMemoryBuffer(shm_id);
+  if (!buffer.ptr)
+    return NULL;
   unsigned int end = offset + size;
-  if (end > shm_size || end < offset) {
+  if (end > buffer.size || end < offset) {
     return NULL;
   }
-  return static_cast<int8 *>(shm_addr) + offset;
+  return static_cast<int8*>(buffer.ptr) + offset;
 }
 
 const char* CommonDecoder::GetCommonCommandName(
diff --git a/gpu/command_buffer/service/common_decoder_unittest.cc b/gpu/command_buffer/service/common_decoder_unittest.cc
index 54f1941..9a2db70 100644
--- a/gpu/command_buffer/service/common_decoder_unittest.cc
+++ b/gpu/command_buffer/service/common_decoder_unittest.cc
@@ -78,13 +78,13 @@ class MockCommandBufferEngine : public CommandBufferEngine {
   }
 
   // Overridden from CommandBufferEngine.
-  virtual void* GetSharedMemoryAddress(int32 shm_id) {
-    return (shm_id == kValidShmId) ? buffer_ : NULL;
-  }
-
-  // Overridden from CommandBufferEngine.
-  virtual size_t GetSharedMemorySize(int32 shm_id) {
-    return (shm_id == kValidShmId) ? kBufferSize : 0;
+  virtual Buffer GetSharedMemoryBuffer(int32 shm_id) {
+    Buffer buffer;
+    if (shm_id == kValidShmId) {
+      buffer.ptr = buffer_;
+      buffer.size = kBufferSize;
+    }
+    return buffer;
   }
 
   template <typename T>
diff --git a/gpu/command_buffer/service/gpu_processor.cc b/gpu/command_buffer/service/gpu_processor.cc
index 61449c0..0968215 100644
--- a/gpu/command_buffer/service/gpu_processor.cc
+++ b/gpu/command_buffer/service/gpu_processor.cc
@@ -20,16 +20,15 @@ void GPUProcessor::ProcessCommands() {
 
   int commands_processed = 0;
   while (commands_processed < commands_per_update_ && !parser_->IsEmpty()) {
-    gpu::parse_error::ParseError parse_error =
-        parser_->ProcessCommand();
+    parse_error::ParseError parse_error = parser_->ProcessCommand();
     switch (parse_error) {
-      case gpu::parse_error::kParseUnknownCommand:
-      case gpu::parse_error::kParseInvalidArguments:
+      case parse_error::kParseUnknownCommand:
+      case parse_error::kParseInvalidArguments:
         command_buffer_->SetParseError(parse_error);
         break;
 
-      case gpu::parse_error::kParseInvalidSize:
-      case gpu::parse_error::kParseOutOfBounds:
+      case parse_error::kParseInvalidSize:
+      case parse_error::kParseOutOfBounds:
         command_buffer_->SetParseError(parse_error);
         command_buffer_->RaiseErrorStatus();
         return;
@@ -46,29 +45,8 @@ void GPUProcessor::ProcessCommands() {
   }
 }
 
-void *GPUProcessor::GetSharedMemoryAddress(int32 shm_id) {
-  ::base::SharedMemory* shared_memory =
-      command_buffer_->GetTransferBuffer(shm_id);
-  if (!shared_memory)
-    return NULL;
-
-  if (!shared_memory->memory()) {
-    if (!shared_memory->Map(shared_memory->max_size()))
-      return NULL;
-  }
-
-  return shared_memory->memory();
-}
-
-// TODO(apatrick): Consolidate this with the above and return both the address
-// and size.
-size_t GPUProcessor::GetSharedMemorySize(int32 shm_id) {
-  ::base::SharedMemory* shared_memory =
-      command_buffer_->GetTransferBuffer(shm_id);
-  if (!shared_memory)
-    return 0;
-
-  return shared_memory->max_size();
+Buffer GPUProcessor::GetSharedMemoryBuffer(int32 shm_id) {
+  return command_buffer_->GetTransferBuffer(shm_id);
 }
 
 void GPUProcessor::set_token(int32 token) {
diff --git a/gpu/command_buffer/service/gpu_processor.h b/gpu/command_buffer/service/gpu_processor.h
index a594f0b..41325fa 100644
--- a/gpu/command_buffer/service/gpu_processor.h
+++ b/gpu/command_buffer/service/gpu_processor.h
@@ -18,8 +18,8 @@ namespace gpu {
 
 // This class processes commands in a command buffer. It is event driven and
 // posts tasks to the current message loop to do additional work.
-class GPUProcessor : public ::base::RefCounted<GPUProcessor>,
-                     public gpu::CommandBufferEngine {
+class GPUProcessor : public base::RefCounted<GPUProcessor>,
+                     public CommandBufferEngine {
  public:
   explicit GPUProcessor(CommandBuffer* command_buffer);
 
@@ -37,21 +37,8 @@ class GPUProcessor : public ::base::RefCounted<GPUProcessor>,
 
   virtual void ProcessCommands();
 
-  virtual bool SetWindow(gfx::PluginWindowHandle handle, int width, int height);
-
   // Implementation of CommandBufferEngine.
-
-  // Gets the base address of a registered shared memory buffer.
-  // Parameters:
-  //   shm_id: the identifier for the shared memory buffer.
-  virtual void *GetSharedMemoryAddress(int32 shm_id);
-
-  // Gets the size of a registered shared memory buffer.
-  // Parameters:
-  //   shm_id: the identifier for the shared memory buffer.
-  virtual size_t GetSharedMemorySize(int32 shm_id);
-
-  // Sets the token value.
+  virtual Buffer GetSharedMemoryBuffer(int32 shm_id);
   virtual void set_token(int32 token);
 
  private:
diff --git a/gpu/command_buffer/service/gpu_processor_mock.h b/gpu/command_buffer/service/gpu_processor_mock.h
index be6a938..ca257e8 100644
--- a/gpu/command_buffer/service/gpu_processor_mock.h
+++ b/gpu/command_buffer/service/gpu_processor_mock.h
@@ -19,11 +19,7 @@ class MockGPUProcessor : public GPUProcessor {
   MOCK_METHOD1(Initialize, bool(gfx::PluginWindowHandle handle));
   MOCK_METHOD0(Destroy, void());
   MOCK_METHOD0(ProcessCommands, void());
-  MOCK_METHOD3(SetWindow, bool(gfx::PluginWindowHandle handle,
-                               int width,
-                               int height));
-  MOCK_METHOD1(GetSharedMemoryAddress, void*(int32 shm_id));
-  MOCK_METHOD1(GetSharedMemorySize, size_t(int32 shm_id));
+  MOCK_METHOD1(GetSharedMemoryBuffer, Buffer(int32 shm_id));
   MOCK_METHOD1(set_token, void(int32 token));
 
  private:
diff --git a/gpu/command_buffer/service/gpu_processor_unittest.cc b/gpu/command_buffer/service/gpu_processor_unittest.cc
index 5041371..304dc72 100644
--- a/gpu/command_buffer/service/gpu_processor_unittest.cc
+++ b/gpu/command_buffer/service/gpu_processor_unittest.cc
@@ -31,25 +31,26 @@ class GPUProcessorTest : public testing::Test {
     shared_memory_->Create(std::wstring(), false, false, kRingBufferSize);
     shared_memory_->Map(kRingBufferSize);
     buffer_ = static_cast<int32*>(shared_memory_->memory());
-
+    shared_memory_buffer_.ptr = buffer_;
+    shared_memory_buffer_.size = kRingBufferSize;
     memset(buffer_, 0, kRingBufferSize);
 
     command_buffer_.reset(new MockCommandBuffer);
     ON_CALL(*command_buffer_.get(), GetRingBuffer())
-      .WillByDefault(Return(shared_memory_.get()));
+      .WillByDefault(Return(shared_memory_buffer_));
     ON_CALL(*command_buffer_.get(), GetSize())
       .WillByDefault(Return(kRingBufferEntries));
 
-    async_api_.reset(new StrictMock<gpu::AsyncAPIMock>);
+    async_api_.reset(new StrictMock<AsyncAPIMock>);
 
     decoder_ = gles2::GLES2Decoder::Create();
 
-    parser_ = new gpu::CommandParser(buffer_,
-                                                kRingBufferEntries,
-                                                0,
-                                                kRingBufferEntries,
-                                                0,
-                                                async_api_.get());
+    parser_ = new CommandParser(buffer_,
+                                kRingBufferEntries,
+                                0,
+                                kRingBufferEntries,
+                                0,
+                                async_api_.get());
 
     processor_ = new GPUProcessor(command_buffer_.get(),
                                   decoder_,
@@ -67,10 +68,11 @@ class GPUProcessorTest : public testing::Test {
   MessageLoop message_loop;
   scoped_ptr<MockCommandBuffer> command_buffer_;
   scoped_ptr<::base::SharedMemory> shared_memory_;
+  Buffer shared_memory_buffer_;
   int32* buffer_;
-  gpu::gles2::GLES2Decoder* decoder_;
-  gpu::CommandParser* parser_;
-  scoped_ptr<gpu::AsyncAPIMock> async_api_;
+  gles2::GLES2Decoder* decoder_;
+  CommandParser* parser_;
+  scoped_ptr<AsyncAPIMock> async_api_;
   scoped_refptr<GPUProcessor> processor_;
 };
 
@@ -81,14 +83,13 @@ TEST_F(GPUProcessorTest, ProcessorDoesNothingIfRingBufferIsEmpty) {
 
   processor_->ProcessCommands();
 
-  EXPECT_EQ(gpu::parse_error::kParseNoError,
+  EXPECT_EQ(parse_error::kParseNoError,
             command_buffer_->ResetParseError());
   EXPECT_FALSE(command_buffer_->GetErrorStatus());
 }
 
 TEST_F(GPUProcessorTest, ProcessesOneCommand) {
-  gpu::CommandHeader* header =
-      reinterpret_cast<gpu::CommandHeader*>(&buffer_[0]);
+  CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 2;
   buffer_[1] = 123;
@@ -98,18 +99,17 @@ TEST_F(GPUProcessorTest, ProcessesOneCommand) {
   EXPECT_CALL(*command_buffer_, SetGetOffset(2));
 
   EXPECT_CALL(*async_api_, DoCommand(7, 1, &buffer_[0]))
-    .WillOnce(Return(gpu::parse_error::kParseNoError));
+    .WillOnce(Return(parse_error::kParseNoError));
 
   processor_->ProcessCommands();
 
-  EXPECT_EQ(gpu::parse_error::kParseNoError,
+  EXPECT_EQ(parse_error::kParseNoError,
             command_buffer_->ResetParseError());
   EXPECT_FALSE(command_buffer_->GetErrorStatus());
 }
 
 TEST_F(GPUProcessorTest, ProcessesTwoCommands) {
-  gpu::CommandHeader* header =
-      reinterpret_cast<gpu::CommandHeader*>(&buffer_[0]);
+  CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 2;
   buffer_[1] = 123;
@@ -121,17 +121,16 @@ TEST_F(GPUProcessorTest, ProcessesTwoCommands) {
   EXPECT_CALL(*command_buffer_, SetGetOffset(3));
 
   EXPECT_CALL(*async_api_, DoCommand(7, 1, &buffer_[0]))
-    .WillOnce(Return(gpu::parse_error::kParseNoError));
+    .WillOnce(Return(parse_error::kParseNoError));
 
   EXPECT_CALL(*async_api_, DoCommand(8, 0, &buffer_[2]))
-    .WillOnce(Return(gpu::parse_error::kParseNoError));
+    .WillOnce(Return(parse_error::kParseNoError));
 
   processor_->ProcessCommands();
 }
 
 TEST_F(GPUProcessorTest, PostsTaskToFinishRemainingCommands) {
-  gpu::CommandHeader* header =
-      reinterpret_cast<gpu::CommandHeader*>(&buffer_[0]);
+  CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 2;
   buffer_[1] = 123;
@@ -144,10 +143,10 @@ TEST_F(GPUProcessorTest, PostsTaskToFinishRemainingCommands) {
     .WillOnce(Return(4));
 
   EXPECT_CALL(*async_api_, DoCommand(7, 1, &buffer_[0]))
-    .WillOnce(Return(gpu::parse_error::kParseNoError));
+    .WillOnce(Return(parse_error::kParseNoError));
 
   EXPECT_CALL(*async_api_, DoCommand(8, 0, &buffer_[2]))
-    .WillOnce(Return(gpu::parse_error::kParseNoError));
+    .WillOnce(Return(parse_error::kParseNoError));
 
   EXPECT_CALL(*command_buffer_, SetGetOffset(3));
 
@@ -159,7 +158,7 @@ TEST_F(GPUProcessorTest, PostsTaskToFinishRemainingCommands) {
     .WillOnce(Return(4));
 
   EXPECT_CALL(*async_api_, DoCommand(9, 0, &buffer_[3]))
-    .WillOnce(Return(gpu::parse_error::kParseNoError));
+    .WillOnce(Return(parse_error::kParseNoError));
 
   EXPECT_CALL(*command_buffer_, SetGetOffset(4));
 
@@ -167,8 +166,7 @@ TEST_F(GPUProcessorTest, PostsTaskToFinishRemainingCommands) {
 }
 
 TEST_F(GPUProcessorTest, SetsErrorCodeOnCommandBuffer) {
-  gpu::CommandHeader* header =
-      reinterpret_cast<gpu::CommandHeader*>(&buffer_[0]);
+  CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 1;
 
@@ -178,18 +176,17 @@ TEST_F(GPUProcessorTest, SetsErrorCodeOnCommandBuffer) {
 
   EXPECT_CALL(*async_api_, DoCommand(7, 0, &buffer_[0]))
     .WillOnce(Return(
-        gpu::parse_error::kParseUnknownCommand));
+        parse_error::kParseUnknownCommand));
 
   EXPECT_CALL(*command_buffer_,
-      SetParseError(gpu::parse_error::kParseUnknownCommand));
+      SetParseError(parse_error::kParseUnknownCommand));
 
   processor_->ProcessCommands();
 }
 
 TEST_F(GPUProcessorTest,
        RecoverableParseErrorsAreNotClearedByFollowingSuccessfulCommands) {
-  gpu::CommandHeader* header =
-      reinterpret_cast<gpu::CommandHeader*>(&buffer_[0]);
+  CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 1;
   header[1].command = 8;
@@ -201,20 +198,20 @@ TEST_F(GPUProcessorTest,
 
   EXPECT_CALL(*async_api_, DoCommand(7, 0, &buffer_[0]))
     .WillOnce(Return(
-        gpu::parse_error::kParseUnknownCommand));
+        parse_error::kParseUnknownCommand));
 
   EXPECT_CALL(*async_api_, DoCommand(8, 0, &buffer_[1]))
-    .WillOnce(Return(gpu::parse_error::kParseNoError));
+    .WillOnce(Return(parse_error::kParseNoError));
 
   EXPECT_CALL(*command_buffer_,
-      SetParseError(gpu::parse_error::kParseUnknownCommand));
+      SetParseError(parse_error::kParseUnknownCommand));
 
   processor_->ProcessCommands();
 }
 
 TEST_F(GPUProcessorTest, UnrecoverableParseErrorsRaiseTheErrorStatus) {
-  gpu::CommandHeader* header =
-      reinterpret_cast<gpu::CommandHeader*>(&buffer_[0]);
+  CommandHeader* header =
+      reinterpret_cast<CommandHeader*>(&buffer_[0]);
   header[0].command = 7;
   header[0].size = 1;
   header[1].command = 8;
@@ -224,10 +221,10 @@ TEST_F(GPUProcessorTest, UnrecoverableParseErrorsRaiseTheErrorStatus) {
     .WillOnce(Return(2));
 
   EXPECT_CALL(*async_api_, DoCommand(7, 0, &buffer_[0]))
-    .WillOnce(Return(gpu::parse_error::kParseInvalidSize));
+    .WillOnce(Return(parse_error::kParseInvalidSize));
 
   EXPECT_CALL(*command_buffer_,
-      SetParseError(gpu::parse_error::kParseInvalidSize));
+      SetParseError(parse_error::kParseInvalidSize));
 
   EXPECT_CALL(*command_buffer_, RaiseErrorStatus());
 
@@ -246,27 +243,20 @@ TEST_F(GPUProcessorTest, ProcessCommandsDoesNothingAfterUnrecoverableError) {
 
 TEST_F(GPUProcessorTest, CanGetAddressOfSharedMemory) {
   EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
-    .WillOnce(Return(shared_memory_.get()));
+    .WillOnce(Return(shared_memory_buffer_));
 
-  EXPECT_EQ(&buffer_[0], processor_->GetSharedMemoryAddress(7));
+  EXPECT_EQ(&buffer_[0], processor_->GetSharedMemoryBuffer(7).ptr);
 }
 
 ACTION_P2(SetPointee, address, value) {
   *address = value;
 }
 
-TEST_F(GPUProcessorTest, GetAddressOfSharedMemoryMapsMemoryIfUnmapped) {
-  EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
-    .WillOnce(Return(shared_memory_.get()));
-
-  EXPECT_EQ(&buffer_[0], processor_->GetSharedMemoryAddress(7));
-}
-
 TEST_F(GPUProcessorTest, CanGetSizeOfSharedMemory) {
   EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
-    .WillOnce(Return(shared_memory_.get()));
+    .WillOnce(Return(shared_memory_buffer_));
 
-  EXPECT_EQ(kRingBufferSize, processor_->GetSharedMemorySize(7));
+  EXPECT_EQ(kRingBufferSize, processor_->GetSharedMemoryBuffer(7).size);
 }
 
 TEST_F(GPUProcessorTest, SetTokenForwardsToCommandBuffer) {
diff --git a/gpu/command_buffer/service/gpu_processor_win.cc b/gpu/command_buffer/service/gpu_processor_win.cc
index c08e102..6a05845 100644
--- a/gpu/command_buffer/service/gpu_processor_win.cc
+++ b/gpu/command_buffer/service/gpu_processor_win.cc
@@ -37,19 +37,17 @@ bool GPUProcessor::Initialize(gfx::PluginWindowHandle handle) {
     return false;
 
   // Map the ring buffer and create the parser.
-  ::base::SharedMemory* ring_buffer = command_buffer_->GetRingBuffer();
-  if (ring_buffer) {
-    size_t size = ring_buffer->max_size();
-    if (!ring_buffer->Map(size)) {
-      return false;
-    }
-
-    void* ptr = ring_buffer->memory();
-    parser_.reset(new gpu::CommandParser(ptr, size, 0, size, 0,
-                                                    decoder_.get()));
+  Buffer ring_buffer = command_buffer_->GetRingBuffer();
+  if (ring_buffer.ptr) {
+    parser_.reset(new CommandParser(ring_buffer.ptr,
+                                    ring_buffer.size,
+                                    0,
+                                    ring_buffer.size,
+                                    0,
+                                    decoder_.get()));
   } else {
-    parser_.reset(new gpu::CommandParser(NULL, 0, 0, 0, 0,
-                                                    decoder_.get()));
+    parser_.reset(new CommandParser(NULL, 0, 0, 0, 0,
+                                    decoder_.get()));
   }
 
   // Initialize GAPI immediately if the window handle is valid.
@@ -64,17 +62,4 @@ void GPUProcessor::Destroy() {
     decoder_->set_hwnd(NULL);
   }
 }
-
-bool GPUProcessor::SetWindow(gfx::PluginWindowHandle handle,
-                             int width,
-                             int height) {
-  if (handle == NULL) {
-    // Destroy GAPI when the window handle becomes invalid.
-    Destroy();
-    return true;
-  } else {
-    return Initialize(handle);
-  }
-}
-
 }  // namespace gpu