Updates GLES Imlementation to use Antoine's cool

FencedAllocator to manage the transfer buffer
with less waiting.

Also updates glBufferData to use glBufferSubData
to send data as well as glTexImage2D to use
glTexSubImage2D. These make it possible to
pass any size image or buffer data.

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

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

5 files changed, 244 insertions, 204 deletions

diff --git a/o3d/gpu/command_buffer/build_gles2_cmd_buffer.py b/o3d/gpu/command_buffer/build_gles2_cmd_buffer.py
index 0e55a45..0d9a7e8 100644
--- a/o3d/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/o3d/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -1205,13 +1205,14 @@ class GETnHandler(TypeHandler):
     all_but_last_args = func.GetOriginalArgs()[:-1]
     arg_string = (
         ", ".join(["%s" % arg.name for arg in all_but_last_args]))
-    file.Write("  helper_->%s(%s, shared_memory_.GetId(), 0);\n" %
+    file.Write("  helper_->%s(%s, result_shm_id(), result_shm_offset());\n" %
                (func.name, arg_string))
-    file.Write("  int32 token = helper_->InsertToken();\n")
-    file.Write("  helper_->WaitForToken(token);\n")
+    file.Write("  WaitForCmd();\n")
     file.Write("  GLsizei num_values = util_.GLGetNumValuesReturned(pname);\n")
-    file.Write("  memcpy(params, shared_memory_.GetAddress(0),\n")
-    file.Write("         num_values * sizeof(*params));\n")
+    file.Write(
+        "  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);\n")
+    file.Write(
+        "  memcpy(params, result_buffer_, num_values * sizeof(*params));\n")
     file.Write("}\n")
     file.Write("\n")
 
@@ -1879,11 +1880,10 @@ class IsHandler(TypeHandler):
     comma = ""
     if len(arg_string) > 0:
       comma = ", "
-    file.Write("  helper_->%s(%s%sshared_memory_.GetId(), 0);\n" %
+    file.Write("  helper_->%s(%s%sresult_shm_id(), result_shm_offset());\n" %
                (func.name, arg_string, comma))
-    file.Write("  int32 token = helper_->InsertToken();\n")
-    file.Write("  helper_->WaitForToken(token);\n")
-    file.Write("  return *shared_memory_.GetAddressAs<%s*>(0);\n" %
+    file.Write("  WaitForCmd();\n")
+    file.Write("  return GetResultAs<%s>();\n" %
                func.return_type)
     file.Write("}\n")
     file.Write("\n")
diff --git a/o3d/gpu/command_buffer/client/gles2_demo.cc b/o3d/gpu/command_buffer/client/gles2_demo.cc
index a37c199..1595ea3 100644
--- a/o3d/gpu/command_buffer/client/gles2_demo.cc
+++ b/o3d/gpu/command_buffer/client/gles2_demo.cc
@@ -84,6 +84,7 @@ bool GLES2Demo::Setup(NPP npp, void* hwnd, int32 size) {
   }
 
   gles2::g_gl_impl = new GLES2Implementation(helper,
+                                             transfer_buffer_size,
                                              transfer_buffer,
                                              transfer_buffer_id);
 
diff --git a/o3d/gpu/command_buffer/client/gles2_implementation.cc b/o3d/gpu/command_buffer/client/gles2_implementation.cc
index afc85a6..1208a57 100644
--- a/o3d/gpu/command_buffer/client/gles2_implementation.cc
+++ b/o3d/gpu/command_buffer/client/gles2_implementation.cc
@@ -14,16 +14,21 @@ namespace gles2 {
 
 GLES2Implementation::GLES2Implementation(
       GLES2CmdHelper* helper,
+      size_t transfer_buffer_size,
       void* transfer_buffer,
-      int transfer_buffer_id)
+      int32 transfer_buffer_id)
     : util_(0),  // TODO(gman): Get real number of compressed texture formats.
       helper_(helper),
-      shared_memory_(transfer_buffer, transfer_buffer_id),
+      transfer_buffer_(transfer_buffer_size, helper, transfer_buffer),
+      transfer_buffer_id_(transfer_buffer_id),
       pack_alignment_(4),
       unpack_alignment_(4) {
   // Eat 1 id so we start at 1 instead of 0.
   GLuint eat;
   MakeIds(1, &eat);
+  // Allocate space for simple GL results.
+  result_buffer_ = transfer_buffer_.Alloc(kMaxSizeOfSimpleResult);
+  result_shm_offset_ = transfer_buffer_.GetOffset(result_buffer_);
 }
 
 void GLES2Implementation::MakeIds(GLsizei n, GLuint* ids) {
@@ -38,6 +43,11 @@ void GLES2Implementation::FreeIds(GLsizei n, const GLuint* ids) {
   }
 }
 
+void GLES2Implementation::WaitForCmd() {
+  int32 token = helper_->InsertToken();
+  helper_->WaitForToken(token);
+}
+
 void GLES2Implementation::DrawElements(
     GLenum mode, GLsizei count, GLenum type, const void* indices) {
   helper_->DrawElements(mode, count, type, reinterpret_cast<GLuint>(indices));
@@ -45,19 +55,18 @@ void GLES2Implementation::DrawElements(
 
 GLint GLES2Implementation::GetAttribLocation(
     GLuint program, const char* name) {
-  helper_->GetAttribLocationImmediate(program, name, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
-  return *shared_memory_.GetAddressAs<GLint*>(0);
+  helper_->GetAttribLocationImmediate(
+      program, name, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  return GetResultAs<GLint>();
 }
 
 GLint GLES2Implementation::GetUniformLocation(
     GLuint program, const char* name) {
   helper_->GetUniformLocationImmediate(
-      program, name, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
-  return *shared_memory_.GetAddressAs<GLint*>(0);
+      program, name, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  return GetResultAs<GLint>();
 }
 
 void GLES2Implementation::PixelStorei(GLenum pname, GLint param) {
@@ -83,107 +92,158 @@ void GLES2Implementation::VertexAttribPointer(
 }
 
 void GLES2Implementation::ShaderSource(
-    GLuint shader, GLsizei count, const char** string, const GLint* length) {
+    GLuint shader, GLsizei count, const char** source, const GLint* length) {
   // TODO(gman): change to use buckets and check that there is enough room.
-  uint32* offsets = shared_memory_.GetAddressAs<uint32*>(0);
-  char* strings = reinterpret_cast<char*>(offsets);
 
+  // Compute the total size.
+  uint32 total_size = count * sizeof(total_size);
+  for (GLsizei ii = 0; ii < count; ++ii) {
+    total_size += length ? length[ii] : strlen(source[ii]);
+  }
+
+  // Create string table in transfer buffer.
+  char* strings = transfer_buffer_.AllocTyped<char>(total_size);
+  uint32* offsets = reinterpret_cast<uint32*>(strings);
   uint32 offset = count * sizeof(*offsets);
   for (GLsizei ii = 0; ii < count; ++ii) {
-    uint32 len = length ? length[ii] : strlen(string[ii]);
-    memcpy(strings + offset, string[ii], len);
+    uint32 len = length ? length[ii] : strlen(source[ii]);
+    memcpy(strings + offset, source[ii], len);
     offset += len;
     offsets[ii] = offset;
   }
 
-  helper_->ShaderSource(shader, count, shared_memory_.GetId(), 0, offset);
-  // TODO(gman): Should insert token but not wait until we need shared memory
-  //     again. Really, I should implement a shared memory manager that puts
-  //     things in the next unused part of shared memory and only blocks
-  //     when it needs more memory.
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->ShaderSource(shader, count,
+                        transfer_buffer_id_,
+                        transfer_buffer_.GetOffset(strings), offset);
+  transfer_buffer_.FreePendingToken(strings, helper_->InsertToken());
 }
 
 void GLES2Implementation::BufferData(
     GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
-  // TODO(gman): Switch to use buckets alwayst or at least if no room in shared
-  //    memory.
-  if (data == NULL) {
-    helper_->BufferData(target, size, 0, 0, usage);
-  } else {
-    memcpy(shared_memory_.GetAddress(0), data, size);
-    helper_->BufferData(target, size, shared_memory_.GetId(), 0, usage);
-    int32 token = helper_->InsertToken();
-    helper_->WaitForToken(token);
+  // NOTE: Should this be optimized for the case where we can call BufferData
+  //    with the actual data in the case of our transfer buffer being big
+  //    enough?
+  helper_->BufferData(target, size, 0, 0, usage);
+  if (data != NULL) {
+    BufferSubData(target, 0, size, data);
   }
 }
 
 void GLES2Implementation::BufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
-  // TODO(gman): Switch to use buckets alwayst or at least if no room in shared
-  //    memory.
-  memcpy(shared_memory_.GetAddress(0), data, size);
-  helper_->BufferSubData(target, offset, size, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  const int8* source = static_cast<const int8*>(data);
+  GLsizeiptr max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+  while (size) {
+    GLsizeiptr part_size = std::min(size, max_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());
+    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 imageSize, const void* data) {
+    GLsizei height, GLint border, GLsizei image_size, const void* data) {
   // TODO(gman): Switch to use buckets alwayst or at least if no room in shared
   //    memory.
-  memcpy(shared_memory_.GetAddress(0), data, imageSize);
+  DCHECK_LE(image_size,
+            static_cast<GLsizei>(
+                transfer_buffer_.GetLargestFreeOrPendingSize()));
+  void* buffer = transfer_buffer_.Alloc(image_size);
+  memcpy(buffer, data, image_size);
   helper_->CompressedTexImage2D(
-      target, level, internalformat, width, height, border, imageSize,
-      shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+      target, level, internalformat, width, height, border, image_size,
+      transfer_buffer_id_, transfer_buffer_.GetOffset(buffer));
+  transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
 }
 
 void GLES2Implementation::CompressedTexSubImage2D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
-    GLsizei height, GLenum format, GLsizei imageSize, const void* data) {
+    GLsizei height, GLenum format, GLsizei image_size, const void* data) {
   // TODO(gman): Switch to use buckets alwayst or at least if no room in shared
   //    memory.
-  memcpy(shared_memory_.GetAddress(0), data, imageSize);
+  DCHECK_LE(image_size,
+            static_cast<GLsizei>(
+                transfer_buffer_.GetLargestFreeOrPendingSize()));
+  void* buffer = transfer_buffer_.Alloc(image_size);
+  memcpy(buffer, data, image_size);
   helper_->CompressedTexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format, imageSize,
-      shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+      target, level, xoffset, yoffset, width, height, format, image_size,
+      transfer_buffer_id_, transfer_buffer_.GetOffset(buffer));
+  transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
 }
 
 void GLES2Implementation::TexImage2D(
     GLenum target, GLint level, GLint internalformat, GLsizei width,
     GLsizei height, GLint border, GLenum format, GLenum type,
     const void* pixels) {
-  // TODO(gman): Switch to use buckets alwayst or at least if no room in shared
-  //    memory.
-  uint32 pixels_size = GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment_);
-  memcpy(shared_memory_.GetAddress(0), pixels, pixels_size);
   helper_->TexImage2D(
-      target, level, internalformat, width, height, border, format, type,
-      shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+      target, level, internalformat, width, height, border, format, type, 0, 0);
+  if (pixels) {
+    TexSubImage2D(target, level, 0, 0, width, height, format, type, pixels);
+  }
 }
 
 void GLES2Implementation::TexSubImage2D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLenum type, const void* pixels) {
-  // TODO(gman): Switch to use buckets alwayst or at least if no room in shared
-  //    memory.
-  uint32 pixels_size = GLES2Util::ComputeImageDataSize(
-      width, height, format, type, unpack_alignment_);
-  memcpy(shared_memory_.GetAddress(0), pixels, pixels_size);
-  helper_->TexSubImage2D(
-      target, level, xoffset, yoffset, width, height, format, type,
-      shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  const int8* source = static_cast<const int8*>(pixels);
+  GLsizeiptr max_size = transfer_buffer_.GetLargestFreeOrPendingSize();
+
+  GLsizeiptr unpadded_row_size = GLES2Util::ComputeImageDataSize(
+      width, 1, format, type, unpack_alignment_);
+  GLsizeiptr padded_row_size = GLES2Util::ComputeImageDataSize(
+      width, 2, format, type, unpack_alignment_) - unpadded_row_size;
+
+  if (padded_row_size <= max_size) {
+    // Transfer by rows.
+    GLint max_rows = max_size / padded_row_size;
+    while (height) {
+      GLint num_rows = std::min(height, max_rows);
+      GLsizeiptr part_size = num_rows * padded_row_size;
+      void* buffer = transfer_buffer_.Alloc(part_size);
+      memcpy(buffer, source, part_size);
+      helper_->TexSubImage2D(
+          target, level, xoffset, yoffset, width, num_rows, format, type,
+          transfer_buffer_id_, transfer_buffer_.GetOffset(buffer));
+      transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+      yoffset += num_rows;
+      source += part_size;
+      height -= num_rows;
+    }
+  } else {
+    // Transfer by sub rows. Beacuse GL has no maximum texture dimensions.
+    GLsizeiptr element_size = GLES2Util::ComputeImageDataSize(
+       1, 1, format, type, unpack_alignment_);
+    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);
+        memcpy(buffer, row_source, part_size);
+        helper_->TexSubImage2D(
+            target, level, temp_xoffset, yoffset, temp_width, 1, format, type,
+            transfer_buffer_id_, transfer_buffer_.GetOffset(buffer));
+        transfer_buffer_.FreePendingToken(buffer, helper_->InsertToken());
+        row_source += part_size;
+        temp_xoffset += num_pixels;
+        temp_width -= num_pixels;
+      }
+      ++yoffset;
+      source += padded_row_size;
+    }
+  }
 }
 
 
diff --git a/o3d/gpu/command_buffer/client/gles2_implementation.h b/o3d/gpu/command_buffer/client/gles2_implementation.h
index 2df52ca..fec3de9 100644
--- a/o3d/gpu/command_buffer/client/gles2_implementation.h
+++ b/o3d/gpu/command_buffer/client/gles2_implementation.h
@@ -9,43 +9,11 @@
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/id_allocator.h"
+#include "gpu/command_buffer/client/fenced_allocator.h"
 
 namespace command_buffer {
 namespace gles2 {
 
-// A class to help with shared memory.
-class SharedMemoryHelper {
- public:
-  SharedMemoryHelper(void* address, int id)
-      : address_(address),
-        id_(id) {
-  }
-
-  unsigned int GetOffset(void* address) const {
-    return static_cast<int8*>(address) -
-           static_cast<int8*>(address_);
-  }
-
-  void* GetAddress(unsigned int offset) const {
-    return static_cast<int8*>(address_) + offset;
-  }
-
-  template <typename T>
-  T GetAddressAs(unsigned int offset) const {
-    return static_cast<T>(GetAddress(offset));
-  }
-
-  unsigned int GetId() const {
-    return id_;
-  }
-
- private:
-  void* address_;
-  int id_;
-
-  DISALLOW_COPY_AND_ASSIGN(SharedMemoryHelper);
-};
-
 // This class emulates GLES2 over command buffers. It can be used by a client
 // program so that the program does not need deal with shared memory and command
 // buffer management. See gl2_lib.h.  Note that there is a performance gain to
@@ -56,8 +24,9 @@ class GLES2Implementation {
  public:
   GLES2Implementation(
       GLES2CmdHelper* helper,
+      size_t transfer_buffer_size,
       void* transfer_buffer,
-      int transfer_buffer_id);  // TODO: add size.
+      int32 transfer_buffer_id);
 
   // Include the auto-generated part of this class. We split this because
   // it means we can easily edit the non-auto generated parts right here in
@@ -71,10 +40,35 @@ class GLES2Implementation {
   // Frees a set of Ids for glDelete___ functions.
   void FreeIds(GLsizei n, const GLuint* ids);
 
+  // Gets the shared memory id for the result buffer.
+  uint32 result_shm_id() const {
+    return transfer_buffer_id_;
+  }
+
+  // Gets the shared memory offset for the result buffer.
+  uint32 result_shm_offset() const {
+    return result_shm_offset_;
+  }
+
+  // Gets the value of the result.
+  template <typename T>
+  T GetResultAs() const {
+    return *static_cast<T*>(result_buffer_);
+  }
+
+  // Waits for all commands to execute.
+  void WaitForCmd();
+
+  // The maxiumum result size from simple GL get commands.
+  static const size_t kMaxSizeOfSimpleResult = 4 * sizeof(uint32);  // NOLINT.
+
   GLES2Util util_;
   GLES2CmdHelper* helper_;
   IdAllocator id_allocator_;
-  SharedMemoryHelper shared_memory_;  // TODO(gman): rename transfer_buffer_.
+  FencedAllocatorWrapper transfer_buffer_;
+  int transfer_buffer_id_;
+  void* result_buffer_;
+  uint32 result_shm_offset_;
 
   // pack alignment as last set by glPixelStorei
   GLint pack_alignment_;
diff --git a/o3d/gpu/command_buffer/client/gles2_implementation_autogen.h b/o3d/gpu/command_buffer/client/gles2_implementation_autogen.h
index af78b52..c4b34b9 100644
--- a/o3d/gpu/command_buffer/client/gles2_implementation_autogen.h
+++ b/o3d/gpu/command_buffer/client/gles2_implementation_autogen.h
@@ -255,66 +255,60 @@ void GetAttachedShaders(
 GLint GetAttribLocation(GLuint program, const char* name);
 
 void GetBooleanv(GLenum pname, GLboolean* params) {
-  helper_->GetBooleanv(pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->GetBooleanv(pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
-  helper_->GetBufferParameteriv(target, pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->GetBufferParameteriv(
+      target, pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 GLenum GetError() {
-  helper_->GetError(shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
-  return *shared_memory_.GetAddressAs<GLenum*>(0);
+  helper_->GetError(result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  return GetResultAs<GLenum>();
 }
 
 void GetFloatv(GLenum pname, GLfloat* params) {
-  helper_->GetFloatv(pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->GetFloatv(pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 void GetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   helper_->GetFramebufferAttachmentParameteriv(
-      target, attachment, pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+      target, attachment, pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 void GetIntegerv(GLenum pname, GLint* params) {
-  helper_->GetIntegerv(pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->GetIntegerv(pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 void GetProgramiv(GLuint program, GLenum pname, GLint* params) {
-  helper_->GetProgramiv(program, pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->GetProgramiv(program, pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 // TODO(gman): Implement this
@@ -323,21 +317,19 @@ void GetProgramInfoLog(
 
 void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) {
   helper_->GetRenderbufferParameteriv(
-      target, pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+      target, pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 void GetShaderiv(GLuint shader, GLenum pname, GLint* params) {
-  helper_->GetShaderiv(shader, pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->GetShaderiv(shader, pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 // TODO(gman): Implement this
@@ -354,21 +346,21 @@ void GetShaderSource(
 const GLubyte* GetString(GLenum name);
 
 void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
-  helper_->GetTexParameterfv(target, pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->GetTexParameterfv(
+      target, pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) {
-  helper_->GetTexParameteriv(target, pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->GetTexParameteriv(
+      target, pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 void GetUniformfv(GLuint program, GLint location, GLfloat* params);
@@ -378,21 +370,21 @@ void GetUniformiv(GLuint program, GLint location, GLint* params);
 GLint GetUniformLocation(GLuint program, const char* name);
 
 void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) {
-  helper_->GetVertexAttribfv(index, pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->GetVertexAttribfv(
+      index, pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) {
-  helper_->GetVertexAttribiv(index, pname, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
+  helper_->GetVertexAttribiv(
+      index, pname, result_shm_id(), result_shm_offset());
+  WaitForCmd();
   GLsizei num_values = util_.GLGetNumValuesReturned(pname);
-  memcpy(params, shared_memory_.GetAddress(0),
-         num_values * sizeof(*params));
+  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);
+  memcpy(params, result_buffer_, num_values * sizeof(*params));
 }
 
 void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer);
@@ -402,52 +394,45 @@ void Hint(GLenum target, GLenum mode) {
 }
 
 GLboolean IsBuffer(GLuint buffer) {
-  helper_->IsBuffer(buffer, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
-  return *shared_memory_.GetAddressAs<GLboolean*>(0);
+  helper_->IsBuffer(buffer, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  return GetResultAs<GLboolean>();
 }
 
 GLboolean IsEnabled(GLenum cap) {
-  helper_->IsEnabled(cap, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
-  return *shared_memory_.GetAddressAs<GLboolean*>(0);
+  helper_->IsEnabled(cap, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  return GetResultAs<GLboolean>();
 }
 
 GLboolean IsFramebuffer(GLuint framebuffer) {
-  helper_->IsFramebuffer(framebuffer, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
-  return *shared_memory_.GetAddressAs<GLboolean*>(0);
+  helper_->IsFramebuffer(framebuffer, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  return GetResultAs<GLboolean>();
 }
 
 GLboolean IsProgram(GLuint program) {
-  helper_->IsProgram(program, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
-  return *shared_memory_.GetAddressAs<GLboolean*>(0);
+  helper_->IsProgram(program, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  return GetResultAs<GLboolean>();
 }
 
 GLboolean IsRenderbuffer(GLuint renderbuffer) {
-  helper_->IsRenderbuffer(renderbuffer, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
-  return *shared_memory_.GetAddressAs<GLboolean*>(0);
+  helper_->IsRenderbuffer(renderbuffer, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  return GetResultAs<GLboolean>();
 }
 
 GLboolean IsShader(GLuint shader) {
-  helper_->IsShader(shader, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
-  return *shared_memory_.GetAddressAs<GLboolean*>(0);
+  helper_->IsShader(shader, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  return GetResultAs<GLboolean>();
 }
 
 GLboolean IsTexture(GLuint texture) {
-  helper_->IsTexture(texture, shared_memory_.GetId(), 0);
-  int32 token = helper_->InsertToken();
-  helper_->WaitForToken(token);
-  return *shared_memory_.GetAddressAs<GLboolean*>(0);
+  helper_->IsTexture(texture, result_shm_id(), result_shm_offset());
+  WaitForCmd();
+  return GetResultAs<GLboolean>();
 }
 
 void LineWidth(GLfloat width) {