Add support for GL_CHROMIUM_pixel_transfer_buffer_object.

gpu/command_buffer/service/buffer_manager_unittest.cc

Index: gpu/command_buffer/service/buffer_manager_unittest.cc
diff --git a/gpu/command_buffer/service/buffer_manager_unittest.cc b/gpu/command_buffer/service/buffer_manager_unittest.cc
index 7a84b0575ede13f504ebc44dc9380d293ce7b096..60b11bd2dc1c8fc3adb559523e9035239c12de82 100644
--- a/gpu/command_buffer/service/buffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/buffer_manager_unittest.cc
@@ -3,14 +3,33 @@
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/buffer_manager.h"
+#include "gpu/command_buffer/service/cmd_buffer_engine.h"
+#include "gpu/command_buffer/service/common_decoder.h"
 #include "gpu/command_buffer/common/gl_mock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
 namespace gles2 {
 
+class MockDecoder : public CommonDecoder {
+ public:
+  virtual ~MockDecoder() { }
+  MOCK_METHOD3(DoCommand, error::Error(
+     unsigned int command,
+     unsigned int arg_count,
+     const void* cmd_data));
+  MOCK_CONST_METHOD1(GetCommandName, const char* (unsigned int command_id));
+};
+
 class BufferManagerTest : public testing::Test {
  public:
+  static const int32 kSharedMemoryId = 401;
+  static const size_t kSharedBufferSize = 2048;
+  static const uint32 kSharedMemoryOffset = 132;
+  static const int32 kInvalidSharedMemoryId = 402;
+  static const uint32 kInvalidSharedMemoryOffset = kSharedBufferSize + 1;
+  static const uint8 kInitialMemoryValue = 0xBDu;
+
   BufferManagerTest() {
   }
   ~BufferManagerTest() {
@@ -18,12 +37,61 @@ class BufferManagerTest : public testing::Test {
   }
 
  protected:
+  class MockCommandBufferEngine : public CommandBufferEngine {
+   public:
+    MockCommandBufferEngine() {
+      data_.reset(new int8[kSharedBufferSize]);
+      ClearSharedMemory();
+      valid_buffer_.ptr = data_.get();
+      valid_buffer_.size = kSharedBufferSize;
+    }
+
+    virtual ~MockCommandBufferEngine() {
+    }
+
+    virtual Buffer GetSharedMemoryBuffer(int32 shm_id) OVERRIDE {
+      return shm_id == kSharedMemoryId ? valid_buffer_ : invalid_buffer_;
+    }
+
+    void ClearSharedMemory() {
+      memset(data_.get(), kInitialMemoryValue, kSharedBufferSize);
+    }
+
+    virtual void set_token(int32 token) OVERRIDE {
+      DCHECK(false);
+    }
+
+    virtual bool SetGetBuffer(int32 /* transfer_buffer_id */) OVERRIDE {
+      DCHECK(false);
+      return false;
+    }
+
+    // Overridden from CommandBufferEngine.
+    virtual bool SetGetOffset(int32 offset) OVERRIDE {
+      DCHECK(false);
+      return false;
+    }
+
+    // Overridden from CommandBufferEngine.
+    virtual int32 GetGetOffset() OVERRIDE {
+      DCHECK(false);
+      return 0;
+    }
+
+   private:
+    scoped_array<int8> data_;
+    Buffer valid_buffer_;
+    Buffer invalid_buffer_;
+  };
+
   virtual void SetUp() {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
+    engine_.reset(new MockCommandBufferEngine());
   }
 
   virtual void TearDown() {
+    engine_.reset();
     ::gfx::GLInterface::SetGLInterface(NULL);
     gl_.reset();
   }
@@ -34,9 +102,20 @@ class BufferManagerTest : public testing::Test {
 
   // Use StrictMock to make 100% sure we know how GL will be called.
   scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_;
+  scoped_ptr<MockCommandBufferEngine> engine_;
   BufferManager manager_;
 };
 
+// GCC requires these declarations, but MSVC requires they not be present
+#ifndef COMPILER_MSVC
+const int32 BufferManagerTest::kSharedMemoryId;
+const size_t BufferManagerTest::kSharedBufferSize;
+const uint32 BufferManagerTest::kSharedMemoryOffset;
+const int32 BufferManagerTest::kInvalidSharedMemoryId;
+const uint32 BufferManagerTest::kInvalidSharedMemoryOffset;
+const uint8 BufferManagerTest::kInitialMemoryValue;
+#endif
+
 TEST_F(BufferManagerTest, Basic) {
   const GLuint kClientBuffer1Id = 1;
   const GLuint kServiceBuffer1Id = 11;
@@ -244,7 +323,50 @@ TEST_F(BufferManagerTest, UseDeletedBuffer) {
   info = NULL;
 }
 
-}  // namespace gles2
-}  // namespace gpu
+TEST_F(BufferManagerTest, SharedMemory) {
+  const GLuint kClientBufferId = 1;
+  const GLuint kServiceBufferId = 11;
+  const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+  manager_.CreateBufferInfo(kClientBufferId, kServiceBufferId);
+  BufferManager::BufferInfo* info = manager_.GetBufferInfo(kClientBufferId);
+  ASSERT_TRUE(info != NULL);
 
+  manager_.SetTarget(info, GL_ARRAY_BUFFER);
+  scoped_ptr<MockDecoder> decoder;
+  decoder.reset(new MockDecoder());
+  decoder->set_engine(engine_.get());
+  // Set shared memory.
+  manager_.SetInfo(info, sizeof(data), GL_DYNAMIC_DRAW, decoder.get(),
+                   kSharedMemoryId, kSharedMemoryOffset);
+  const uint8* buf = static_cast<const uint8*>(
+      info->GetRange(0, sizeof(data)));
+  ASSERT_TRUE(buf != NULL);
+  ASSERT_EQ(kInitialMemoryValue, buf[0]);
+  ASSERT_EQ(kInitialMemoryValue, buf[sizeof(data) - 1]);
+
+  // Check that SetRange modifies shared memory.
+  info->SetRange(0, sizeof(data), data);
+  uint8* shm_buf = decoder->GetSharedMemoryAs<uint8*>(
+      kSharedMemoryId, kSharedMemoryOffset, sizeof(data));
+  ASSERT_TRUE(shm_buf != NULL);
+  ASSERT_EQ(buf[0], shm_buf[0]);
+  ASSERT_EQ(buf[sizeof(data) - 1], shm_buf[sizeof(data) - 1]);
 
+  // Reset shared memory to initial value.
+  engine_->ClearSharedMemory();
+  const uint8* buf1 = static_cast<const uint8*>(
+      info->GetRange(0, sizeof(data)));
+  ASSERT_TRUE(buf1 != NULL);
+  ASSERT_EQ(kInitialMemoryValue, buf[0]);
+  ASSERT_EQ(kInitialMemoryValue, buf[sizeof(data) - 1]);
+
+  // Remove decoder.
+  decoder.reset();
+  // Check that GetRange returns NULL after removing decoder.
+  const uint8* buf2 = static_cast<const uint8*>(
+      info->GetRange(0, sizeof(data)));
+  ASSERT_TRUE(buf2 == NULL);
+}
+
+}  // namespace gles2
+}  // namespace gpu