Make command buffer free transfer buffer when switching tabs

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "../client/gles2_implementation.h"
 
 #include <set>
 #include <queue>
@@ skipping 501 matching lines @@
   GLsizei array_buffer_offset_;
   GLuint element_array_buffer_id_;
   GLsizei element_array_buffer_size_;
   scoped_array<VertexAttribInfo> vertex_attrib_infos_;
   GLsizei collection_buffer_size_;
   scoped_array<int8> collection_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSideBufferHelper);
 };
 
+AlignedRingBuffer::~AlignedRingBuffer() {
+}
+
+TransferBuffer::TransferBuffer(
+    CommandBufferHelper* helper,
+    int32 buffer_id,
+    void* buffer,
+    size_t buffer_size,
+    size_t result_size,
+    unsigned int alignment)
+    : helper_(helper),
+      buffer_size_(buffer_size),
+      result_size_(result_size),
+      alignment_(alignment) {
+  Setup(buffer_id, buffer);
+}
+
+TransferBuffer::~TransferBuffer() {
+}
+
+void TransferBuffer::Setup(int32 buffer_id, void* buffer) {
+  GPU_CHECK(!ring_buffer_.get());
+  ring_buffer_.reset(new AlignedRingBuffer(
+      alignment_,
+      buffer_id,
+      result_size_,
+      buffer_size_ - result_size_,
+      helper_,
+      static_cast<char*>(buffer) + result_size_));
+  buffer_id_ = buffer_id;
+  result_buffer_ = buffer;
+  result_shm_offset_ = 0;
+}
+
+void TransferBuffer::Free() {
+  if (buffer_id_) {
+    // TODO(gman): should we check the memory is unused?
+    helper_->command_buffer()->DestroyTransferBuffer(buffer_id_);
+    buffer_id_ = 0;
+    result_buffer_ = NULL;
+    result_shm_offset_ = 0;
+    ring_buffer_.reset();
+  }
+}
+
+void TransferBuffer::AllocateRingBuffer() {
+  if (!buffer_id_) {
+    int32 id = helper_->command_buffer()->CreateTransferBuffer(
+        buffer_size_, -1);
+    GPU_CHECK_NE(-1, id);  // if it fails we're done.
+    gpu::Buffer shm = helper_->command_buffer()->GetTransferBuffer(id);
+    Setup(id, shm.ptr);
+  }
+}
+
+AlignedRingBuffer* TransferBuffer::GetBuffer() {
+  AllocateRingBuffer();
+  return ring_buffer_.get();
+}
+
+void* TransferBuffer::GetResultBuffer() {
+  AllocateRingBuffer();
+  GPU_CHECK(result_buffer_);
+  return result_buffer_;
+}
+
+int TransferBuffer::GetResultOffset() {
+  AllocateRingBuffer();
+  return result_shm_offset_;
+}
+
+int TransferBuffer::GetShmId() {
+  AllocateRingBuffer();
+  GPU_CHECK(buffer_id_);
+  return buffer_id_;
+}
+
 #if !defined(_MSC_VER)
 const size_t GLES2Implementation::kMaxSizeOfSimpleResult;
 #endif
 
 COMPILE_ASSERT(gpu::kInvalidResource == 0,
                INVALID_RESOURCE_NOT_0_AS_GL_EXPECTS);
 
 GLES2Implementation::GLES2Implementation(
       GLES2CmdHelper* helper,
       size_t transfer_buffer_size,
       void* transfer_buffer,
       int32 transfer_buffer_id,
       bool share_resources,
       bool bind_generates_resource)
     : helper_(helper),
       transfer_buffer_(
-          kStartingOffset,
-          transfer_buffer_size - kStartingOffset,
           helper,
-          static_cast<char*>(transfer_buffer) + kStartingOffset),
-      transfer_buffer_id_(transfer_buffer_id),
+          transfer_buffer_id,
+          transfer_buffer,
+          transfer_buffer_size,
+          GLES2Implementation::kStartingOffset,
+          GLES2Implementation::kAlignment),
       angle_pack_reverse_row_order_status(kUnknownExtensionStatus),
       pack_alignment_(4),
       unpack_alignment_(4),
       unpack_flip_y_(false),
       pack_reverse_row_order_(false),
       active_texture_unit_(0),
       bound_framebuffer_(0),
       bound_renderbuffer_(0),
       bound_array_buffer_id_(0),
       bound_element_array_buffer_id_(0),
       client_side_array_id_(0),
       client_side_element_array_id_(0),
       error_bits_(0),
       debug_(false),
       sharing_resources_(share_resources),
       bind_generates_resource_(bind_generates_resource) {
   GPU_CLIENT_LOG_CODE_BLOCK({
     debug_ = CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableGPUClientLogging);
   });
 
-  // Allocate space for simple GL results.
-  result_buffer_ = transfer_buffer;
-  result_shm_offset_ = 0;
   memset(&reserved_ids_, 0, sizeof(reserved_ids_));
 
   mapped_memory_.reset(new MappedMemoryManager(helper_));
   SetSharedMemoryChunkSizeMultiple(1024 * 1024 * 2);
 
   if (share_resources) {
     if (!bind_generates_resource) {
       for (int i = 0; i < id_namespaces::kNumIdNamespaces; ++i) {
         id_handlers_[i].reset(new StrictSharedIdHandler(
               this, static_cast<id_namespaces::IdNamespaces>(i)));
@@ skipping 61 matching lines @@
 
 void GLES2Implementation::SetSharedMemoryChunkSizeMultiple(
     unsigned int multiple) {
   mapped_memory_->set_chunk_size_multiple(multiple);
 }
 
 void GLES2Implementation::FreeUnusedSharedMemory() {
   mapped_memory_->FreeUnused();
 }
 
+void GLES2Implementation::FreeEverything() {
+  Finish();
+  FreeUnusedSharedMemory();
+  transfer_buffer_.Free();
+}
+
 void GLES2Implementation::WaitForCmd() {
   TRACE_EVENT0("gpu", "GLES2::WaitForCmd");
   helper_->CommandBufferHelper::Finish();
 }
 
 namespace {
 bool IsExtensionAvailable(GLES2Implementation* gles2, const char ext[]) {
   const char* extensions = reinterpret_cast<const char*>(
       gles2->GetString(GL_EXTENSIONS));
   int length = strlen(ext);
@@ skipping 33 matching lines @@
   GPU_CLIENT_LOG("returned " << GLES2Util::GetStringError(err));
   return err;
 }
 
 GLenum GLES2Implementation::GetGLError() {
   TRACE_EVENT0("gpu", "GLES2::GetGLError");
   // Check the GL error first, then our wrapped error.
   typedef gles2::GetError::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = GL_NO_ERROR;
-  helper_->GetError(result_shm_id(), result_shm_offset());
+  helper_->GetError(GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   GLenum error = *result;
   if (error == GL_NO_ERROR && error_bits_ != 0) {
     for (uint32 mask = 1; mask != 0; mask = mask << 1) {
       if ((error_bits_ & mask) != 0) {
         error = GLES2Util::GLErrorBitToGLError(mask);
         break;
       }
     }
   }
@@ skipping 14 matching lines @@
   error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
 }
 
 void GLES2Implementation::GetBucketContents(uint32 bucket_id,
                                             std::vector<int8>* data) {
   TRACE_EVENT0("gpu", "GLES2::GetBucketContents");
   GPU_DCHECK(data);
   typedef cmd::GetBucketSize::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = 0;
-  helper_->GetBucketSize(bucket_id, result_shm_id(), result_shm_offset());
+  helper_->GetBucketSize(bucket_id, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   uint32 size = *result;
   data->resize(size);
   if (size > 0u) {
-    uint32 max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+    AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+    uint32 max_size = transfer_buffer->GetLargestFreeOrPendingSize();
     uint32 offset = 0;
     while (size) {
       uint32 part_size = std::min(max_size, size);
-      void* buffer = transfer_buffer_.Alloc(part_size);
+      void* buffer = transfer_buffer->Alloc(part_size);
       helper_->GetBucketData(
           bucket_id, offset, part_size,
-          transfer_buffer_id_, transfer_buffer_.GetOffset(buffer));
+          transfer_buffer->GetShmId(),
+          transfer_buffer->GetOffset(buffer));
       WaitForCmd();
       memcpy(&(*data)[offset], buffer, part_size);
-      transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+      transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
       offset += part_size;
       size -= part_size;
     }
     // Free the bucket. This is not required but it does free up the memory.
     // and we don't have to wait for the result so from the client's perspective
     // it's cheap.
     helper_->SetBucketSize(bucket_id, 0);
   }
 }
 
 void GLES2Implementation::SetBucketContents(
     uint32 bucket_id, const void* data, size_t size) {
   GPU_DCHECK(data);
   helper_->SetBucketSize(bucket_id, size);
   if (size > 0u) {
-    uint32 max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+    AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+    uint32 max_size = transfer_buffer->GetLargestFreeOrPendingSize();
     uint32 offset = 0;
     while (size) {
       uint32 part_size = std::min(static_cast<size_t>(max_size), size);
-      void* buffer = transfer_buffer_.Alloc(part_size);
+      void* buffer = transfer_buffer->Alloc(part_size);
       memcpy(buffer, static_cast<const int8*>(data) + offset, part_size);
       helper_->SetBucketData(
           bucket_id, offset, part_size,
-          transfer_buffer_id_, transfer_buffer_.GetOffset(buffer));
-      transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+          transfer_buffer->GetShmId(),
+          transfer_buffer->GetOffset(buffer));
+      transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
       offset += part_size;
       size -= part_size;
     }
   }
 }
 
 void GLES2Implementation::SetBucketAsCString(
     uint32 bucket_id, const char* str) {
   // NOTE: strings are passed NULL terminated. That means the empty
   // string will have a size of 1 and no-string will have a size of 0
@@ skipping 228 matching lines @@
   GLuint namespace_id, GLuint id_offset, GLsizei n, GLuint* ids) {
   GPU_CLIENT_LOG("[" << this << "] glGenSharedIdsCHROMIUMTextures("
       << namespace_id << ", " << id_offset << ", " << n << ", " <<
       static_cast<void*>(ids) << ")");
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (GLsizei i = 0; i < n; ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << ids[i]);
     }
   });
   TRACE_EVENT0("gpu", "GLES2::GenSharedIdsCHROMIUM");
-  GLsizei max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  GLsizei max_size = transfer_buffer->GetLargestFreeOrPendingSize();
   GLsizei max_num_per = max_size / sizeof(ids[0]);
   while (n) {
     GLsizei num = std::min(n, max_num_per);
-    GLint* id_buffer = transfer_buffer_.AllocTyped<GLint>(num);
+    GLint* id_buffer = transfer_buffer->AllocTyped<GLint>(num);
     helper_->GenSharedIdsCHROMIUM(
         namespace_id, id_offset, num,
-        transfer_buffer_id_,
-        transfer_buffer_.GetOffset(id_buffer));
+        transfer_buffer->GetShmId(),
+        transfer_buffer->GetOffset(id_buffer));
     WaitForCmd();
     memcpy(ids, id_buffer, sizeof(*ids) * num);
-    transfer_buffer_.FreePendingToken(id_buffer, helper_->InsertToken());
+    transfer_buffer->FreePendingToken(id_buffer, helper_->InsertToken());
     n -= num;
     ids += num;
   }
 }
 
 void GLES2Implementation::DeleteSharedIdsCHROMIUM(
     GLuint namespace_id, GLsizei n, const GLuint* ids) {
   GPU_CLIENT_LOG("[" << this << "] glDeleteSharedIdsCHROMIUM("
       << namespace_id << ", " << n << ", "
       << static_cast<const void*>(ids) << ")");
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (GLsizei i = 0; i < n; ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << ids[i]);
     }
   });
   TRACE_EVENT0("gpu", "GLES2::DeleteSharedIdsCHROMIUM");
-  GLsizei max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  GLsizei max_size = transfer_buffer->GetLargestFreeOrPendingSize();
   GLsizei max_num_per = max_size / sizeof(ids[0]);
   while (n) {
     GLsizei num = std::min(n, max_num_per);
-    GLint* id_buffer = transfer_buffer_.AllocTyped<GLint>(num);
+    GLint* id_buffer = transfer_buffer->AllocTyped<GLint>(num);
     memcpy(id_buffer, ids, sizeof(*ids) * num);
     helper_->DeleteSharedIdsCHROMIUM(
         namespace_id, num,
-        transfer_buffer_id_,
-        transfer_buffer_.GetOffset(id_buffer));
+        transfer_buffer->GetShmId(),
+        transfer_buffer->GetOffset(id_buffer));
     WaitForCmd();
-    transfer_buffer_.FreePendingToken(id_buffer, helper_->InsertToken());
+    transfer_buffer->FreePendingToken(id_buffer, helper_->InsertToken());
     n -= num;
     ids += num;
   }
 }
 
 void GLES2Implementation::RegisterSharedIdsCHROMIUM(
     GLuint namespace_id, GLsizei n, const GLuint* ids) {
   GPU_CLIENT_LOG("[" << this << "] glRegisterSharedIdsCHROMIUM("
      << namespace_id << ", " << n << ", "
      << static_cast<const void*>(ids) << ")");
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (GLsizei i = 0; i < n; ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << ids[i]);
     }
   });
   TRACE_EVENT0("gpu", "GLES2::RegisterSharedIdsCHROMIUM");
-  GLsizei max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  GLsizei max_size = transfer_buffer->GetLargestFreeOrPendingSize();
   GLsizei max_num_per = max_size / sizeof(ids[0]);
   while (n) {
     GLsizei num = std::min(n, max_num_per);
-    GLint* id_buffer = transfer_buffer_.AllocTyped<GLint>(n);
+    GLint* id_buffer = transfer_buffer->AllocTyped<GLint>(n);
     memcpy(id_buffer, ids, sizeof(*ids) * n);
     helper_->RegisterSharedIdsCHROMIUM(
         namespace_id, n,
-        transfer_buffer_id_,
-        transfer_buffer_.GetOffset(id_buffer));
+        transfer_buffer->GetShmId(),
+        transfer_buffer->GetOffset(id_buffer));
     WaitForCmd();
-    transfer_buffer_.FreePendingToken(id_buffer, helper_->InsertToken());
+    transfer_buffer->FreePendingToken(id_buffer, helper_->InsertToken());
     n -= num;
     ids += num;
   }
 }
 
 void GLES2Implementation::BindAttribLocation(
   GLuint program, GLuint index, const char* name) {
   GPU_CLIENT_LOG("[" << this << "] glBindAttribLocation(" << program << ", "
       << index << ", " << name << ")");
   SetBucketAsString(kResultBucketId, name);
@@ skipping 12 matching lines @@
   if (client_side_buffer_helper_->GetAttribPointer(index, pname, ptr)) {
     return;
   }
 #endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 
   TRACE_EVENT0("gpu", "GLES2::GetVertexAttribPointerv");
   typedef gles2::GetVertexAttribPointerv::Result Result;
   Result* result = GetResultAs<Result*>();
   result->SetNumResults(0);
   helper_->GetVertexAttribPointerv(
-    index, pname, result_shm_id(), result_shm_offset());
+    index, pname, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(ptr);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
 }
 
 bool GLES2Implementation::DeleteProgramHelper(GLuint program) {
@@ skipping 20 matching lines @@
   return true;
 }
 
 GLint GLES2Implementation::GetAttribLocationHelper(
     GLuint program, const char* name) {
   typedef GetAttribLocationBucket::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = -1;
   SetBucketAsCString(kResultBucketId, name);
   helper_->GetAttribLocationBucket(
-      program, kResultBucketId, result_shm_id(), result_shm_offset());
+      program, kResultBucketId, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
   return *result;
 }
 
 GLint GLES2Implementation::GetAttribLocation(
     GLuint program, const char* name) {
   GPU_CLIENT_LOG("[" << this << "] glGetAttribLocation(" << program
       << ", " << name << ")");
   TRACE_EVENT0("gpu", "GLES2::GetAttribLocation");
   GLint loc = program_info_manager_->GetAttribLocation(this, program, name);
   GPU_CLIENT_LOG("returned " << loc);
   return loc;
 }
 
 GLint GLES2Implementation::GetUniformLocationHelper(
     GLuint program, const char* name) {
   typedef GetUniformLocationBucket::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = -1;
   SetBucketAsCString(kResultBucketId, name);
   helper_->GetUniformLocationBucket(program, kResultBucketId,
-                                    result_shm_id(), result_shm_offset());
+                                    GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
   return *result;
 }
 
 GLint GLES2Implementation::GetUniformLocation(
     GLuint program, const char* name) {
   GPU_CLIENT_LOG("[" << this << "] glGetUniformLocation(" << program
       << ", " << name << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformLocation");
@@ skipping 23 matching lines @@
       << length << ")");
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE, "glShaderBinary n < 0.");
     return;
   }
   if (length < 0) {
     SetGLError(GL_INVALID_VALUE, "glShaderBinary length < 0.");
     return;
   }
   GLsizei shader_id_size = n * sizeof(*shaders);
-  int8* buffer = transfer_buffer_.AllocTyped<int8>(shader_id_size + length);
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  int8* buffer = transfer_buffer->AllocTyped<int8>(shader_id_size + length);
   void* shader_ids = buffer;
   void* shader_data = buffer + shader_id_size;
   memcpy(shader_ids, shaders, shader_id_size);
   memcpy(shader_data, binary, length);
   helper_->ShaderBinary(
       n,
-      transfer_buffer_id_, transfer_buffer_.GetOffset(shader_ids),
+      transfer_buffer->GetShmId(),
+      transfer_buffer->GetOffset(shader_ids),
       binaryformat,
-      transfer_buffer_id_, transfer_buffer_.GetOffset(shader_data),
+      transfer_buffer->GetShmId(),
+      transfer_buffer->GetOffset(shader_data),
       length);
-  transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+  transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
 }
 
 void GLES2Implementation::PixelStorei(GLenum pname, GLint param) {
   GPU_CLIENT_LOG("[" << this << "] glPixelStorei("
       << GLES2Util::GetStringPixelStore(pname) << ", "
       << param << ")");
   switch (pname) {
     case GL_PACK_ALIGNMENT:
         pack_alignment_ = param;
         break;
@@ skipping 72 matching lines @@
   uint32 total_size = 1;
   for (GLsizei ii = 0; ii < count; ++ii) {
     if (source[ii]) {
       total_size += (length && length[ii] >= 0) ?
           static_cast<size_t>(length[ii]) : strlen(source[ii]);
     }
   }
 
   // Concatenate all the strings in to a bucket on the service.
   helper_->SetBucketSize(kResultBucketId, total_size);
-  uint32 max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  uint32 max_size = transfer_buffer->GetLargestFreeOrPendingSize();
   uint32 offset = 0;
   for (GLsizei ii = 0; ii <= count; ++ii) {
     const char* src = ii < count ? source[ii] : "";
     if (src) {
       uint32 size = ii < count ?
           (length ? static_cast<size_t>(length[ii]) : strlen(src)) : 1;
       while (size) {
         uint32 part_size = std::min(size, max_size);
-        void* buffer = transfer_buffer_.Alloc(part_size);
+        void* buffer = transfer_buffer->Alloc(part_size);
         memcpy(buffer, src, part_size);
         helper_->SetBucketData(kResultBucketId, offset, part_size,
-                               transfer_buffer_id_,
-                               transfer_buffer_.GetOffset(buffer));
-        transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+                               transfer_buffer->GetShmId(),
+                               transfer_buffer->GetOffset(buffer));
+        transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
         offset += part_size;
         src += part_size;
         size -= part_size;
       }
     }
   }
 
   GPU_DCHECK_EQ(total_size, offset);
 
   helper_->ShaderSourceBucket(shader, kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
 void GLES2Implementation::BufferData(
     GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
   GPU_CLIENT_LOG("[" << this << "] glBufferData("
       << GLES2Util::GetStringBufferTarget(target) << ", "
       << size << ", "
       << static_cast<const void*>(data) << ", "
       << GLES2Util::GetStringBufferUsage(usage) << ")");
-  GLsizeiptr max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  GLsizeiptr max_size = transfer_buffer->GetLargestFreeOrPendingSize();
   if (size > max_size || !data) {
     helper_->BufferData(target, size, 0, 0, usage);
     if (data != NULL) {
       BufferSubData(target, 0, size, data);
     }
     return;
   }
 
-  void* buffer = transfer_buffer_.Alloc(size);
+  void* buffer = transfer_buffer->Alloc(size);
   memcpy(buffer, data, size);
   helper_->BufferData(
       target,
       size,
-      transfer_buffer_id_,
-      transfer_buffer_.GetOffset(buffer),
+      transfer_buffer->GetShmId(),
+      transfer_buffer->GetOffset(buffer),
       usage);
-  transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+  transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
 }
 
 void GLES2Implementation::BufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
   GPU_CLIENT_LOG("[" << this << "] glBufferSubData("
       << GLES2Util::GetStringBufferTarget(target) << ", "
       << offset << ", " << size << ", "
       << static_cast<const void*>(data) << ")");
   if (size == 0) {
     return;
   }
 
   if (size < 0) {
     SetGLError(GL_INVALID_VALUE, "glBufferSubData: size < 0");
     return;
   }
 
   const int8* source = static_cast<const int8*>(data);
-  GLsizeiptr max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  GLsizeiptr max_size = transfer_buffer->GetLargestFreeOrPendingSize();
   while (size) {
     GLsizeiptr part_size = std::min(size, max_size);
-    void* buffer = transfer_buffer_.Alloc(part_size);
+    void* buffer = transfer_buffer->Alloc(part_size);
     memcpy(buffer, source, part_size);
     helper_->BufferSubData(target, offset, part_size,
-                           transfer_buffer_id_,
-                           transfer_buffer_.GetOffset(buffer));
-    transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+                           transfer_buffer->GetShmId(),
+                           transfer_buffer->GetOffset(buffer));
+    transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
     offset += part_size;
     source += part_size;
     size -= part_size;
   }
 }
 
 void GLES2Implementation::CompressedTexImage2D(
     GLenum target, GLint level, GLenum internalformat, GLsizei width,
     GLsizei height, GLint border, GLsizei image_size, const void* data) {
   GPU_CLIENT_LOG("[" << this << "] glCompressedTexImage2D("
@@ skipping 99 matching lines @@
     return;
   }
   uint32 size;
   if (!GLES2Util::ComputeImageDataSize(
       width, height, format, type, unpack_alignment_, &size)) {
     SetGLError(GL_INVALID_VALUE, "glTexImage2D: image size too large");
     return;
   }
 
   // Check if we can send it all at once.
-  unsigned int max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  unsigned int max_size = transfer_buffer->GetLargestFreeOrPendingSize();
   if (size > max_size || !pixels) {
     // No, so send it using TexSubImage2D.
     helper_->TexImage2D(
        target, level, internalformat, width, height, border, format, type,
        0, 0);
     if (pixels) {
       TexSubImage2DImpl(
           target, level, 0, 0, width, height, format, type, pixels, GL_TRUE);
     }
     return;
   }
 
-  void* buffer = transfer_buffer_.Alloc(size);
+  void* buffer = transfer_buffer->Alloc(size);
   bool copy_success = true;
   if (unpack_flip_y_) {
     copy_success = CopyRectToBufferFlipped(
         pixels, width, height, format, type, buffer);
   } else {
     memcpy(buffer, pixels, size);
   }
 
   if (copy_success) {
     helper_->TexImage2D(
         target, level, internalformat, width, height, border, format, type,
-        transfer_buffer_id_, transfer_buffer_.GetOffset(buffer));
+        transfer_buffer->GetShmId(), transfer_buffer->GetOffset(buffer));
   }
-  transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+  transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
 }
 
 void GLES2Implementation::TexSubImage2D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLenum type, const void* pixels) {
   GPU_CLIENT_LOG("[" << this << "] glTexSubImage2D("
       << GLES2Util::GetStringTextureTarget(target) << ", "
       << level << ", "
       << xoffset << ", " << yoffset << ", "
       << width << ", " << height << ", "
@@ skipping 10 matching lines @@
     GLsizei height, GLenum format, GLenum type, const void* pixels,
     GLboolean internal) {
   if (level < 0 || height < 0 || width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D dimension < 0");
     return;
   }
   if (height == 0 || width == 0) {
     return;
   }
   const int8* source = static_cast<const int8*>(pixels);
-  GLsizeiptr max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  GLsizeiptr max_size = transfer_buffer->GetLargestFreeOrPendingSize();
   uint32 temp_size;
   if (!GLES2Util::ComputeImageDataSize(
       width, 1, format, type, unpack_alignment_, &temp_size)) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
     return;
   }
   GLsizeiptr unpadded_row_size = temp_size;
   if (!GLES2Util::ComputeImageDataSize(
       width, 2, format, type, unpack_alignment_, &temp_size)) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
     return;
   }
   GLsizeiptr padded_row_size = temp_size - unpadded_row_size;
   if (padded_row_size < 0 || unpadded_row_size < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D: size to large");
     return;
   }
 
   GLint original_yoffset = yoffset;
   if (padded_row_size <= max_size) {
     // Transfer by rows.
     GLint max_rows = max_size / std::max(padded_row_size,
                                          static_cast<GLsizeiptr>(1));
     while (height) {
       GLint num_rows = std::min(height, max_rows);
       GLsizeiptr part_size =
           (num_rows - 1) * padded_row_size + unpadded_row_size;
-      void* buffer = transfer_buffer_.Alloc(part_size);
+      void* buffer = transfer_buffer->Alloc(part_size);
       GLint y;
       if (unpack_flip_y_) {
         CopyRectToBufferFlipped(
             source, width, num_rows, format, type, buffer);
         // GPU_DCHECK(copy_success);  // can't check this because bot fails!
         y = original_yoffset + height - num_rows;
       } else {
         memcpy(buffer, source, part_size);
         y = yoffset;
       }
       helper_->TexSubImage2D(
           target, level, xoffset, y, width, num_rows, format, type,
-          transfer_buffer_id_, transfer_buffer_.GetOffset(buffer), internal);
-      transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+          transfer_buffer->GetShmId(),
+          transfer_buffer->GetOffset(buffer), internal);
+      transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
       yoffset += num_rows;
       source += num_rows * padded_row_size;
       height -= num_rows;
     }
   } else {
     // Transfer by sub rows. Because GL has no maximum texture dimensions.
     uint32 temp;
     GLES2Util::ComputeImageDataSize(
        1, 1, format, type, unpack_alignment_, &temp);
     GLsizeiptr element_size = temp;
     max_size -= max_size % element_size;
     GLint max_sub_row_pixels = max_size / element_size;
     for (; height; --height) {
       GLint temp_width = width;
       GLint temp_xoffset = xoffset;
       const int8* row_source = source;
       while (temp_width) {
         GLint num_pixels = std::min(width, max_sub_row_pixels);
         GLsizeiptr part_size = num_pixels * element_size;
-        void* buffer = transfer_buffer_.Alloc(part_size);
+        void* buffer = transfer_buffer->Alloc(part_size);
         memcpy(buffer, row_source, part_size);
         GLint y = unpack_flip_y_ ? (original_yoffset + height - 1) : yoffset;
         helper_->TexSubImage2D(
             target, level, temp_xoffset, y, num_pixels, 1, format, type,
-            transfer_buffer_id_, transfer_buffer_.GetOffset(buffer), internal);
-        transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+            transfer_buffer->GetShmId(),
+            transfer_buffer->GetOffset(buffer), internal);
+        transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
         row_source += part_size;
         temp_xoffset += num_pixels;
         temp_width -= num_pixels;
       }
       ++yoffset;
       source += padded_row_size;
     }
   }
 }
 
 bool GLES2Implementation::GetActiveAttribHelper(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   typedef gles2::GetActiveAttrib::Result Result;
-  Result* result = static_cast<Result*>(result_buffer_);
+  Result* result = GetResultAs<Result*>();
   // Set as failed so if the command fails we'll recover.
   result->success = false;
   helper_->GetActiveAttrib(program, index, kResultBucketId,
-                           result_shm_id(), result_shm_offset());
+                           GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   if (result->success) {
     if (size) {
       *size = result->size;
     }
     if (type) {
       *type = result->type;
     }
     if (length || name) {
       std::vector<int8> str;
@@ skipping 41 matching lines @@
     }
   }
 }
 
 bool GLES2Implementation::GetActiveUniformHelper(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   typedef gles2::GetActiveUniform::Result Result;
-  Result* result = static_cast<Result*>(result_buffer_);
+  Result* result = GetResultAs<Result*>();
   // Set as failed so if the command fails we'll recover.
   result->success = false;
   helper_->GetActiveUniform(program, index, kResultBucketId,
-                            result_shm_id(), result_shm_offset());
+                            GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   if (result->success) {
     if (size) {
       *size = result->size;
     }
     if (type) {
       *type = result->type;
     }
     if (length || name) {
       std::vector<int8> str;
@@ skipping 48 matching lines @@
       << program << ", " << maxcount << ", "
       << static_cast<const void*>(count) << ", "
       << static_cast<const void*>(shaders) << ", ");
   if (maxcount < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetAttachedShaders: maxcount < 0");
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetAttachedShaders");
   typedef gles2::GetAttachedShaders::Result Result;
   uint32 size = Result::ComputeSize(maxcount);
-  Result* result = transfer_buffer_.AllocTyped<Result>(size);
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  Result* result = transfer_buffer->AllocTyped<Result>(size);
   result->SetNumResults(0);
   helper_->GetAttachedShaders(
     program,
-    transfer_buffer_id_,
-    transfer_buffer_.GetOffset(result),
+    transfer_buffer->GetShmId(),
+    transfer_buffer->GetOffset(result),
     size);
   int32 token = helper_->InsertToken();
   WaitForCmd();
   if (count) {
     *count = result->GetNumResults();
   }
   result->CopyResult(shaders);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
-  transfer_buffer_.FreePendingToken(result, token);
+  transfer_buffer->FreePendingToken(result, token);
 }
 
 void GLES2Implementation::GetShaderPrecisionFormat(
     GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
   GPU_CLIENT_LOG("[" << this << "] glGetShaderPrecisionFormat("
       << GLES2Util::GetStringShaderType(shadertype) << ", "
       << GLES2Util::GetStringShaderPrecision(precisiontype) << ", "
       << static_cast<const void*>(range) << ", "
       << static_cast<const void*>(precision) << ", ");
   TRACE_EVENT0("gpu", "GLES2::GetShaderPrecisionFormat");
   typedef gles2::GetShaderPrecisionFormat::Result Result;
-  Result* result = static_cast<Result*>(result_buffer_);
+  Result* result = GetResultAs<Result*>();
   result->success = false;
   helper_->GetShaderPrecisionFormat(
-    shadertype, precisiontype, result_shm_id(), result_shm_offset());
+    shadertype, precisiontype, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   if (result->success) {
     if (range) {
       range[0] = result->min_range;
       range[1] = result->max_range;
       GPU_CLIENT_LOG("  min_range: " << range[0]);
       GPU_CLIENT_LOG("  min_range: " << range[1]);
     }
     if (precision) {
       precision[0] = result->precision;
@@ skipping 48 matching lines @@
   return reinterpret_cast<const GLubyte*>(result);
 }
 
 void GLES2Implementation::GetUniformfv(
     GLuint program, GLint location, GLfloat* params) {
   GPU_CLIENT_LOG("[" << this << "] glGetUniformfv("
       << program << ", " << location << ", "
       << static_cast<const void*>(params) << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformfv");
   typedef gles2::GetUniformfv::Result Result;
-  Result* result = static_cast<Result*>(result_buffer_);
+  Result* result = GetResultAs<Result*>();
   result->SetNumResults(0);
   helper_->GetUniformfv(
-      program, location, result_shm_id(), result_shm_offset());
+      program, location, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
 }
 
 void GLES2Implementation::GetUniformiv(
     GLuint program, GLint location, GLint* params) {
   GPU_CLIENT_LOG("[" << this << "] glGetUniformiv("
       << program << ", " << location << ", "
       << static_cast<const void*>(params) << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformiv");
   typedef gles2::GetUniformiv::Result Result;
-  Result* result = static_cast<Result*>(result_buffer_);
+  Result* result = GetResultAs<Result*>();
   result->SetNumResults(0);
   helper_->GetUniformiv(
-      program, location, result_shm_id(), result_shm_offset());
+      program, location, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
-  static_cast<gles2::GetUniformfv::Result*>(result_buffer_)->CopyResult(params);
+  GetResultAs<gles2::GetUniformfv::Result*>()->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
 }
 
 void GLES2Implementation::ReadPixels(
     GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format,
     GLenum type, void* pixels) {
@@ skipping 12 matching lines @@
   }
 
   // glReadPixel pads the size of each row of pixels by an amount specified by
   // glPixelStorei. So, we have to take that into account both in the fact that
   // the pixels returned from the ReadPixel command will include that padding
   // and that when we copy the results to the user's buffer we need to not
   // write those padding bytes but leave them as they are.
 
   TRACE_EVENT0("gpu", "GLES2::ReadPixels");
   typedef gles2::ReadPixels::Result Result;
-  Result* result = static_cast<Result*>(result_buffer_);
+  Result* result = GetResultAs<Result*>();
   int8* dest = reinterpret_cast<int8*>(pixels);
-  GLsizeiptr max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  GLsizeiptr max_size = transfer_buffer->GetLargestFreeOrPendingSize();
   uint32 temp_size;
   if (!GLES2Util::ComputeImageDataSize(
       width, 1, format, type, pack_alignment_, &temp_size)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels: size too large.");
     return;
   }
   GLsizeiptr unpadded_row_size = temp_size;
   if (!GLES2Util::ComputeImageDataSize(
       width, 2, format, type, pack_alignment_, &temp_size)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels: size too large.");
@@ skipping 10 matching lines @@
     // The max rows we can transfer.
     GLint max_rows = max_size / std::max(padded_row_size,
                                          static_cast<GLsizeiptr>(1));
     while (height) {
       // Compute how many rows to transfer.
       GLint num_rows = std::min(height, max_rows);
       // Compute how much space those rows will take. The last row will not
       // include padding.
       GLsizeiptr part_size =
           unpadded_row_size + padded_row_size * (num_rows - 1);
-      void* buffer = transfer_buffer_.Alloc(part_size);
+      void* buffer = transfer_buffer->Alloc(part_size);
       *result = 0;  // mark as failed.
       helper_->ReadPixels(
           xoffset, yoffset, width, num_rows, format, type,
-          transfer_buffer_id_, transfer_buffer_.GetOffset(buffer),
-          result_shm_id(), result_shm_offset());
+          transfer_buffer->GetShmId(), transfer_buffer->GetOffset(buffer),
+          GetResultShmId(), GetResultShmOffset());
       WaitForCmd();
       if (*result != 0) {
         // when doing a y-flip we have to iterate through top-to-bottom chunks
         // of the dst. The service side handles reversing the rows within a
         // chunk.
         int8* rows_dst;
         if (pack_reverse_row_order_) {
             rows_dst = dest + (height - num_rows) * padded_row_size;
         } else {
             rows_dst = dest;
         }
         // We have to copy 1 row at a time to avoid writing pad bytes.
         const int8* src = static_cast<const int8*>(buffer);
         for (GLint yy = 0; yy < num_rows; ++yy) {
           memcpy(rows_dst, src, unpadded_row_size);
           rows_dst += padded_row_size;
           src += padded_row_size;
         }
         if (!pack_reverse_row_order_) {
           dest = rows_dst;
         }
       }
-      transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+      transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
       // If it was not marked as successful exit.
       if (*result == 0) {
         return;
       }
       yoffset += num_rows;
       height -= num_rows;
     }
   } else {
     // Transfer by sub rows. Because GL has no maximum texture dimensions.
     GLES2Util::ComputeImageDataSize(
        1, 1, format, type, pack_alignment_, &temp_size);
     GLsizeiptr element_size = temp_size;
     max_size -= max_size % element_size;
     GLint max_sub_row_pixels = max_size / element_size;
     if (pack_reverse_row_order_) {
       // start at the last row when flipping y.
       dest = dest + (height - 1) * padded_row_size;
     }
     for (; height; --height) {
       GLint temp_width = width;
       GLint temp_xoffset = xoffset;
       int8* row_dest = dest;
       while (temp_width) {
         GLint num_pixels = std::min(width, max_sub_row_pixels);
         GLsizeiptr part_size = num_pixels * element_size;
-        void* buffer = transfer_buffer_.Alloc(part_size);
+        void* buffer = transfer_buffer->Alloc(part_size);
         *result = 0;  // mark as failed.
         helper_->ReadPixels(
             temp_xoffset, yoffset, temp_width, 1, format, type,
-            transfer_buffer_id_, transfer_buffer_.GetOffset(buffer),
-            result_shm_id(), result_shm_offset());
+            transfer_buffer->GetShmId(),
+            transfer_buffer->GetOffset(buffer),
+            GetResultShmId(), GetResultShmOffset());
         WaitForCmd();
         if (*result != 0) {
           memcpy(row_dest, buffer, part_size);
         }
-        transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+        transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
         // If it was not marked as successful exit.
         if (*result == 0) {
           return;
         }
         row_dest += part_size;
         temp_xoffset += num_pixels;
         temp_width -= num_pixels;
       }
       ++yoffset;
       dest += pack_reverse_row_order_ ? -padded_row_size : padded_row_size;
@@ skipping 267 matching lines @@
   if (GetVertexAttribHelper(index, pname, &value)) {
     *params = static_cast<float>(value);
     return;
   }
 #endif
   TRACE_EVENT0("gpu", "GLES2::GetVertexAttribfv");
   typedef GetVertexAttribfv::Result Result;
   Result* result = GetResultAs<Result*>();
   result->SetNumResults(0);
   helper_->GetVertexAttribfv(
-      index, pname, result_shm_id(), result_shm_offset());
+      index, pname, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
 }
 
 void GLES2Implementation::GetVertexAttribiv(
     GLuint index, GLenum pname, GLint* params) {
   GPU_CLIENT_LOG("[" << this << "] glGetVertexAttribiv("
       << index << ", "
       << GLES2Util::GetStringVertexAttribute(pname) << ", "
       << static_cast<const void*>(params) << ")");
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   uint32 value = 0;
   if (GetVertexAttribHelper(index, pname, &value)) {
     *params = value;
     return;
   }
 #endif
   TRACE_EVENT0("gpu", "GLES2::GetVertexAttribiv");
   typedef GetVertexAttribiv::Result Result;
   Result* result = GetResultAs<Result*>();
   result->SetNumResults(0);
   helper_->GetVertexAttribiv(
-      index, pname, result_shm_id(), result_shm_offset());
+      index, pname, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
 }
 
 GLboolean GLES2Implementation::EnableFeatureCHROMIUM(
     const char* feature) {
   GPU_CLIENT_LOG("[" << this << "] glEnableFeatureCHROMIUM("
                  << feature << ")");
   TRACE_EVENT0("gpu", "GLES2::EnableFeatureCHROMIUM");
   typedef EnableFeatureCHROMIUM::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = 0;
   SetBucketAsCString(kResultBucketId, feature);
   helper_->EnableFeatureCHROMIUM(
-      kResultBucketId, result_shm_id(), result_shm_offset());
+      kResultBucketId, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
   GPU_CLIENT_LOG("   returned " << GLES2Util::GetStringBool(*result));
   return *result;
 }
 
 void* GLES2Implementation::MapBufferSubDataCHROMIUM(
     GLuint target, GLintptr offset, GLsizeiptr size, GLenum access) {
   GPU_CLIENT_LOG("[" << this << "] glMapBufferSubDataCHROMIUM("
       << target << ", " << offset << ", " << size << ", "
@@ skipping 197 matching lines @@
   }
   for (int ii = 0; ii < num_results; ++ii) {
     if (results[ii] != 0) {
       SetGLError(GL_INVALID_VALUE,
                  "glGetMultipleIntegervCHROMIUM: results not set to zero.");
       return;
     }
   }
   uint32 size_needed =
       count * sizeof(pnames[0]) + num_results * sizeof(results[0]);
-  void* buffer = transfer_buffer_.Alloc(size_needed);
+  AlignedRingBuffer* transfer_buffer = transfer_buffer_.GetBuffer();
+  void* buffer = transfer_buffer->Alloc(size_needed);
   GLenum* pnames_buffer = static_cast<GLenum*>(buffer);
   void* results_buffer = pnames_buffer + count;
   memcpy(pnames_buffer, pnames, count * sizeof(GLenum));
   memset(results_buffer, 0, num_results * sizeof(GLint));
   helper_->GetMultipleIntegervCHROMIUM(
-      transfer_buffer_id_, transfer_buffer_.GetOffset(pnames_buffer),
+      transfer_buffer->GetShmId(),
+      transfer_buffer->GetOffset(pnames_buffer),
       count,
-      transfer_buffer_id_, transfer_buffer_.GetOffset(results_buffer),
+      transfer_buffer->GetShmId(),
+      transfer_buffer->GetOffset(results_buffer),
       size);
   WaitForCmd();
   memcpy(results, results_buffer, size);
   // TODO(gman): We should be able to free without a token.
-  transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+  transfer_buffer->FreePendingToken(buffer, helper_->InsertToken());
   GPU_CLIENT_LOG("  returned");
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int i = 0; i < num_results; ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << (results[i]));
     }
   });
 }
 
 void GLES2Implementation::GetProgramInfoCHROMIUMHelper(
     GLuint program, std::vector<int8>* result) {
@@ skipping 36 matching lines @@
 
 GLuint GLES2Implementation::CreateStreamTextureCHROMIUM(GLuint texture) {
   GPU_CLIENT_LOG("[" << this << "] CreateStreamTextureCHROMIUM("
       << texture << ")");
   TRACE_EVENT0("gpu", "GLES2::CreateStreamTextureCHROMIUM");
   typedef CreateStreamTextureCHROMIUM::Result Result;
   Result* result = GetResultAs<Result*>();
   *result = GL_ZERO;
 
   helper_->CreateStreamTextureCHROMIUM(texture,
-                                       result_shm_id(),
-                                       result_shm_offset());
+                                       GetResultShmId(),
+                                       GetResultShmOffset());
   WaitForCmd();
 
   return *result;
 }
 
 void GLES2Implementation::DestroyStreamTextureCHROMIUM(GLuint texture) {
   GPU_CLIENT_LOG("[" << this << "] DestroyStreamTextureCHROMIUM("
       << texture << ")");
   TRACE_EVENT0("gpu", "GLES2::DestroyStreamTextureCHROMIUM");
   helper_->DestroyStreamTextureCHROMIUM(texture);
@@ skipping 10 matching lines @@
   helper_->PostSubBufferCHROMIUM(x, y, width, height);
   helper_->CommandBufferHelper::Flush();
   if (swap_buffers_tokens_.size() > kMaxSwapBuffers + 1) {
     helper_->WaitForToken(swap_buffers_tokens_.front());
     swap_buffers_tokens_.pop();
   }
 }
 
 }  // namespace gles2
 }  // namespace gpu