Revert 113250 - Add CommandBuffer::SetGetBuffer

gpu/command_buffer/client/gles2_implementation_unittest.cc

 // Copyright (c) 2011 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.
 
 // Tests for the Command Buffer Helper.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2ext.h>
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 #if !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
 #endif
 
-using testing::_;
-using testing::DoAll;
-using testing::InSequence;
-using testing::Invoke;
-using testing::Mock;
-using testing::Sequence;
-using testing::Truly;
-using testing::Return;
-
 namespace gpu {
 
 class GLES2MockCommandBufferHelper : public CommandBuffer {
  public:
-  static const int32 kTransferBufferBaseId = 0x123;
-  static const int32 kMaxTransferBuffers = 6;
+  static const int32 kTransferBufferId = 0x123;
 
   GLES2MockCommandBufferHelper() { }
   virtual ~GLES2MockCommandBufferHelper() { }
 
   // CommandBuffer implementation:
-  virtual bool Initialize() {
+  virtual bool Initialize(int32 size) {
+    ring_buffer_.reset(new CommandBufferEntry[size]);
+    ring_buffer_buffer_.ptr = ring_buffer_.get();
+    ring_buffer_buffer_.size = size;
+    state_.num_entries = size / sizeof(ring_buffer_[0]);
+    state_.token = 10000;  // All token checks in the tests should pass.
     return true;
   }
 
+  virtual bool Initialize(base::SharedMemory* buffer, int32 size) {
+    GPU_NOTREACHED();
+    return false;
+  }
+
+  virtual Buffer GetRingBuffer() {
+    return ring_buffer_buffer_;
+  }
+
   virtual State GetState() {
     return state_;
   }
 
   virtual State GetLastState() {
     return state_;
   }
 
   virtual void Flush(int32 put_offset) {
     state_.put_offset = put_offset;
   }
 
   virtual State FlushSync(int32 put_offset, int32 last_known_get) {
     state_.put_offset = put_offset;
     state_.get_offset = put_offset;
-    // Warning: This is a hack. We just happen to know that the default
-    // transfer buffer will be the first transfer buffer.
-    OnFlush(transfer_buffer_buffers_[0].ptr);
+    OnFlush(transfer_buffer_buffer_.ptr);
     return state_;
   }
 
-  virtual void SetGetBuffer(int transfer_buffer_id) {
-    ring_buffer_buffer_ = GetTransferBuffer(transfer_buffer_id);
-    ring_buffer_ = static_cast<CommandBufferEntry*>(ring_buffer_buffer_.ptr);
-    state_.num_entries = ring_buffer_buffer_.size / sizeof(ring_buffer_[0]);
-    state_.token = 10000;  // All token checks in the tests should pass.
-  }
-
   virtual void SetGetOffset(int32 get_offset) {
     state_.get_offset = get_offset;
   }
 
-  // Get's the Id of the next transfer buffer that will be returned
-  // by CreateTransferBuffer. This is useful for testing expected ids.
-  int32 GetNextFreeTransferBufferId() {
-    for (size_t ii = 0; ii < arraysize(transfer_buffers_); ++ii) {
-      if (!transfer_buffers_[ii].get()) {
-        return kTransferBufferBaseId + ii;
-      }
-    }
-    return -1;
+  virtual int32 CreateTransferBuffer(size_t size, int32 id_request) {
+    transfer_buffer_.reset(new int8[size]);
+    transfer_buffer_buffer_.ptr = transfer_buffer_.get();
+    transfer_buffer_buffer_.size = size;
+    return kTransferBufferId;
   }
 
-  virtual int32 CreateTransferBuffer(size_t size, int32 id_request) {
-    int32 id = GetNextFreeTransferBufferId();
-    if (id >= 0) {
-      int32 ndx = id - kTransferBufferBaseId;
-      transfer_buffers_[ndx].reset(new int8[size]);
-      transfer_buffer_buffers_[ndx].ptr = transfer_buffers_[ndx].get();
-      transfer_buffer_buffers_[ndx].size = size;
-    }
-    return id;
-  }
-
-  void DestroyTransferBufferHelper(int32 id) {
-    GPU_DCHECK_GE(id, kTransferBufferBaseId);
-    GPU_DCHECK_LT(id, kTransferBufferBaseId + kMaxTransferBuffers);
-    id -= kTransferBufferBaseId;
-    transfer_buffers_[id].reset();
-    transfer_buffer_buffers_[id] = Buffer();
+  virtual void DestroyTransferBuffer(int32 /* id */) {
+    GPU_NOTREACHED();
   }
 
   virtual Buffer GetTransferBuffer(int32 id) {
-    GPU_DCHECK_GE(id, kTransferBufferBaseId);
-    GPU_DCHECK_LT(id, kTransferBufferBaseId + kMaxTransferBuffers);
-    return transfer_buffer_buffers_[id - kTransferBufferBaseId];
+    GPU_DCHECK_EQ(id, kTransferBufferId);
+    return transfer_buffer_buffer_;
   }
 
   virtual int32 RegisterTransferBuffer(base::SharedMemory* shared_memory,
                                        size_t size,
                                        int32 id_request) {
     GPU_NOTREACHED();
     return -1;
   }
 
   virtual void SetToken(int32 token) {
     GPU_NOTREACHED();
     state_.token = token;
   }
 
   virtual void SetParseError(error::Error error) {
     GPU_NOTREACHED();
     state_.error = error;
   }
 
   virtual void SetContextLostReason(error::ContextLostReason reason) {
     GPU_NOTREACHED();
     state_.context_lost_reason = reason;
   }
 
   virtual void OnFlush(void* transfer_buffer) = 0;
 
  private:
-  scoped_array<int8> transfer_buffers_[kMaxTransferBuffers];
-  Buffer transfer_buffer_buffers_[kMaxTransferBuffers];
-  CommandBufferEntry* ring_buffer_;
+  scoped_array<int8> transfer_buffer_;
+  Buffer transfer_buffer_buffer_;
+  scoped_array<CommandBufferEntry> ring_buffer_;
   Buffer ring_buffer_buffer_;
   State state_;
 };
 
 class MockGLES2CommandBuffer : public GLES2MockCommandBufferHelper {
  public:
-  MockGLES2CommandBuffer() {
-    DelegateToFake();
-  }
-
   virtual ~MockGLES2CommandBuffer() {
   }
 
   // This is so we can use all the gmock functions when Flush is called.
   MOCK_METHOD1(OnFlush, void(void* result));
   MOCK_METHOD1(DestroyTransferBuffer, void(int32 id));
-
-  void DelegateToFake() {
-    ON_CALL(*this, DestroyTransferBuffer(_))
-        .WillByDefault(Invoke(
-            this, &GLES2MockCommandBufferHelper::DestroyTransferBufferHelper));
-  }
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
-const int32 GLES2MockCommandBufferHelper::kTransferBufferBaseId;
-const int32 GLES2MockCommandBufferHelper::kMaxTransferBuffers;
+const int32 GLES2MockCommandBufferHelper::kTransferBufferId;
 #endif
 
 namespace gles2 {
 
+using testing::_;
+using testing::DoAll;
+using testing::InSequence;
+using testing::Invoke;
+using testing::Mock;
+using testing::Sequence;
+using testing::Truly;
+using testing::Return;
+
 ACTION_P(SetMemory, obj) {
   memcpy(arg0, &obj, sizeof(obj));
 }
 
 ACTION_P2(SetMemoryAtOffset, offset, obj) {
   memcpy(static_cast<char*>(arg0) + offset, &obj, sizeof(obj));
 }
 
 ACTION_P3(SetMemoryAtOffsetFromArray, offset, array, size) {
   memcpy(static_cast<char*>(arg0) + offset, array, size);
@@ skipping 34 matching lines @@
   char str[7];
 };
 #pragma pack(pop)
 
 class GLES2CommandBufferTestBase : public testing::Test {
  protected:
   static const int32 kNumCommandEntries = 400;
   static const int32 kCommandBufferSizeBytes =
       kNumCommandEntries * sizeof(CommandBufferEntry);
   static const size_t kTransferBufferSize = 256;
+  static const int32 kTransferBufferId =
+      GLES2MockCommandBufferHelper::kTransferBufferId;
   static const uint8 kInitialValue = 0xBD;
 
   GLES2CommandBufferTestBase()
       : commands_(NULL),
         token_(0),
         offset_(0),
         initial_offset_(0),
-        alignment_(0),
-        transfer_buffer_id_(-1) {
+        alignment_(0) {
   }
 
   void SetupCommandBuffer(unsigned int offset, unsigned alignment) {
     initial_offset_ = offset;
     offset_ = offset;
     alignment_ = alignment;
 
     command_buffer_.reset(new MockGLES2CommandBuffer());
-    command_buffer_->Initialize();
+    command_buffer_->Initialize(kCommandBufferSizeBytes);
 
-    transfer_buffer_id_ =
-        command_buffer_->CreateTransferBuffer(kTransferBufferSize, -1);
-    transfer_buffer_ = command_buffer_->GetTransferBuffer(transfer_buffer_id_);
+    EXPECT_EQ(kTransferBufferId,
+              command_buffer_->CreateTransferBuffer(kTransferBufferSize, -1));
+    transfer_buffer_ = command_buffer_->GetTransferBuffer(kTransferBufferId);
     ClearTransferBuffer();
 
     helper_.reset(new GLES2CmdHelper(command_buffer_.get()));
     helper_->Initialize(kCommandBufferSizeBytes);
   }
 
   const void* GetPut() {
     return helper_->GetSpace(0);
   }
 
   size_t MaxTransferBufferSize() {
     return kTransferBufferSize - initial_offset_;
   }
 
   void ClearCommands() {
-    Buffer ring_buffer = helper_->get_ring_buffer();
+    Buffer ring_buffer = command_buffer_->GetRingBuffer();
     memset(ring_buffer.ptr, kInitialValue, ring_buffer.size);
   }
 
   bool NoCommandsWritten() {
     return static_cast<const uint8*>(static_cast<const void*>(commands_))[0] ==
            kInitialValue;
   }
 
   void ClearTransferBuffer() {
     memset(transfer_buffer_.ptr, kInitialValue, kTransferBufferSize);
   }
 
   unsigned int RoundToAlignment(unsigned int size) {
     return (size + alignment_ - 1) & ~(alignment_ - 1);
   }
 
   int GetNextToken() {
     return ++token_;
   }
 
-  int32 GetNextFreeTransferBufferId() {
-    return command_buffer_->GetNextFreeTransferBufferId();
-  }
-
   uint32 AllocateTransferBuffer(size_t size) {
     if (offset_ + size > kTransferBufferSize) {
       offset_ = initial_offset_;
     }
     uint32 offset = offset_;
     offset_ += RoundToAlignment(size);
     return offset;
   }
 
   void* GetTransferAddressFromOffset(uint32 offset, size_t size) {
     EXPECT_LE(offset + size, transfer_buffer_.size);
     return static_cast<int8*>(transfer_buffer_.ptr) + offset;
   }
 
   template <typename T>
   T* GetTransferAddressFromOffsetAs(uint32 offset, size_t size) {
     return static_cast<T*>(GetTransferAddressFromOffset(offset, size));
   }
 
   Buffer transfer_buffer_;
   CommandBufferEntry* commands_;
   scoped_ptr<MockGLES2CommandBuffer> command_buffer_;
   scoped_ptr<GLES2CmdHelper> helper_;
   int token_;
   uint32 offset_;
   uint32 initial_offset_;
   uint32 alignment_;
-  int32 transfer_buffer_id_;
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
 const int32 GLES2CommandBufferTestBase::kNumCommandEntries;
 const int32 GLES2CommandBufferTestBase::kCommandBufferSizeBytes;
 const size_t GLES2CommandBufferTestBase::kTransferBufferSize;
+const int32 GLES2CommandBufferTestBase::kTransferBufferId;
 const uint8 GLES2CommandBufferTestBase::kInitialValue;
 #endif
 
 class TransferBufferTest : public GLES2CommandBufferTestBase {
  protected:
   static const unsigned int kStartingOffset = 64;
   static const unsigned int kAlignment = 4;
 
   TransferBufferTest() { }
 
   virtual void SetUp() {
     SetupCommandBuffer(
         GLES2Implementation::kStartingOffset,
         GLES2Implementation::kAlignment);
 
-    transfer_buffer_id_ =
-        command_buffer_->CreateTransferBuffer(kTransferBufferSize, -1);
-
     transfer_buffer_.reset(new TransferBuffer(
         helper_.get(),
-        transfer_buffer_id_,
+        kTransferBufferId,
         GetTransferAddressFromOffset(0, 0),
         kTransferBufferSize,
         kStartingOffset,
         kAlignment));
   }
 
   virtual void TearDown() {
     transfer_buffer_.reset();
   }
 
   scoped_ptr<TransferBuffer> transfer_buffer_;
 };
 
 // GCC requires these declarations, but MSVC requires they not be present
 #ifndef _MSC_VER
 const unsigned int TransferBufferTest::kStartingOffset;
 const unsigned int TransferBufferTest::kAlignment;
 #endif
 
 TEST_F(TransferBufferTest, Basic) {
   EXPECT_TRUE(transfer_buffer_->HaveBuffer());
-  EXPECT_EQ(transfer_buffer_id_, transfer_buffer_->GetShmId());
+  EXPECT_EQ(kTransferBufferId, transfer_buffer_->GetShmId());
 }
 
 TEST_F(TransferBufferTest, Free) {
   EXPECT_TRUE(transfer_buffer_->HaveBuffer());
 
   // Free buffer.
   EXPECT_CALL(*command_buffer_, DestroyTransferBuffer(_))
       .Times(1)
       .RetiresOnSaturation();
   transfer_buffer_->Free();
   // See it's freed.
   EXPECT_FALSE(transfer_buffer_->HaveBuffer());
   // See that it gets reallocated.
-  EXPECT_EQ(transfer_buffer_id_, transfer_buffer_->GetShmId());
+  EXPECT_EQ(kTransferBufferId, transfer_buffer_->GetShmId());
   EXPECT_TRUE(transfer_buffer_->HaveBuffer());
 
   // Free buffer.
   EXPECT_CALL(*command_buffer_, DestroyTransferBuffer(_))
       .Times(1)
       .RetiresOnSaturation();
   transfer_buffer_->Free();
   // See it's freed.
   EXPECT_FALSE(transfer_buffer_->HaveBuffer());
   // See that it gets reallocated.
@@ skipping 111 matching lines @@
             ids += num;
             num_ids -= num;
           }
         }
       }
 
       gl_.reset(new GLES2Implementation(
           helper_.get(),
           kTransferBufferSize,
           transfer_buffer_.ptr,
-          transfer_buffer_id_,
+          kTransferBufferId,
           shared_resources,
           bind_generates_resource));
     }
 
     EXPECT_CALL(*command_buffer_, OnFlush(_))
         .Times(1)
         .RetiresOnSaturation();
     helper_->CommandBufferHelper::Finish();
-    Buffer ring_buffer = helper_->get_ring_buffer();
+    Buffer ring_buffer = command_buffer_->GetRingBuffer();
     commands_ = static_cast<CommandBufferEntry*>(ring_buffer.ptr) +
                 command_buffer_->GetState().put_offset;
     ClearCommands();
   }
 
   Sequence sequence_;
   scoped_ptr<GLES2Implementation> gl_;
 };
 
 class GLES2ImplementationStrictSharedTest : public GLES2ImplementationTest {
@@ skipping 22 matching lines @@
     cmd::SetBucketData set_bucket_data2;
     cmd::SetToken set_token2;
     cmd::SetBucketData set_bucket_data3;
     cmd::SetToken set_token3;
     ShaderSourceBucket shader_source_bucket;
     cmd::SetBucketSize clear_bucket_size;
   };
   Cmds expected;
   expected.set_bucket_size.Init(kBucketId, kSourceSize);
   expected.set_bucket_data1.Init(
-      kBucketId, 0, kString1Size, transfer_buffer_id_,
+      kBucketId, 0, kString1Size, kTransferBufferId,
       AllocateTransferBuffer(kPaddedString1Size));
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_data2.Init(
-      kBucketId, kString1Size, kString2Size, transfer_buffer_id_,
+      kBucketId, kString1Size, kString2Size, kTransferBufferId,
       AllocateTransferBuffer(kPaddedString2Size));
   expected.set_token2.Init(GetNextToken());
   expected.set_bucket_data3.Init(
       kBucketId, kString1Size + kString2Size,
-      kString3Size, transfer_buffer_id_,
+      kString3Size, kTransferBufferId,
       AllocateTransferBuffer(kPaddedString3Size));
   expected.set_token3.Init(GetNextToken());
   expected.shader_source_bucket.Init(kShaderId, kBucketId);
   expected.clear_bucket_size.Init(kBucketId, 0);
   const char* strings[] = {
     kString1,
     kString2,
   };
   gl_->ShaderSource(kShaderId, 2, strings, NULL);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, GetShaderSource) {
   const uint32 kBucketId = 1;  // This id is hardcoded into GLES2Implemenation
   const GLuint kShaderId = 456;
   const Str7 kString = {"foobar"};
   const char kBad = 0x12;
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
     GetShaderSource get_shader_source;
     cmd::GetBucketSize get_bucket_size;
     cmd::GetBucketData get_bucket_data;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
   uint32 offset = AllocateTransferBuffer(sizeof(kString));
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_shader_source.Init(kShaderId, kBucketId);
-  expected.get_bucket_size.Init(kBucketId, transfer_buffer_id_, 0);
+  expected.get_bucket_size.Init(kBucketId, kTransferBufferId, 0);
   expected.get_bucket_data.Init(
-      kBucketId, 0, sizeof(kString), transfer_buffer_id_, offset);
+      kBucketId, 0, sizeof(kString), kTransferBufferId, offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_size2.Init(kBucketId, 0);
   char buf[sizeof(kString) + 1];
   memset(buf, kBad, sizeof(buf));
 
   EXPECT_CALL(*command_buffer_, OnFlush(_))
       .WillOnce(SetMemory(uint32(sizeof(kString))))
       .WillOnce(SetMemoryAtOffset(offset, kString))
       .RetiresOnSaturation();
 
@@ skipping 41 matching lines @@
   const GLsizei kEmuOffset1 = 0;
   const GLsizei kEmuOffset2 = kSize1;
 
   const GLsizei kTotalSize = kSize1 + kSize2;
   Cmds expected;
   expected.enable1.Init(kAttribIndex1);
   expected.enable2.Init(kAttribIndex2);
   expected.bind_to_emu.Init(GL_ARRAY_BUFFER, kEmuBufferId);
   expected.set_size.Init(GL_ARRAY_BUFFER, kTotalSize, 0, 0, GL_DYNAMIC_DRAW);
   expected.copy_data1.Init(
-      GL_ARRAY_BUFFER, kEmuOffset1, kSize1, transfer_buffer_id_,
+      GL_ARRAY_BUFFER, kEmuOffset1, kSize1, kTransferBufferId,
       AllocateTransferBuffer(kSize1));
   expected.set_token1.Init(GetNextToken());
   expected.set_pointer1.Init(kAttribIndex1, kNumComponents1,
                              GL_FLOAT, GL_FALSE, 0, kEmuOffset1);
   expected.copy_data2.Init(
-      GL_ARRAY_BUFFER, kEmuOffset2, kSize2, transfer_buffer_id_,
+      GL_ARRAY_BUFFER, kEmuOffset2, kSize2, kTransferBufferId,
       AllocateTransferBuffer(kSize2));
   expected.set_token2.Init(GetNextToken());
   expected.set_pointer2.Init(kAttribIndex2, kNumComponents2,
                              GL_FLOAT, GL_FALSE, 0, kEmuOffset2);
   expected.draw.Init(GL_POINTS, kFirst, kCount);
   expected.restore.Init(GL_ARRAY_BUFFER, 0);
   gl_->EnableVertexAttribArray(kAttribIndex1);
   gl_->EnableVertexAttribArray(kAttribIndex2);
   gl_->VertexAttribPointer(kAttribIndex1, kNumComponents1,
                            GL_FLOAT, GL_FALSE, kClientStride, verts);
@@ skipping 49 matching lines @@
   const GLsizei kEmuOffset2 = kSize1;
 
   const GLsizei kTotalSize = kSize1 + kSize2;
   Cmds expected;
   expected.enable1.Init(kAttribIndex1);
   expected.enable2.Init(kAttribIndex2);
   expected.bind_to_index_emu.Init(GL_ELEMENT_ARRAY_BUFFER, kEmuIndexBufferId);
   expected.set_index_size.Init(
       GL_ELEMENT_ARRAY_BUFFER, kIndexSize, 0, 0, GL_DYNAMIC_DRAW);
   expected.copy_data0.Init(
-      GL_ELEMENT_ARRAY_BUFFER, 0, kIndexSize, transfer_buffer_id_,
+      GL_ELEMENT_ARRAY_BUFFER, 0, kIndexSize, kTransferBufferId,
       AllocateTransferBuffer(kIndexSize));
   expected.set_token0.Init(GetNextToken());
   expected.bind_to_emu.Init(GL_ARRAY_BUFFER, kEmuBufferId);
   expected.set_size.Init(GL_ARRAY_BUFFER, kTotalSize, 0, 0, GL_DYNAMIC_DRAW);
   expected.copy_data1.Init(
-      GL_ARRAY_BUFFER, kEmuOffset1, kSize1, transfer_buffer_id_,
+      GL_ARRAY_BUFFER, kEmuOffset1, kSize1, kTransferBufferId,
       AllocateTransferBuffer(kSize1));
   expected.set_token1.Init(GetNextToken());
   expected.set_pointer1.Init(kAttribIndex1, kNumComponents1,
                              GL_FLOAT, GL_FALSE, 0, kEmuOffset1);
   expected.copy_data2.Init(
-      GL_ARRAY_BUFFER, kEmuOffset2, kSize2, transfer_buffer_id_,
+      GL_ARRAY_BUFFER, kEmuOffset2, kSize2, kTransferBufferId,
       AllocateTransferBuffer(kSize2));
   expected.set_token2.Init(GetNextToken());
   expected.set_pointer2.Init(kAttribIndex2, kNumComponents2,
                              GL_FLOAT, GL_FALSE, 0, kEmuOffset2);
   expected.draw.Init(GL_POINTS, kCount, GL_UNSIGNED_SHORT, 0);
   expected.restore.Init(GL_ARRAY_BUFFER, 0);
   expected.restore_element.Init(GL_ELEMENT_ARRAY_BUFFER, 0);
   gl_->EnableVertexAttribArray(kAttribIndex1);
   gl_->EnableVertexAttribArray(kAttribIndex2);
   gl_->VertexAttribPointer(kAttribIndex1, kNumComponents1,
@@ skipping 43 matching lines @@
       arraysize(verts) * kNumComponents2 * sizeof(verts[0][0]);
   const GLsizei kEmuOffset1 = 0;
   const GLsizei kEmuOffset2 = kSize1;
 
   const GLsizei kTotalSize = kSize1 + kSize2;
   Cmds expected;
   expected.enable1.Init(kAttribIndex1);
   expected.enable2.Init(kAttribIndex2);
   expected.bind_to_index.Init(GL_ELEMENT_ARRAY_BUFFER, kClientIndexBufferId);
   expected.get_max.Init(kClientIndexBufferId, kCount, GL_UNSIGNED_SHORT,
-                        kIndexOffset, transfer_buffer_id_, 0);
+                        kIndexOffset, kTransferBufferId, 0);
   expected.bind_to_emu.Init(GL_ARRAY_BUFFER, kEmuBufferId);
   expected.set_size.Init(GL_ARRAY_BUFFER, kTotalSize, 0, 0, GL_DYNAMIC_DRAW);
   expected.copy_data1.Init(
-      GL_ARRAY_BUFFER, kEmuOffset1, kSize1, transfer_buffer_id_,
+      GL_ARRAY_BUFFER, kEmuOffset1, kSize1, kTransferBufferId,
       AllocateTransferBuffer(kSize1));
   expected.set_token1.Init(GetNextToken());
   expected.set_pointer1.Init(kAttribIndex1, kNumComponents1,
                              GL_FLOAT, GL_FALSE, 0, kEmuOffset1);
   expected.copy_data2.Init(
-      GL_ARRAY_BUFFER, kEmuOffset2, kSize2, transfer_buffer_id_,
+      GL_ARRAY_BUFFER, kEmuOffset2, kSize2, kTransferBufferId,
       AllocateTransferBuffer(kSize2));
   expected.set_token2.Init(GetNextToken());
   expected.set_pointer2.Init(kAttribIndex2, kNumComponents2,
                              GL_FLOAT, GL_FALSE, 0, kEmuOffset2);
   expected.draw.Init(GL_POINTS, kCount, GL_UNSIGNED_SHORT, kIndexOffset);
   expected.restore.Init(GL_ARRAY_BUFFER, 0);
 
   EXPECT_CALL(*command_buffer_, OnFlush(_))
       .WillOnce(SetMemory(kMaxIndex))
       .RetiresOnSaturation();
@@ skipping 26 matching lines @@
   struct Cmds {
     BindBuffer bind;
     VertexAttribPointer set_pointer;
     GetVertexAttribPointerv get_pointer;
   };
   Cmds expected;
   expected.bind.Init(GL_ARRAY_BUFFER, kBufferId);
   expected.set_pointer.Init(kAttribIndex2, kNumComponents2, GL_FLOAT, GL_FALSE,
                             kStride2, kOffset2);
   expected.get_pointer.Init(kAttribIndex2, GL_VERTEX_ATTRIB_ARRAY_POINTER,
-                            transfer_buffer_id_, 0);
+                            kTransferBufferId, 0);
 
   // One call to flush to way for GetVertexAttribPointerv
   EXPECT_CALL(*command_buffer_, OnFlush(_))
       .WillOnce(SetMemory(SizedResultHelper<uint32>(kOffset2)))
       .RetiresOnSaturation();
 
   // Set one client side buffer.
   gl_->VertexAttribPointer(kAttribIndex1, kNumComponents1,
                            GL_FLOAT, GL_FALSE, kStride1, verts);
   // Set one VBO
@@ skipping 36 matching lines @@
     GetVertexAttribiv get1;  // for getting the buffer from attrib2
     GetVertexAttribfv get2;  // for getting the value from attrib1
   };
   Cmds expected;
   expected.enable.Init(kAttribIndex1);
   expected.bind.Init(GL_ARRAY_BUFFER, kBufferId);
   expected.set_pointer.Init(kAttribIndex2, kNumComponents2, GL_FLOAT, GL_FALSE,
                             kStride2, kOffset2);
   expected.get1.Init(kAttribIndex2,
                      GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING,
-                     transfer_buffer_id_, 0);
+                     kTransferBufferId, 0);
   expected.get2.Init(kAttribIndex1,
                      GL_CURRENT_VERTEX_ATTRIB,
-                     transfer_buffer_id_, 0);
+                     kTransferBufferId, 0);
 
   FourFloats current_attrib(1.2f, 3.4f, 5.6f, 7.8f);
 
   // One call to flush to way for GetVertexAttribiv
   EXPECT_CALL(*command_buffer_, OnFlush(_))
       .WillOnce(SetMemory(SizedResultHelper<GLuint>(kBufferId)))
       .WillOnce(SetMemory(SizedResultHelper<FourFloats>(current_attrib)))
       .RetiresOnSaturation();
 
   gl_->EnableVertexAttribArray(kAttribIndex1);
@@ skipping 42 matching lines @@
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, ReservedIds) {
   // Only the get error command should be issued.
   struct Cmds {
     GetError get;
   };
   Cmds expected;
-  expected.get.Init(transfer_buffer_id_, 0);
+  expected.get.Init(kTransferBufferId, 0);
 
   // One call to flush to wait for GetError
   EXPECT_CALL(*command_buffer_, OnFlush(_))
       .WillOnce(SetMemory(GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
 
   gl_->BindBuffer(
       GL_ARRAY_BUFFER,
       GLES2Implementation::kClientSideArrayId);
   gl_->BindBuffer(
@@ skipping 17 matching lines @@
   const GLint kWidth =
       (kTransferBufferSize - GLES2Implementation::kStartingOffset) /
       kBytesPerPixel;
   const GLint kHeight = 2;
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
 
   Cmds expected;
   expected.read1.Init(
       0, 0, kWidth, kHeight / 2, kFormat, kType,
-      transfer_buffer_id_,
+      kTransferBufferId,
       AllocateTransferBuffer(kWidth * kHeight / 2 * kBytesPerPixel),
-      transfer_buffer_id_, 0);
+      kTransferBufferId, 0);
   expected.set_token1.Init(GetNextToken());
   expected.read2.Init(
       0, kHeight / 2, kWidth, kHeight / 2, kFormat, kType,
-      transfer_buffer_id_,
+      kTransferBufferId,
       AllocateTransferBuffer(kWidth * kHeight / 2 * kBytesPerPixel),
-      transfer_buffer_id_, 0);
+      kTransferBufferId, 0);
   expected.set_token2.Init(GetNextToken());
   scoped_array<int8> buffer(new int8[kWidth * kHeight * kBytesPerPixel]);
 
   EXPECT_CALL(*command_buffer_, OnFlush(_))
       .WillOnce(SetMemory(static_cast<uint32>(1)))
       .WillOnce(SetMemory(static_cast<uint32>(1)))
       .RetiresOnSaturation();
 
   gl_->ReadPixels(0, 0, kWidth, kHeight, kFormat, kType, buffer.get());
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, ReadPixelsBadFormatType) {
   struct Cmds {
     ReadPixels read;
     cmd::SetToken set_token;
   };
   const GLint kBytesPerPixel = 4;
   const GLint kWidth = 2;
   const GLint kHeight = 2;
   const GLenum kFormat = 0;
   const GLenum kType = 0;
 
   Cmds expected;
   expected.read.Init(
       0, 0, kWidth, kHeight / 2, kFormat, kType,
-      transfer_buffer_id_,
+      kTransferBufferId,
       AllocateTransferBuffer(kWidth * kHeight * kBytesPerPixel),
-      transfer_buffer_id_, 0);
+      kTransferBufferId, 0);
   expected.set_token.Init(GetNextToken());
   scoped_array<int8> buffer(new int8[kWidth * kHeight * kBytesPerPixel]);
 
   EXPECT_CALL(*command_buffer_, OnFlush(_))
       .Times(1)
       .RetiresOnSaturation();
 
   gl_->ReadPixels(0, 0, kWidth, kHeight, kFormat, kType, buffer.get());
 }
 
 TEST_F(GLES2ImplementationTest, FreeUnusedSharedMemory) {
   struct Cmds {
     BufferSubData buf;
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLintptr kOffset = 15;
   const GLsizeiptr kSize = 16;
 
   uint32 offset = 0;
   Cmds expected;
   expected.buf.Init(
-    kTarget, kOffset, kSize, transfer_buffer_id_, offset);
+    kTarget, kOffset, kSize, kTransferBufferId, offset);
   expected.set_token.Init(GetNextToken());
 
   void* mem = gl_->MapBufferSubDataCHROMIUM(
       kTarget, kOffset, kSize, GL_WRITE_ONLY);
   ASSERT_TRUE(mem != NULL);
   gl_->UnmapBufferSubDataCHROMIUM(mem);
   EXPECT_CALL(*command_buffer_, DestroyTransferBuffer(_))
       .Times(1)
       .RetiresOnSaturation();
   gl_->FreeUnusedSharedMemory();
 }
 
 TEST_F(GLES2ImplementationTest, MapUnmapBufferSubDataCHROMIUM) {
   struct Cmds {
     BufferSubData buf;
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLintptr kOffset = 15;
   const GLsizeiptr kSize = 16;
 
   uint32 offset = 0;
   Cmds expected;
   expected.buf.Init(
-      kTarget, kOffset, kSize, GetNextFreeTransferBufferId(), offset);
+    kTarget, kOffset, kSize, kTransferBufferId, offset);
   expected.set_token.Init(GetNextToken());
 
   void* mem = gl_->MapBufferSubDataCHROMIUM(
       kTarget, kOffset, kSize, GL_WRITE_ONLY);
   ASSERT_TRUE(mem != NULL);
   gl_->UnmapBufferSubDataCHROMIUM(mem);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, MapUnmapBufferSubDataCHROMIUMBadArgs) {
@@ skipping 34 matching lines @@
   const GLint kYOffset = 3;
   const GLint kWidth = 4;
   const GLint kHeight = 5;
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
 
   uint32 offset = 0;
   Cmds expected;
   expected.tex.Init(
       GL_TEXTURE_2D, kLevel, kXOffset, kYOffset, kWidth, kHeight, kFormat,
-      kType, GetNextFreeTransferBufferId(), offset, GL_FALSE);
+      kType, kTransferBufferId, offset, GL_FALSE);
   expected.set_token.Init(GetNextToken());
 
   void* mem = gl_->MapTexSubImage2DCHROMIUM(
       GL_TEXTURE_2D,
       kLevel,
       kXOffset,
       kYOffset,
       kWidth,
       kHeight,
       kFormat,
@@ skipping 114 matching lines @@
     GetMultipleIntegervCHROMIUM get_multiple;
     cmd::SetToken set_token;
   };
   const GLsizei kNumPnames = arraysize(pnames);
   const GLsizeiptr kResultsSize = num_results * sizeof(results[0]);
   const uint32 kPnamesOffset =
       AllocateTransferBuffer(kNumPnames * sizeof(pnames[0]));
   const uint32 kResultsOffset = AllocateTransferBuffer(kResultsSize);
   Cmds expected;
   expected.get_multiple.Init(
-      transfer_buffer_id_, kPnamesOffset, kNumPnames,
-      transfer_buffer_id_, kResultsOffset, kResultsSize);
+      kTransferBufferId, kPnamesOffset, kNumPnames,
+      kTransferBufferId, kResultsOffset, kResultsSize);
   expected.set_token.Init(GetNextToken());
 
   const GLint kSentinel = 0x12345678;
   memset(results, 0, sizeof(results));
   results[num_results] = kSentinel;
   const GLint returned_results[] = {
     1, 0, 1, 0, 1, -1,
   };
   // One call to flush to wait for results
   EXPECT_CALL(*command_buffer_, OnFlush(_))
@@ skipping 88 matching lines @@
     cmd::SetBucketSize set_bucket_size1;
     GetProgramInfoCHROMIUM get_program_info;
     cmd::GetBucketSize get_bucket_size;
     cmd::GetBucketData get_bucket_data;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_program_info.Init(kProgramId, kBucketId);
-  expected.get_bucket_size.Init(kBucketId, transfer_buffer_id_, 0);
+  expected.get_bucket_size.Init(kBucketId, kTransferBufferId, 0);
   expected.get_bucket_data.Init(
-      kBucketId, 0, sizeof(kString), transfer_buffer_id_, offset);
+      kBucketId, 0, sizeof(kString), kTransferBufferId, offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_size2.Init(kBucketId, 0);
   gl_->GetProgramInfoCHROMIUM(kProgramId, sizeof(buf), &size, &buf);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
   EXPECT_EQ(sizeof(kString), static_cast<size_t>(size));
   EXPECT_STREQ(kString.str, buf);
   EXPECT_EQ(buf[sizeof(kString)], kBad);
 }
 
@@ skipping 18 matching lines @@
     cmd::SetBucketSize set_bucket_size1;
     GetProgramInfoCHROMIUM get_program_info;
     cmd::GetBucketSize get_bucket_size;
     cmd::GetBucketData get_bucket_data;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_program_info.Init(kProgramId, kBucketId);
-  expected.get_bucket_size.Init(kBucketId, transfer_buffer_id_, 0);
+  expected.get_bucket_size.Init(kBucketId, kTransferBufferId, 0);
   expected.get_bucket_data.Init(
-      kBucketId, 0, sizeof(kString), transfer_buffer_id_, offset);
+      kBucketId, 0, sizeof(kString), kTransferBufferId, offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_size2.Init(kBucketId, 0);
   gl_->GetProgramInfoCHROMIUM(kProgramId, 6, &size, &buf);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), gl_->GetError());
   ClearCommands();
 
   // try bad bufsize
   gl_->GetProgramInfoCHROMIUM(kProgramId, -1, &size, &buf);
   EXPECT_TRUE(NoCommandsWritten());
@@ skipping 155 matching lines @@
   static uint8 pixels[] = {
     11, 12, 13, 13, 14, 15, 15, 16, 17, 101, 102, 103,
     21, 22, 23, 23, 24, 25, 25, 26, 27, 201, 202, 203,
     31, 32, 33, 33, 34, 35, 35, 36, 37, 123, 124, 125,
     41, 42, 43, 43, 44, 45, 45, 46, 47,
   };
   uint32 offset = AllocateTransferBuffer(sizeof(pixels));
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
-      transfer_buffer_id_, offset);
+      kTransferBufferId, offset);
   expected.set_token.Init(GetNextToken());
   gl_->TexImage2D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       pixels);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment, false,
       pixels, GetTransferAddressFromOffsetAs<uint8>(offset, sizeof(pixels))));
 
   ClearCommands();
   uint32 offset2 = AllocateTransferBuffer(sizeof(pixels));
   Cmds2 expected2;
   expected2.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
-      transfer_buffer_id_, offset2);
+      kTransferBufferId, offset2);
   expected2.set_token.Init(GetNextToken());
   const void* commands2 = GetPut();
   gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
   gl_->TexImage2D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       pixels);
   EXPECT_EQ(0, memcmp(&expected2, commands2, sizeof(expected2)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment, true,
       pixels, GetTransferAddressFromOffsetAs<uint8>(offset2, sizeof(pixels))));
@@ skipping 36 matching lines @@
     pixels[ii] = static_cast<uint8>(ii);
   }
   uint32 offset1 = AllocateTransferBuffer(half_size);
   uint32 offset2 = AllocateTransferBuffer(half_size);
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       0, 0);
   expected.tex_sub_image_2d1.Init(
       kTarget, kLevel, 0, 0, kWidth, kHeight / 2, kFormat, kType,
-      transfer_buffer_id_, offset1, true);
+      kTransferBufferId, offset1, true);
   expected.set_token1.Init(GetNextToken());
   expected.tex_sub_image_2d2.Init(
       kTarget, kLevel, 0, kHeight / 2, kWidth, kHeight / 2, kFormat, kType,
-      transfer_buffer_id_, offset2, true);
+      kTransferBufferId, offset2, true);
   expected.set_token2.Init(GetNextToken());
 
   // TODO(gman): Make it possible to run this test
   // EXPECT_CALL(*command_buffer_, OnFlush(_))
   //     .WillOnce(CheckRectAction(
   //         kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment,
   //         false, pixels.get(),
   //         GetTransferAddressFromOffsetAs<uint8>(offset1, half_size)))
   //     .RetiresOnSaturation();
 
   gl_->TexImage2D(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       pixels.get());
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment, false,
       pixels.get() + kHeight / 2 * padded_row_size,
       GetTransferAddressFromOffsetAs<uint8>(offset2, half_size)));
 
   ClearCommands();
   const void* commands2 = GetPut();
   uint32 offset3 = AllocateTransferBuffer(half_size);
   uint32 offset4 = AllocateTransferBuffer(half_size);
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       0, 0);
   expected.tex_sub_image_2d1.Init(
       kTarget, kLevel, 0, kHeight / 2, kWidth, kHeight / 2, kFormat, kType,
-      transfer_buffer_id_, offset3, true);
+      kTransferBufferId, offset3, true);
   expected.set_token1.Init(GetNextToken());
   expected.tex_sub_image_2d2.Init(
       kTarget, kLevel, 0, 0, kWidth, kHeight / 2, kFormat, kType,
-      transfer_buffer_id_, offset4, true);
+      kTransferBufferId, offset4, true);
   expected.set_token2.Init(GetNextToken());
 
   // TODO(gman): Make it possible to run this test
   // EXPECT_CALL(*command_buffer_, OnFlush(_))
   //     .WillOnce(CheckRectAction(
   //         kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment,
   //         true, pixels.get(),
   //         GetTransferAddressFromOffsetAs<uint8>(offset3, half_size)))
   //     .RetiresOnSaturation();
 
@@ skipping 45 matching lines @@
   uint32 offset1 = AllocateTransferBuffer(part_size);
   uint32 offset2 = AllocateTransferBuffer(part_size);
   uint32 offset3 = AllocateTransferBuffer(part_size);
   uint32 offset4 = AllocateTransferBuffer(part_size);
   Cmds expected;
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       0, 0);
   expected.tex_sub_image_2d1.Init(
       kTarget, kLevel, 0, 0, kWidth / 2, 1, kFormat, kType,
-      transfer_buffer_id_, offset1, true);
+      kTransferBufferId, offset1, true);
   expected.set_token1.Init(GetNextToken());
   expected.tex_sub_image_2d2.Init(
       kTarget, kLevel, kWidth / 2, 0, kWidth / 2, 1, kFormat, kType,
-      transfer_buffer_id_, offset2, true);
+      kTransferBufferId, offset2, true);
   expected.set_token2.Init(GetNextToken());
   expected.tex_sub_image_2d3.Init(
       kTarget, kLevel, 0, 1, kWidth / 2, 1, kFormat, kType,
-      transfer_buffer_id_, offset3, true);
+      kTransferBufferId, offset3, true);
   expected.set_token3.Init(GetNextToken());
   expected.tex_sub_image_2d4.Init(
       kTarget, kLevel, kWidth / 2, 1, kWidth / 2, 1, kFormat, kType,
-      transfer_buffer_id_, offset4, true);
+      kTransferBufferId, offset4, true);
   expected.set_token4.Init(GetNextToken());
 
   // TODO(gman): Make it possible to run this test
   // EXPECT_CALL(*command_buffer_, OnFlush(_))
   //     .WillOnce(CheckRectAction(
   //         kWidth / 2, 1, kFormat, kType, kPixelStoreUnpackAlignment, false,
   //         pixels.get(),
   //         GetTransferAddressFromOffsetAs<uint8>(offset1, part_size)))
   //     .WillOnce(CheckRectAction(
   //         kWidth / 2, 1, kFormat, kType, kPixelStoreUnpackAlignment, false,
@@ skipping 18 matching lines @@
   const void* commands2 = GetPut();
   offset1 = AllocateTransferBuffer(part_size);
   offset2 = AllocateTransferBuffer(part_size);
   offset3 = AllocateTransferBuffer(part_size);
   offset4 = AllocateTransferBuffer(part_size);
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kWidth, kHeight, kBorder, kFormat, kType,
       0, 0);
   expected.tex_sub_image_2d1.Init(
       kTarget, kLevel, 0, 1, kWidth / 2, 1, kFormat, kType,
-      transfer_buffer_id_, offset1, true);
+      kTransferBufferId, offset1, true);
   expected.set_token1.Init(GetNextToken());
   expected.tex_sub_image_2d2.Init(
       kTarget, kLevel, kWidth / 2, 1, kWidth / 2, 1, kFormat, kType,
-      transfer_buffer_id_, offset2, true);
+      kTransferBufferId, offset2, true);
   expected.set_token2.Init(GetNextToken());
   expected.tex_sub_image_2d3.Init(
       kTarget, kLevel, 0, 0, kWidth / 2, 1, kFormat, kType,
-      transfer_buffer_id_, offset3, true);
+      kTransferBufferId, offset3, true);
   expected.set_token3.Init(GetNextToken());
   expected.tex_sub_image_2d4.Init(
       kTarget, kLevel, kWidth / 2, 0, kWidth / 2, 1, kFormat, kType,
-      transfer_buffer_id_, offset4, true);
+      kTransferBufferId, offset4, true);
   expected.set_token4.Init(GetNextToken());
 
   // TODO(gman): Make it possible to run this test
   // EXPECT_CALL(*command_buffer_, OnFlush(_))
   //     .WillOnce(CheckRectAction(
   //         kWidth / 2, 1, kFormat, kType, kPixelStoreUnpackAlignment, false,
   //         pixels.get(),
   //         GetTransferAddressFromOffsetAs<uint8>(offset1, part_size)))
   //     .WillOnce(CheckRectAction(
   //         kWidth / 2, 1, kFormat, kType, kPixelStoreUnpackAlignment, false,
@@ skipping 47 matching lines @@
   uint32 offset1 = AllocateTransferBuffer(sub_2_high_size);
   uint32 offset2 = AllocateTransferBuffer(sub_2_high_size);
 
   Cmds expected;
   expected.pixel_store_i1.Init(GL_UNPACK_ALIGNMENT, kPixelStoreUnpackAlignment);
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kTextureWidth, kTextureHeight, kBorder, kFormat,
       kType, 0, NULL);
   expected.tex_sub_image_2d1.Init(kTarget, kLevel, kSubImageXOffset,
       kSubImageYOffset + 2, kSubImageWidth, 2, kFormat, kType,
-      transfer_buffer_id_, offset1, false);
+      kTransferBufferId, offset1, false);
   expected.set_token1.Init(GetNextToken());
   expected.tex_sub_image_2d2.Init(kTarget, kLevel, kSubImageXOffset,
-      kSubImageYOffset, kSubImageWidth , 2, kFormat, kType, transfer_buffer_id_,
+      kSubImageYOffset, kSubImageWidth , 2, kFormat, kType, kTransferBufferId,
       offset2, false);
   expected.set_token2.Init(GetNextToken());
 
   gl_->PixelStorei(GL_UNPACK_ALIGNMENT, kPixelStoreUnpackAlignment);
   gl_->TexImage2D(
       kTarget, kLevel, kFormat, kTextureWidth, kTextureHeight, kBorder, kFormat,
       kType, NULL);
   // this call should not emit commands (handled client-side)
   gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, GL_TRUE);
   scoped_array<uint32> pixels(new uint32[kSubImageWidth * kSubImageHeight]);
@@ skipping 88 matching lines @@
 TEST_F(GLES2ImplementationTest, CreateStreamTextureCHROMIUM) {
   const GLuint kTextureId = 123;
   const GLuint kResult = 456;
   const uint32 kResultOffset = 0;
 
   struct Cmds {
     CreateStreamTextureCHROMIUM create_stream;
   };
 
   Cmds expected;
-  expected.create_stream.Init(kTextureId, transfer_buffer_id_, kResultOffset);
+  expected.create_stream.Init(kTextureId, kTransferBufferId, kResultOffset);
 
   EXPECT_CALL(*command_buffer_, OnFlush(_))
       .WillOnce(SetMemoryAtOffset(kResultOffset, kResult))
       .WillOnce(SetMemory(GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
 
   GLuint handle = gl_->CreateStreamTextureCHROMIUM(kTextureId);
   EXPECT_EQ(handle, kResult);
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
@@ skipping 10 matching lines @@
   expected.destroy_stream.Init(kTextureHandle);
 
   gl_->DestroyStreamTextureCHROMIUM(kTextureHandle);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 }  // namespace gles2
 }  // namespace gpu