Make GLES2CmdHelper and CommandBufferHelper handle failed allocation

This passes all the current unit tests.
I'll write more tests to check this stuff but I want to get it the tree
asap to see if it stop the crashes

Note. This is only step 1 of about 4 steps
Step 2 is make GLES2Implementation do the same
Step 3 is make both of these trigger lost context
Step 4 is write tests.

TEST=none
BUG=109694

R=apatrick@chromium.org


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

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

6 files changed, 1092 insertions, 584 deletions

diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index 9804080..9200fbf 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# Copyright (c) 2011 The Chromium Authors. All rights reserved.
+# Copyright (c) 2012 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.
 
@@ -2519,25 +2519,37 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
 
   def WriteCmdHelper(self, func, file):
     """Writes the cmd helper definition for a cmd."""
-    args = func.MakeCmdArgString("")
-    file.Write("  void %s(%s) {\n" %
-               (func.name, func.MakeTypedCmdArgString("")))
-    file.Write("    gles2::%s& c = GetCmdSpace<gles2::%s>();\n" %
-               (func.name, func.name))
-    file.Write("    c.Init(%s);\n" % args)
-    file.Write("  }\n\n")
+    code = """  void %(name)s(%(typed_args)s) {
+    gles2::%(name)s* c = GetCmdSpace<gles2::%(name)s>();
+    if (c) {
+      c->Init(%(args)s);
+    }
+  }
+
+"""
+    file.Write(code % {
+          "name": func.name,
+          "typed_args": func.MakeTypedCmdArgString(""),
+          "args": func.MakeCmdArgString(""),
+        })
 
   def WriteImmediateCmdHelper(self, func, file):
     """Writes the cmd helper definition for the immediate version of a cmd."""
-    args = func.MakeCmdArgString("")
-    file.Write("  void %s(%s) {\n" %
-               (func.name, func.MakeTypedCmdArgString("")))
-    file.Write("    const uint32 s = 0;  // TODO(gman): compute correct size\n")
-    file.Write("    gles2::%s& c = "
-               "GetImmediateCmdSpaceTotalSize<gles2::%s>(s);\n" %
-               (func.name, func.name))
-    file.Write("    c.Init(%s);\n" % args)
-    file.Write("  }\n\n")
+    code = """  void %(name)s(%(typed_args)s) {
+    const uint32 s = 0;  // TODO(gman): compute correct size
+    gles2::%(name)s* c =
+        GetImmediateCmdSpaceTotalSize<gles2::%(name)s>(s);
+    if (c) {
+      c->Init(%(args)s);
+    }
+  }
+
+"""
+    file.Write(code % {
+           "name": func.name,
+           "typed_args": func.MakeTypedCmdArgString(""),
+           "args": func.MakeCmdArgString(""),
+        })
 
 
 class CustomHandler(TypeHandler):
@@ -3051,12 +3063,12 @@ TEST_F(%(test_name)s, %(name)sInvalidArgs) {
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
-  %(name)s& cmd = *GetImmediateAs<%(name)s>();
+  %(name)s* cmd = GetImmediateAs<%(name)s>();
   GLuint temp = kNewClientId;
   SpecializedSetup<%(name)s, 0>(true);
-  cmd.Init(1, &temp);
+  cmd->Init(1, &temp);
   EXPECT_EQ(error::kNoError,
-            ExecuteImmediateCmd(cmd, sizeof(temp)));
+            ExecuteImmediateCmd(*cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(Get%(resource_name)sInfo(kNewClientId) != NULL);
 }
@@ -3067,11 +3079,11 @@ TEST_F(%(test_name)s, %(name)sValidArgs) {
     invalid_test = """
 TEST_F(%(test_name)s, %(name)sInvalidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(_, _)).Times(0);
-  %(name)s& cmd = *GetImmediateAs<%(name)s>();
+  %(name)s* cmd = GetImmediateAs<%(name)s>();
   SpecializedSetup<%(name)s, 0>(false);
-  cmd.Init(1, &client_%(resource_name)s_id_);
+  cmd->Init(1, &client_%(resource_name)s_id_);
   EXPECT_EQ(error::kInvalidArguments,
-            ExecuteImmediateCmd(cmd, sizeof(&client_%(resource_name)s_id_)));
+            ExecuteImmediateCmd(*cmd, sizeof(&client_%(resource_name)s_id_)));
 }
 """
     self.WriteValidUnitTest(func, file, invalid_test, {
@@ -3130,16 +3142,21 @@ TEST_F(%(test_name)s, %(name)sInvalidArgs) {
 
   def WriteImmediateCmdHelper(self, func, file):
     """Overrriden from TypeHandler."""
-    args = func.MakeOriginalArgString("")
-    file.Write("  void %s(%s) {\n" %
-               (func.name, func.MakeTypedOriginalArgString("")))
-    file.Write("    const uint32 size = gles2::%s::ComputeSize(n);\n" %
-               func.name)
-    file.Write("    gles2::%s& c = "
-               "GetImmediateCmdSpaceTotalSize<gles2::%s>(size);\n" %
-               (func.name, func.name))
-    file.Write("    c.Init(%s);\n" % args)
-    file.Write("  }\n\n")
+    code = """  void %(name)s(%(typed_args)s) {
+    const uint32 size = gles2::%(name)s::ComputeSize(n);
+    gles2::%(name)s* c =
+        GetImmediateCmdSpaceTotalSize<gles2::%(name)s>(size);
+    if (c) {
+      c->Init(%(args)s);
+    }
+  }
+
+"""
+    file.Write(code % {
+          "name": func.name,
+          "typed_args": func.MakeTypedOriginalArgString(""),
+          "args": func.MakeOriginalArgString(""),
+        })
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
@@ -3467,16 +3484,21 @@ TEST_F(%(test_name)s, %(name)sInvalidArgs) {
 
   def WriteImmediateCmdHelper(self, func, file):
     """Overrriden from TypeHandler."""
-    args = func.MakeOriginalArgString("")
-    file.Write("  void %s(%s) {\n" %
-               (func.name, func.MakeTypedOriginalArgString("")))
-    file.Write("    const uint32 size = gles2::%s::ComputeSize(n);\n" %
-               func.name)
-    file.Write("    gles2::%s& c = "
-               "GetImmediateCmdSpaceTotalSize<gles2::%s>(size);\n" %
-               (func.name, func.name))
-    file.Write("    c.Init(%s);\n" % args)
-    file.Write("  }\n\n")
+    code = """  void %(name)s(%(typed_args)s) {
+    const uint32 size = gles2::%(name)s::ComputeSize(n);
+    gles2::%(name)s* c =
+        GetImmediateCmdSpaceTotalSize<gles2::%(name)s>(size);
+    if (c) {
+      c->Init(%(args)s);
+    }
+  }
+
+"""
+    file.Write(code % {
+          "name": func.name,
+          "typed_args": func.MakeTypedOriginalArgString(""),
+          "args": func.MakeOriginalArgString(""),
+        })
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
@@ -3893,16 +3915,21 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
 
   def WriteImmediateCmdHelper(self, func, file):
     """Overrriden from TypeHandler."""
-    args = func.MakeOriginalArgString("")
-    file.Write("  void %s(%s) {\n" %
-               (func.name, func.MakeTypedOriginalArgString("")))
-    file.Write("    const uint32 size = gles2::%s::ComputeSize();\n" %
-               func.name)
-    file.Write("    gles2::%s& c = "
-               "GetImmediateCmdSpaceTotalSize<gles2::%s>(size);\n" %
-               (func.name, func.name))
-    file.Write("    c.Init(%s);\n" % args)
-    file.Write("  }\n\n")
+    code = """  void %(name)s(%(typed_args)s) {
+    const uint32 size = gles2::%(name)s::ComputeSize();
+    gles2::%(name)s* c =
+        GetImmediateCmdSpaceTotalSize<gles2::%(name)s>(size);
+    if (c) {
+      c->Init(%(args)s);
+    }
+  }
+
+"""
+    file.Write(code % {
+          "name": func.name,
+          "typed_args": func.MakeTypedOriginalArgString(""),
+          "args": func.MakeOriginalArgString(""),
+        })
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
@@ -4161,16 +4188,21 @@ TEST_F(GLES2ImplementationTest, %(name)s) {
 
   def WriteImmediateCmdHelper(self, func, file):
     """Overrriden from TypeHandler."""
-    args = func.MakeOriginalArgString("")
-    file.Write("  void %s(%s) {\n" %
-               (func.name, func.MakeTypedOriginalArgString("")))
-    file.Write("    const uint32 size = gles2::%s::ComputeSize(count);\n" %
-               func.name)
-    file.Write("    gles2::%s& c = "
-               "GetImmediateCmdSpaceTotalSize<gles2::%s>(size);\n" %
-               (func.name, func.name))
-    file.Write("    c.Init(%s);\n" % args)
-    file.Write("  }\n\n")
+    code = """  void %(name)s(%(typed_args)s) {
+    const uint32 size = gles2::%(name)s::ComputeSize(count);
+    gles2::%(name)s* c =
+        GetImmediateCmdSpaceTotalSize<gles2::%(name)s>(size);
+    if (c) {
+      c->Init(%(args)s);
+    }
+  }
+
+"""
+    file.Write(code % {
+          "name": func.name,
+          "typed_args": func.MakeTypedOriginalArgString(""),
+          "args": func.MakeOriginalArgString(""),
+        })
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
@@ -4325,16 +4357,21 @@ class GLcharHandler(CustomHandler):
 
   def WriteImmediateCmdHelper(self, func, file):
     """Overrriden from TypeHandler."""
-    args = func.MakeOriginalArgString("")
-    last_arg = func.GetLastOriginalArg()
-    file.Write("  void %s(%s) {\n" %
-               (func.name, func.MakeTypedOriginalArgString("")))
-    file.Write("    const uint32 data_size = strlen(name);\n")
-    file.Write("    gles2::%s& c = GetImmediateCmdSpace<gles2::%s>("
-               "data_size);\n" %
-               (func.name, func.name))
-    file.Write("    c.Init(%s, data_size);\n" % args)
-    file.Write("  }\n\n")
+    code = """  void %(name)s(%(typed_args)s) {
+    const uint32 data_size = strlen(name);
+    gles2::%(name)s* c = GetImmediateCmdSpace<gles2::%(name)s>(data_size);
+    if (c) {
+      c->Init(%(args)s, data_size);
+    }
+  }
+
+"""
+    file.Write(code % {
+          "name": func.name,
+          "typed_args": func.MakeTypedOriginalArgString(""),
+          "args": func.MakeOriginalArgString(""),
+        })
+
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
diff --git a/gpu/command_buffer/client/cmd_buffer_helper.cc b/gpu/command_buffer/client/cmd_buffer_helper.cc
index cb4752b..d9a4c55 100644
--- a/gpu/command_buffer/client/cmd_buffer_helper.cc
+++ b/gpu/command_buffer/client/cmd_buffer_helper.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -26,22 +26,30 @@ CommandBufferHelper::CommandBufferHelper(CommandBuffer* command_buffer)
       put_(0),
       last_put_sent_(0),
       commands_issued_(0),
+      usable_(true),
       last_flush_time_(0) {
 }
 
 bool CommandBufferHelper::AllocateRingBuffer() {
+  if (!usable()) {
+    return false;
+  }
+
   if (HaveRingBuffer()) {
     return true;
   }
 
   int32 id = command_buffer_->CreateTransferBuffer(ring_buffer_size_, -1);
   if (id < 0) {
+    ClearUsable();
     return false;
   }
 
   ring_buffer_ = command_buffer_->GetTransferBuffer(id);
-  if (!ring_buffer_.ptr)
+  if (!ring_buffer_.ptr) {
+    ClearUsable();
     return false;
+  }
 
   ring_buffer_id_ = id;
   command_buffer_->SetGetBuffer(id);
@@ -53,6 +61,7 @@ bool CommandBufferHelper::AllocateRingBuffer() {
   int32 num_ring_buffer_entries =
       ring_buffer_size_ / sizeof(CommandBufferEntry);
   if (num_ring_buffer_entries > state.num_entries) {
+    ClearUsable();
     return false;
   }
 
@@ -82,7 +91,9 @@ CommandBufferHelper::~CommandBufferHelper() {
 }
 
 bool CommandBufferHelper::FlushSync() {
-  GPU_DCHECK(HaveRingBuffer());
+  if (!usable()) {
+    return false;
+  }
   last_flush_time_ = clock();
   last_put_sent_ = put_;
   CommandBuffer::State state = command_buffer_->FlushSync(put_, get_offset());
@@ -90,16 +101,20 @@ bool CommandBufferHelper::FlushSync() {
 }
 
 void CommandBufferHelper::Flush() {
-  GPU_DCHECK(HaveRingBuffer());
-  last_flush_time_ = clock();
-  last_put_sent_ = put_;
-  command_buffer_->Flush(put_);
+  if (usable()) {
+    last_flush_time_ = clock();
+    last_put_sent_ = put_;
+    command_buffer_->Flush(put_);
+  }
 }
 
 // Calls Flush() and then waits until the buffer is empty. Break early if the
 // error is set.
 bool CommandBufferHelper::Finish() {
   TRACE_EVENT0("gpu", "CommandBufferHelper::Finish");
+  if (!usable()) {
+    return false;
+  }
   GPU_DCHECK(HaveRingBuffer());
   do {
     // Do not loop forever if the flush fails, meaning the command buffer reader
@@ -117,17 +132,22 @@ bool CommandBufferHelper::Finish() {
 // which will be rare.
 int32 CommandBufferHelper::InsertToken() {
   AllocateRingBuffer();
+  if (!usable()) {
+    return token_;
+  }
   GPU_DCHECK(HaveRingBuffer());
   // Increment token as 31-bit integer. Negative values are used to signal an
   // error.
   token_ = (token_ + 1) & 0x7FFFFFFF;
-  cmd::SetToken& cmd = GetCmdSpace<cmd::SetToken>();
-  cmd.Init(token_);
-  if (token_ == 0) {
-    TRACE_EVENT0("gpu", "CommandBufferHelper::InsertToken(wrapped)");
-    // we wrapped
-    Finish();
-    GPU_DCHECK_EQ(token_, last_token_read());
+  cmd::SetToken* cmd = GetCmdSpace<cmd::SetToken>();
+  if (cmd) {
+    cmd->Init(token_);
+    if (token_ == 0) {
+      TRACE_EVENT0("gpu", "CommandBufferHelper::InsertToken(wrapped)");
+      // we wrapped
+      Finish();
+      GPU_DCHECK_EQ(token_, last_token_read());
+    }
   }
   return token_;
 }
@@ -135,8 +155,11 @@ int32 CommandBufferHelper::InsertToken() {
 // Waits until the current token value is greater or equal to the value passed
 // in argument.
 void CommandBufferHelper::WaitForToken(int32 token) {
-  GPU_DCHECK(HaveRingBuffer());
   TRACE_EVENT_IF_LONGER_THAN0(50, "gpu", "CommandBufferHelper::WaitForToken");
+  if (!usable()) {
+    return;
+  }
+  GPU_DCHECK(HaveRingBuffer());
   // Return immediately if corresponding InsertToken failed.
   if (token < 0)
     return;
@@ -160,6 +183,9 @@ void CommandBufferHelper::WaitForToken(int32 token) {
 // space may not be available.
 void CommandBufferHelper::WaitForAvailableEntries(int32 count) {
   AllocateRingBuffer();
+  if (!usable()) {
+    return;
+  }
   GPU_DCHECK(HaveRingBuffer());
   GPU_DCHECK(count < usable_entry_count_);
   if (put_ + count > usable_entry_count_) {
@@ -213,6 +239,9 @@ void CommandBufferHelper::WaitForAvailableEntries(int32 count) {
 
 CommandBufferEntry* CommandBufferHelper::GetSpace(uint32 entries) {
   AllocateRingBuffer();
+  if (!usable()) {
+    return NULL;
+  }
   GPU_DCHECK(HaveRingBuffer());
   ++commands_issued_;
   WaitForAvailableEntries(entries);
diff --git a/gpu/command_buffer/client/cmd_buffer_helper.h b/gpu/command_buffer/client/cmd_buffer_helper.h
index d27b25f..bc3fd56 100644
--- a/gpu/command_buffer/client/cmd_buffer_helper.h
+++ b/gpu/command_buffer/client/cmd_buffer_helper.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -90,29 +90,29 @@ class CommandBufferHelper {
   // Typed version of GetSpace. Gets enough room for the given type and returns
   // a reference to it.
   template <typename T>
-  T& GetCmdSpace() {
+  T* GetCmdSpace() {
     COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed);
     uint32 space_needed = ComputeNumEntries(sizeof(T));
     void* data = GetSpace(space_needed);
-    return *reinterpret_cast<T*>(data);
+    return reinterpret_cast<T*>(data);
   }
 
   // Typed version of GetSpace for immediate commands.
   template <typename T>
-  T& GetImmediateCmdSpace(size_t data_space) {
+  T* GetImmediateCmdSpace(size_t data_space) {
     COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN);
     uint32 space_needed = ComputeNumEntries(sizeof(T) + data_space);
     void* data = GetSpace(space_needed);
-    return *reinterpret_cast<T*>(data);
+    return reinterpret_cast<T*>(data);
   }
 
   // Typed version of GetSpace for immediate commands.
   template <typename T>
-  T& GetImmediateCmdSpaceTotalSize(size_t total_space) {
+  T* GetImmediateCmdSpaceTotalSize(size_t total_space) {
     COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN);
     uint32 space_needed = ComputeNumEntries(total_space);
     void* data = GetSpace(space_needed);
-    return *reinterpret_cast<T*>(data);
+    return reinterpret_cast<T*>(data);
   }
 
   int32 last_token_read() const {
@@ -127,44 +127,60 @@ class CommandBufferHelper {
 
   // Common Commands
   void Noop(uint32 skip_count) {
-    cmd::Noop& cmd = GetImmediateCmdSpace<cmd::Noop>(
+    cmd::Noop* cmd = GetImmediateCmdSpace<cmd::Noop>(
         skip_count * sizeof(CommandBufferEntry));
-    cmd.Init(skip_count);
+    if (cmd) {
+      cmd->Init(skip_count);
+    }
   }
 
   void SetToken(uint32 token) {
-    cmd::SetToken& cmd = GetCmdSpace<cmd::SetToken>();
-    cmd.Init(token);
+    cmd::SetToken* cmd = GetCmdSpace<cmd::SetToken>();
+    if (cmd) {
+      cmd->Init(token);
+    }
   }
 
   void Jump(uint32 offset) {
-    cmd::Jump& cmd = GetCmdSpace<cmd::Jump>();
-    cmd.Init(offset);
+    cmd::Jump* cmd = GetCmdSpace<cmd::Jump>();
+    if (cmd) {
+      cmd->Init(offset);
+    }
   }
 
   void JumpRelative(int32 offset) {
-    cmd::JumpRelative& cmd = GetCmdSpace<cmd::JumpRelative>();
-    cmd.Init(offset);
+    cmd::JumpRelative* cmd = GetCmdSpace<cmd::JumpRelative>();
+    if (cmd) {
+      cmd->Init(offset);
+    }
   }
 
   void Call(uint32 offset) {
-    cmd::Call& cmd = GetCmdSpace<cmd::Call>();
-    cmd.Init(offset);
+    cmd::Call* cmd = GetCmdSpace<cmd::Call>();
+    if (cmd) {
+      cmd->Init(offset);
+    }
   }
 
   void CallRelative(int32 offset) {
-    cmd::CallRelative& cmd = GetCmdSpace<cmd::CallRelative>();
-    cmd.Init(offset);
+    cmd::CallRelative* cmd = GetCmdSpace<cmd::CallRelative>();
+    if (cmd) {
+      cmd->Init(offset);
+    }
   }
 
   void Return() {
-    cmd::Return& cmd = GetCmdSpace<cmd::Return>();
-    cmd.Init();
+    cmd::Return* cmd = GetCmdSpace<cmd::Return>();
+    if (cmd) {
+      cmd->Init();
+    }
   }
 
   void SetBucketSize(uint32 bucket_id, uint32 size) {
-    cmd::SetBucketSize& cmd = GetCmdSpace<cmd::SetBucketSize>();
-    cmd.Init(bucket_id, size);
+    cmd::SetBucketSize* cmd = GetCmdSpace<cmd::SetBucketSize>();
+    if (cmd) {
+      cmd->Init(bucket_id, size);
+    }
   }
 
   void SetBucketData(uint32 bucket_id,
@@ -172,29 +188,35 @@ class CommandBufferHelper {
                      uint32 size,
                      uint32 shared_memory_id,
                      uint32 shared_memory_offset) {
-    cmd::SetBucketData& cmd = GetCmdSpace<cmd::SetBucketData>();
-    cmd.Init(bucket_id,
-             offset,
-             size,
-             shared_memory_id,
-             shared_memory_offset);
+    cmd::SetBucketData* cmd = GetCmdSpace<cmd::SetBucketData>();
+    if (cmd) {
+      cmd->Init(bucket_id,
+                offset,
+                size,
+                shared_memory_id,
+                shared_memory_offset);
+    }
   }
 
   void SetBucketDataImmediate(
       uint32 bucket_id, uint32 offset, const void* data, uint32 size) {
-    cmd::SetBucketDataImmediate& cmd =
+    cmd::SetBucketDataImmediate* cmd =
         GetImmediateCmdSpace<cmd::SetBucketDataImmediate>(size);
-    cmd.Init(bucket_id, offset, size);
-    memcpy(ImmediateDataAddress(&cmd), data, size);
+    if (cmd) {
+      cmd->Init(bucket_id, offset, size);
+      memcpy(ImmediateDataAddress(cmd), data, size);
+    }
   }
 
   void GetBucketSize(uint32 bucket_id,
                      uint32 shared_memory_id,
                      uint32 shared_memory_offset) {
-    cmd::GetBucketSize& cmd = GetCmdSpace<cmd::GetBucketSize>();
-    cmd.Init(bucket_id,
-             shared_memory_id,
-             shared_memory_offset);
+    cmd::GetBucketSize* cmd = GetCmdSpace<cmd::GetBucketSize>();
+    if (cmd) {
+      cmd->Init(bucket_id,
+                shared_memory_id,
+                shared_memory_offset);
+    }
   }
 
   void GetBucketData(uint32 bucket_id,
@@ -202,12 +224,14 @@ class CommandBufferHelper {
                      uint32 size,
                      uint32 shared_memory_id,
                      uint32 shared_memory_offset) {
-    cmd::GetBucketData& cmd = GetCmdSpace<cmd::GetBucketData>();
-    cmd.Init(bucket_id,
-             offset,
-             size,
-             shared_memory_id,
-             shared_memory_offset);
+    cmd::GetBucketData* cmd = GetCmdSpace<cmd::GetBucketData>();
+    if (cmd) {
+      cmd->Init(bucket_id,
+                offset,
+                size,
+                shared_memory_id,
+                shared_memory_offset);
+    }
   }
 
   CommandBuffer* command_buffer() const {
@@ -224,6 +248,14 @@ class CommandBufferHelper {
     return ring_buffer_id_ != -1;
   }
 
+  bool usable () const {
+    return usable_;
+  }
+
+  void ClearUsable() {
+    usable_ = false;
+  }
+
  private:
   // Waits until get changes, updating the value of get_.
   void WaitForGetChange();
@@ -247,6 +279,7 @@ class CommandBufferHelper {
   int32 put_;
   int32 last_put_sent_;
   int commands_issued_;
+  bool usable_;
 
   // Using C runtime instead of base because this file cannot depend on base.
   clock_t last_flush_time_;
diff --git a/gpu/command_buffer/client/gles2_cmd_helper.h b/gpu/command_buffer/client/gles2_cmd_helper.h
index 9876156..2db951c 100644
--- a/gpu/command_buffer/client/gles2_cmd_helper.h
+++ b/gpu/command_buffer/client/gles2_cmd_helper.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -31,53 +31,65 @@ class GLES2CmdHelper : public CommandBufferHelper {
   void GetAttribLocation(
       GLuint program, uint32 name_shm_id, uint32 name_shm_offset,
       uint32 location_shm_id, uint32 location_shm_offset, uint32 data_size) {
-    gles2::GetAttribLocation& c = GetCmdSpace<gles2::GetAttribLocation>();
-    c.Init(
-        program, name_shm_id, name_shm_offset, location_shm_id,
-        location_shm_offset, data_size);
+    gles2::GetAttribLocation* c = GetCmdSpace<gles2::GetAttribLocation>();
+    if (c) {
+      c->Init(
+          program, name_shm_id, name_shm_offset, location_shm_id,
+          location_shm_offset, data_size);
+    }
   }
 
   void GetAttribLocationImmediate(
       GLuint program, const char* name,
       uint32 location_shm_id, uint32 location_shm_offset) {
     const uint32 size = gles2::GetAttribLocationImmediate::ComputeSize(name);
-    gles2::GetAttribLocationImmediate& c =
+    gles2::GetAttribLocationImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::GetAttribLocationImmediate>(size);
-    c.Init(program, name, location_shm_id, location_shm_offset);
+    if (c) {
+      c->Init(program, name, location_shm_id, location_shm_offset);
+    }
   }
 
   void GetAttribLocationBucket(
       GLuint program, uint32 name_bucket_id,
       uint32 location_shm_id, uint32 location_shm_offset) {
-    gles2::GetAttribLocationBucket& c =
+    gles2::GetAttribLocationBucket* c =
         GetCmdSpace<gles2::GetAttribLocationBucket>();
-    c.Init(program, name_bucket_id, location_shm_id, location_shm_offset);
+    if (c) {
+      c->Init(program, name_bucket_id, location_shm_id, location_shm_offset);
+    }
   }
 
   void GetUniformLocation(
       GLuint program, uint32 name_shm_id, uint32 name_shm_offset,
       uint32 location_shm_id, uint32 location_shm_offset, uint32 data_size) {
-    gles2::GetUniformLocation& c = GetCmdSpace<gles2::GetUniformLocation>();
-    c.Init(
-        program, name_shm_id, name_shm_offset, location_shm_id,
-        location_shm_offset, data_size);
+    gles2::GetUniformLocation* c = GetCmdSpace<gles2::GetUniformLocation>();
+    if (c) {
+      c->Init(
+          program, name_shm_id, name_shm_offset, location_shm_id,
+          location_shm_offset, data_size);
+    }
   }
 
   void GetUniformLocationImmediate(
       GLuint program, const char* name,
       uint32 location_shm_id, uint32 location_shm_offset) {
     const uint32 size = gles2::GetUniformLocationImmediate::ComputeSize(name);
-    gles2::GetUniformLocationImmediate& c =
+    gles2::GetUniformLocationImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::GetUniformLocationImmediate>(size);
-    c.Init(program, name, location_shm_id, location_shm_offset);
+    if (c) {
+      c->Init(program, name, location_shm_id, location_shm_offset);
+    }
   }
 
   void GetUniformLocationBucket(
       GLuint program, uint32 name_bucket_id,
       uint32 location_shm_id, uint32 location_shm_offset) {
-    gles2::GetUniformLocationBucket& c =
+    gles2::GetUniformLocationBucket* c =
         GetCmdSpace<gles2::GetUniformLocationBucket>();
-    c.Init(program, name_bucket_id, location_shm_id, location_shm_offset);
+    if (c) {
+      c->Init(program, name_bucket_id, location_shm_id, location_shm_offset);
+    }
   }
 
  private:
diff --git a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
index c3e5497..9ba4763 100644
--- a/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
+++ b/gpu/command_buffer/client/gles2_cmd_helper_autogen.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -10,1262 +10,1661 @@
 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_
 
   void ActiveTexture(GLenum texture) {
-    gles2::ActiveTexture& c = GetCmdSpace<gles2::ActiveTexture>();
-    c.Init(texture);
+    gles2::ActiveTexture* c = GetCmdSpace<gles2::ActiveTexture>();
+    if (c) {
+      c->Init(texture);
+    }
   }
 
   void AttachShader(GLuint program, GLuint shader) {
-    gles2::AttachShader& c = GetCmdSpace<gles2::AttachShader>();
-    c.Init(program, shader);
+    gles2::AttachShader* c = GetCmdSpace<gles2::AttachShader>();
+    if (c) {
+      c->Init(program, shader);
+    }
   }
 
   void BindAttribLocation(
       GLuint program, GLuint index, uint32 name_shm_id, uint32 name_shm_offset,
       uint32 data_size) {
-    gles2::BindAttribLocation& c = GetCmdSpace<gles2::BindAttribLocation>();
-    c.Init(program, index, name_shm_id, name_shm_offset, data_size);
+    gles2::BindAttribLocation* c = GetCmdSpace<gles2::BindAttribLocation>();
+    if (c) {
+      c->Init(program, index, name_shm_id, name_shm_offset, data_size);
+    }
   }
 
   void BindAttribLocationImmediate(
       GLuint program, GLuint index, const char* name) {
     const uint32 data_size = strlen(name);
-    gles2::BindAttribLocationImmediate& c =
+    gles2::BindAttribLocationImmediate* c =
         GetImmediateCmdSpace<gles2::BindAttribLocationImmediate>(data_size);
-    c.Init(program, index, name, data_size);
+    if (c) {
+      c->Init(program, index, name, data_size);
+    }
   }
 
   void BindAttribLocationBucket(
       GLuint program, GLuint index, uint32 name_bucket_id) {
-    gles2::BindAttribLocationBucket& c =
+    gles2::BindAttribLocationBucket* c =
         GetCmdSpace<gles2::BindAttribLocationBucket>();
-    c.Init(program, index, name_bucket_id);
+    if (c) {
+      c->Init(program, index, name_bucket_id);
+    }
   }
 
   void BindBuffer(GLenum target, GLuint buffer) {
-    gles2::BindBuffer& c = GetCmdSpace<gles2::BindBuffer>();
-    c.Init(target, buffer);
+    gles2::BindBuffer* c = GetCmdSpace<gles2::BindBuffer>();
+    if (c) {
+      c->Init(target, buffer);
+    }
   }
 
   void BindFramebuffer(GLenum target, GLuint framebuffer) {
-    gles2::BindFramebuffer& c = GetCmdSpace<gles2::BindFramebuffer>();
-    c.Init(target, framebuffer);
+    gles2::BindFramebuffer* c = GetCmdSpace<gles2::BindFramebuffer>();
+    if (c) {
+      c->Init(target, framebuffer);
+    }
   }
 
   void BindRenderbuffer(GLenum target, GLuint renderbuffer) {
-    gles2::BindRenderbuffer& c = GetCmdSpace<gles2::BindRenderbuffer>();
-    c.Init(target, renderbuffer);
+    gles2::BindRenderbuffer* c = GetCmdSpace<gles2::BindRenderbuffer>();
+    if (c) {
+      c->Init(target, renderbuffer);
+    }
   }
 
   void BindTexture(GLenum target, GLuint texture) {
-    gles2::BindTexture& c = GetCmdSpace<gles2::BindTexture>();
-    c.Init(target, texture);
+    gles2::BindTexture* c = GetCmdSpace<gles2::BindTexture>();
+    if (c) {
+      c->Init(target, texture);
+    }
   }
 
   void BlendColor(
       GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
-    gles2::BlendColor& c = GetCmdSpace<gles2::BlendColor>();
-    c.Init(red, green, blue, alpha);
+    gles2::BlendColor* c = GetCmdSpace<gles2::BlendColor>();
+    if (c) {
+      c->Init(red, green, blue, alpha);
+    }
   }
 
   void BlendEquation(GLenum mode) {
-    gles2::BlendEquation& c = GetCmdSpace<gles2::BlendEquation>();
-    c.Init(mode);
+    gles2::BlendEquation* c = GetCmdSpace<gles2::BlendEquation>();
+    if (c) {
+      c->Init(mode);
+    }
   }
 
   void BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
-    gles2::BlendEquationSeparate& c =
+    gles2::BlendEquationSeparate* c =
         GetCmdSpace<gles2::BlendEquationSeparate>();
-    c.Init(modeRGB, modeAlpha);
+    if (c) {
+      c->Init(modeRGB, modeAlpha);
+    }
   }
 
   void BlendFunc(GLenum sfactor, GLenum dfactor) {
-    gles2::BlendFunc& c = GetCmdSpace<gles2::BlendFunc>();
-    c.Init(sfactor, dfactor);
+    gles2::BlendFunc* c = GetCmdSpace<gles2::BlendFunc>();
+    if (c) {
+      c->Init(sfactor, dfactor);
+    }
   }
 
   void BlendFuncSeparate(
       GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) {
-    gles2::BlendFuncSeparate& c = GetCmdSpace<gles2::BlendFuncSeparate>();
-    c.Init(srcRGB, dstRGB, srcAlpha, dstAlpha);
+    gles2::BlendFuncSeparate* c = GetCmdSpace<gles2::BlendFuncSeparate>();
+    if (c) {
+      c->Init(srcRGB, dstRGB, srcAlpha, dstAlpha);
+    }
   }
 
   void BufferData(
       GLenum target, GLsizeiptr size, uint32 data_shm_id,
       uint32 data_shm_offset, GLenum usage) {
-    gles2::BufferData& c = GetCmdSpace<gles2::BufferData>();
-    c.Init(target, size, data_shm_id, data_shm_offset, usage);
+    gles2::BufferData* c = GetCmdSpace<gles2::BufferData>();
+    if (c) {
+      c->Init(target, size, data_shm_id, data_shm_offset, usage);
+    }
   }
 
   void BufferDataImmediate(GLenum target, GLsizeiptr size, GLenum usage) {
     const uint32 s = 0;  // TODO(gman): compute correct size
-    gles2::BufferDataImmediate& c =
+    gles2::BufferDataImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::BufferDataImmediate>(s);
-    c.Init(target, size, usage);
+    if (c) {
+      c->Init(target, size, usage);
+    }
   }
 
   void BufferSubData(
       GLenum target, GLintptr offset, GLsizeiptr size, uint32 data_shm_id,
       uint32 data_shm_offset) {
-    gles2::BufferSubData& c = GetCmdSpace<gles2::BufferSubData>();
-    c.Init(target, offset, size, data_shm_id, data_shm_offset);
+    gles2::BufferSubData* c = GetCmdSpace<gles2::BufferSubData>();
+    if (c) {
+      c->Init(target, offset, size, data_shm_id, data_shm_offset);
+    }
   }
 
   void BufferSubDataImmediate(
       GLenum target, GLintptr offset, GLsizeiptr size) {
     const uint32 s = 0;  // TODO(gman): compute correct size
-    gles2::BufferSubDataImmediate& c =
+    gles2::BufferSubDataImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::BufferSubDataImmediate>(s);
-    c.Init(target, offset, size);
+    if (c) {
+      c->Init(target, offset, size);
+    }
   }
 
   void CheckFramebufferStatus(
       GLenum target, uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::CheckFramebufferStatus& c =
+    gles2::CheckFramebufferStatus* c =
         GetCmdSpace<gles2::CheckFramebufferStatus>();
-    c.Init(target, result_shm_id, result_shm_offset);
+    if (c) {
+      c->Init(target, result_shm_id, result_shm_offset);
+    }
   }
 
   void Clear(GLbitfield mask) {
-    gles2::Clear& c = GetCmdSpace<gles2::Clear>();
-    c.Init(mask);
+    gles2::Clear* c = GetCmdSpace<gles2::Clear>();
+    if (c) {
+      c->Init(mask);
+    }
   }
 
   void ClearColor(
       GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
-    gles2::ClearColor& c = GetCmdSpace<gles2::ClearColor>();
-    c.Init(red, green, blue, alpha);
+    gles2::ClearColor* c = GetCmdSpace<gles2::ClearColor>();
+    if (c) {
+      c->Init(red, green, blue, alpha);
+    }
   }
 
   void ClearDepthf(GLclampf depth) {
-    gles2::ClearDepthf& c = GetCmdSpace<gles2::ClearDepthf>();
-    c.Init(depth);
+    gles2::ClearDepthf* c = GetCmdSpace<gles2::ClearDepthf>();
+    if (c) {
+      c->Init(depth);
+    }
   }
 
   void ClearStencil(GLint s) {
-    gles2::ClearStencil& c = GetCmdSpace<gles2::ClearStencil>();
-    c.Init(s);
+    gles2::ClearStencil* c = GetCmdSpace<gles2::ClearStencil>();
+    if (c) {
+      c->Init(s);
+    }
   }
 
   void ColorMask(
       GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
-    gles2::ColorMask& c = GetCmdSpace<gles2::ColorMask>();
-    c.Init(red, green, blue, alpha);
+    gles2::ColorMask* c = GetCmdSpace<gles2::ColorMask>();
+    if (c) {
+      c->Init(red, green, blue, alpha);
+    }
   }
 
   void CompileShader(GLuint shader) {
-    gles2::CompileShader& c = GetCmdSpace<gles2::CompileShader>();
-    c.Init(shader);
+    gles2::CompileShader* c = GetCmdSpace<gles2::CompileShader>();
+    if (c) {
+      c->Init(shader);
+    }
   }
 
   void CompressedTexImage2D(
       GLenum target, GLint level, GLenum internalformat, GLsizei width,
       GLsizei height, GLint border, GLsizei imageSize, uint32 data_shm_id,
       uint32 data_shm_offset) {
-    gles2::CompressedTexImage2D& c =
+    gles2::CompressedTexImage2D* c =
         GetCmdSpace<gles2::CompressedTexImage2D>();
-    c.Init(
-        target, level, internalformat, width, height, border, imageSize,
-        data_shm_id, data_shm_offset);
+    if (c) {
+      c->Init(
+          target, level, internalformat, width, height, border, imageSize,
+          data_shm_id, data_shm_offset);
+    }
   }
 
   void CompressedTexImage2DImmediate(
       GLenum target, GLint level, GLenum internalformat, GLsizei width,
       GLsizei height, GLint border, GLsizei imageSize) {
     const uint32 s = 0;  // TODO(gman): compute correct size
-    gles2::CompressedTexImage2DImmediate& c =
+    gles2::CompressedTexImage2DImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::CompressedTexImage2DImmediate>(s);
-    c.Init(target, level, internalformat, width, height, border, imageSize);
+    if (c) {
+      c->Init(target, level, internalformat, width, height, border, imageSize);
+    }
   }
 
   void CompressedTexImage2DBucket(
       GLenum target, GLint level, GLenum internalformat, GLsizei width,
       GLsizei height, GLint border, GLuint bucket_id) {
-    gles2::CompressedTexImage2DBucket& c =
+    gles2::CompressedTexImage2DBucket* c =
         GetCmdSpace<gles2::CompressedTexImage2DBucket>();
-    c.Init(target, level, internalformat, width, height, border, bucket_id);
+    if (c) {
+      c->Init(target, level, internalformat, width, height, border, bucket_id);
+    }
   }
 
   void CompressedTexSubImage2D(
       GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
       GLsizei height, GLenum format, GLsizei imageSize, uint32 data_shm_id,
       uint32 data_shm_offset) {
-    gles2::CompressedTexSubImage2D& c =
+    gles2::CompressedTexSubImage2D* c =
         GetCmdSpace<gles2::CompressedTexSubImage2D>();
-    c.Init(
-        target, level, xoffset, yoffset, width, height, format, imageSize,
-        data_shm_id, data_shm_offset);
+    if (c) {
+      c->Init(
+          target, level, xoffset, yoffset, width, height, format, imageSize,
+          data_shm_id, data_shm_offset);
+    }
   }
 
   void CompressedTexSubImage2DImmediate(
       GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
       GLsizei height, GLenum format, GLsizei imageSize) {
     const uint32 s = 0;  // TODO(gman): compute correct size
-    gles2::CompressedTexSubImage2DImmediate& c =
+    gles2::CompressedTexSubImage2DImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::CompressedTexSubImage2DImmediate>(
             s);
-    c.Init(target, level, xoffset, yoffset, width, height, format, imageSize);
+    if (c) {
+      c->Init(
+          target, level, xoffset, yoffset, width, height, format, imageSize);
+    }
   }
 
   void CompressedTexSubImage2DBucket(
       GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
       GLsizei height, GLenum format, GLuint bucket_id) {
-    gles2::CompressedTexSubImage2DBucket& c =
+    gles2::CompressedTexSubImage2DBucket* c =
         GetCmdSpace<gles2::CompressedTexSubImage2DBucket>();
-    c.Init(target, level, xoffset, yoffset, width, height, format, bucket_id);
+    if (c) {
+      c->Init(
+          target, level, xoffset, yoffset, width, height, format, bucket_id);
+    }
   }
 
   void CopyTexImage2D(
       GLenum target, GLint level, GLenum internalformat, GLint x, GLint y,
       GLsizei width, GLsizei height, GLint border) {
-    gles2::CopyTexImage2D& c = GetCmdSpace<gles2::CopyTexImage2D>();
-    c.Init(target, level, internalformat, x, y, width, height, border);
+    gles2::CopyTexImage2D* c = GetCmdSpace<gles2::CopyTexImage2D>();
+    if (c) {
+      c->Init(target, level, internalformat, x, y, width, height, border);
+    }
   }
 
   void CopyTexSubImage2D(
       GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x,
       GLint y, GLsizei width, GLsizei height) {
-    gles2::CopyTexSubImage2D& c = GetCmdSpace<gles2::CopyTexSubImage2D>();
-    c.Init(target, level, xoffset, yoffset, x, y, width, height);
+    gles2::CopyTexSubImage2D* c = GetCmdSpace<gles2::CopyTexSubImage2D>();
+    if (c) {
+      c->Init(target, level, xoffset, yoffset, x, y, width, height);
+    }
   }
 
   void CreateProgram(uint32 client_id) {
-    gles2::CreateProgram& c = GetCmdSpace<gles2::CreateProgram>();
-    c.Init(client_id);
+    gles2::CreateProgram* c = GetCmdSpace<gles2::CreateProgram>();
+    if (c) {
+      c->Init(client_id);
+    }
   }
 
   void CreateShader(GLenum type, uint32 client_id) {
-    gles2::CreateShader& c = GetCmdSpace<gles2::CreateShader>();
-    c.Init(type, client_id);
+    gles2::CreateShader* c = GetCmdSpace<gles2::CreateShader>();
+    if (c) {
+      c->Init(type, client_id);
+    }
   }
 
   void CullFace(GLenum mode) {
-    gles2::CullFace& c = GetCmdSpace<gles2::CullFace>();
-    c.Init(mode);
+    gles2::CullFace* c = GetCmdSpace<gles2::CullFace>();
+    if (c) {
+      c->Init(mode);
+    }
   }
 
   void DeleteBuffers(
       GLsizei n, uint32 buffers_shm_id, uint32 buffers_shm_offset) {
-    gles2::DeleteBuffers& c = GetCmdSpace<gles2::DeleteBuffers>();
-    c.Init(n, buffers_shm_id, buffers_shm_offset);
+    gles2::DeleteBuffers* c = GetCmdSpace<gles2::DeleteBuffers>();
+    if (c) {
+      c->Init(n, buffers_shm_id, buffers_shm_offset);
+    }
   }
 
   void DeleteBuffersImmediate(GLsizei n, const GLuint* buffers) {
     const uint32 size = gles2::DeleteBuffersImmediate::ComputeSize(n);
-    gles2::DeleteBuffersImmediate& c =
+    gles2::DeleteBuffersImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::DeleteBuffersImmediate>(size);
-    c.Init(n, buffers);
+    if (c) {
+      c->Init(n, buffers);
+    }
   }
 
   void DeleteFramebuffers(
       GLsizei n, uint32 framebuffers_shm_id, uint32 framebuffers_shm_offset) {
-    gles2::DeleteFramebuffers& c = GetCmdSpace<gles2::DeleteFramebuffers>();
-    c.Init(n, framebuffers_shm_id, framebuffers_shm_offset);
+    gles2::DeleteFramebuffers* c = GetCmdSpace<gles2::DeleteFramebuffers>();
+    if (c) {
+      c->Init(n, framebuffers_shm_id, framebuffers_shm_offset);
+    }
   }
 
   void DeleteFramebuffersImmediate(GLsizei n, const GLuint* framebuffers) {
     const uint32 size = gles2::DeleteFramebuffersImmediate::ComputeSize(n);
-    gles2::DeleteFramebuffersImmediate& c =
+    gles2::DeleteFramebuffersImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::DeleteFramebuffersImmediate>(
             size);
-    c.Init(n, framebuffers);
+    if (c) {
+      c->Init(n, framebuffers);
+    }
   }
 
   void DeleteProgram(GLuint program) {
-    gles2::DeleteProgram& c = GetCmdSpace<gles2::DeleteProgram>();
-    c.Init(program);
+    gles2::DeleteProgram* c = GetCmdSpace<gles2::DeleteProgram>();
+    if (c) {
+      c->Init(program);
+    }
   }
 
   void DeleteRenderbuffers(
       GLsizei n, uint32 renderbuffers_shm_id,
       uint32 renderbuffers_shm_offset) {
-    gles2::DeleteRenderbuffers& c = GetCmdSpace<gles2::DeleteRenderbuffers>();
-    c.Init(n, renderbuffers_shm_id, renderbuffers_shm_offset);
+    gles2::DeleteRenderbuffers* c = GetCmdSpace<gles2::DeleteRenderbuffers>();
+    if (c) {
+      c->Init(n, renderbuffers_shm_id, renderbuffers_shm_offset);
+    }
   }
 
   void DeleteRenderbuffersImmediate(GLsizei n, const GLuint* renderbuffers) {
     const uint32 size = gles2::DeleteRenderbuffersImmediate::ComputeSize(n);
-    gles2::DeleteRenderbuffersImmediate& c =
+    gles2::DeleteRenderbuffersImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::DeleteRenderbuffersImmediate>(
             size);
-    c.Init(n, renderbuffers);
+    if (c) {
+      c->Init(n, renderbuffers);
+    }
   }
 
   void DeleteShader(GLuint shader) {
-    gles2::DeleteShader& c = GetCmdSpace<gles2::DeleteShader>();
-    c.Init(shader);
+    gles2::DeleteShader* c = GetCmdSpace<gles2::DeleteShader>();
+    if (c) {
+      c->Init(shader);
+    }
   }
 
   void DeleteTextures(
       GLsizei n, uint32 textures_shm_id, uint32 textures_shm_offset) {
-    gles2::DeleteTextures& c = GetCmdSpace<gles2::DeleteTextures>();
-    c.Init(n, textures_shm_id, textures_shm_offset);
+    gles2::DeleteTextures* c = GetCmdSpace<gles2::DeleteTextures>();
+    if (c) {
+      c->Init(n, textures_shm_id, textures_shm_offset);
+    }
   }
 
   void DeleteTexturesImmediate(GLsizei n, const GLuint* textures) {
     const uint32 size = gles2::DeleteTexturesImmediate::ComputeSize(n);
-    gles2::DeleteTexturesImmediate& c =
+    gles2::DeleteTexturesImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::DeleteTexturesImmediate>(size);
-    c.Init(n, textures);
+    if (c) {
+      c->Init(n, textures);
+    }
   }
 
   void DepthFunc(GLenum func) {
-    gles2::DepthFunc& c = GetCmdSpace<gles2::DepthFunc>();
-    c.Init(func);
+    gles2::DepthFunc* c = GetCmdSpace<gles2::DepthFunc>();
+    if (c) {
+      c->Init(func);
+    }
   }
 
   void DepthMask(GLboolean flag) {
-    gles2::DepthMask& c = GetCmdSpace<gles2::DepthMask>();
-    c.Init(flag);
+    gles2::DepthMask* c = GetCmdSpace<gles2::DepthMask>();
+    if (c) {
+      c->Init(flag);
+    }
   }
 
   void DepthRangef(GLclampf zNear, GLclampf zFar) {
-    gles2::DepthRangef& c = GetCmdSpace<gles2::DepthRangef>();
-    c.Init(zNear, zFar);
+    gles2::DepthRangef* c = GetCmdSpace<gles2::DepthRangef>();
+    if (c) {
+      c->Init(zNear, zFar);
+    }
   }
 
   void DetachShader(GLuint program, GLuint shader) {
-    gles2::DetachShader& c = GetCmdSpace<gles2::DetachShader>();
-    c.Init(program, shader);
+    gles2::DetachShader* c = GetCmdSpace<gles2::DetachShader>();
+    if (c) {
+      c->Init(program, shader);
+    }
   }
 
   void Disable(GLenum cap) {
-    gles2::Disable& c = GetCmdSpace<gles2::Disable>();
-    c.Init(cap);
+    gles2::Disable* c = GetCmdSpace<gles2::Disable>();
+    if (c) {
+      c->Init(cap);
+    }
   }
 
   void DisableVertexAttribArray(GLuint index) {
-    gles2::DisableVertexAttribArray& c =
+    gles2::DisableVertexAttribArray* c =
         GetCmdSpace<gles2::DisableVertexAttribArray>();
-    c.Init(index);
+    if (c) {
+      c->Init(index);
+    }
   }
 
   void DrawArrays(GLenum mode, GLint first, GLsizei count) {
-    gles2::DrawArrays& c = GetCmdSpace<gles2::DrawArrays>();
-    c.Init(mode, first, count);
+    gles2::DrawArrays* c = GetCmdSpace<gles2::DrawArrays>();
+    if (c) {
+      c->Init(mode, first, count);
+    }
   }
 
   void DrawElements(
       GLenum mode, GLsizei count, GLenum type, GLuint index_offset) {
-    gles2::DrawElements& c = GetCmdSpace<gles2::DrawElements>();
-    c.Init(mode, count, type, index_offset);
+    gles2::DrawElements* c = GetCmdSpace<gles2::DrawElements>();
+    if (c) {
+      c->Init(mode, count, type, index_offset);
+    }
   }
 
   void Enable(GLenum cap) {
-    gles2::Enable& c = GetCmdSpace<gles2::Enable>();
-    c.Init(cap);
+    gles2::Enable* c = GetCmdSpace<gles2::Enable>();
+    if (c) {
+      c->Init(cap);
+    }
   }
 
   void EnableVertexAttribArray(GLuint index) {
-    gles2::EnableVertexAttribArray& c =
+    gles2::EnableVertexAttribArray* c =
         GetCmdSpace<gles2::EnableVertexAttribArray>();
-    c.Init(index);
+    if (c) {
+      c->Init(index);
+    }
   }
 
   void Finish() {
-    gles2::Finish& c = GetCmdSpace<gles2::Finish>();
-    c.Init();
+    gles2::Finish* c = GetCmdSpace<gles2::Finish>();
+    if (c) {
+      c->Init();
+    }
   }
 
   void Flush() {
-    gles2::Flush& c = GetCmdSpace<gles2::Flush>();
-    c.Init();
+    gles2::Flush* c = GetCmdSpace<gles2::Flush>();
+    if (c) {
+      c->Init();
+    }
   }
 
   void FramebufferRenderbuffer(
       GLenum target, GLenum attachment, GLenum renderbuffertarget,
       GLuint renderbuffer) {
-    gles2::FramebufferRenderbuffer& c =
+    gles2::FramebufferRenderbuffer* c =
         GetCmdSpace<gles2::FramebufferRenderbuffer>();
-    c.Init(target, attachment, renderbuffertarget, renderbuffer);
+    if (c) {
+      c->Init(target, attachment, renderbuffertarget, renderbuffer);
+    }
   }
 
   void FramebufferTexture2D(
       GLenum target, GLenum attachment, GLenum textarget, GLuint texture,
       GLint level) {
-    gles2::FramebufferTexture2D& c =
+    gles2::FramebufferTexture2D* c =
         GetCmdSpace<gles2::FramebufferTexture2D>();
-    c.Init(target, attachment, textarget, texture, level);
+    if (c) {
+      c->Init(target, attachment, textarget, texture, level);
+    }
   }
 
   void FrontFace(GLenum mode) {
-    gles2::FrontFace& c = GetCmdSpace<gles2::FrontFace>();
-    c.Init(mode);
+    gles2::FrontFace* c = GetCmdSpace<gles2::FrontFace>();
+    if (c) {
+      c->Init(mode);
+    }
   }
 
   void GenBuffers(
       GLsizei n, uint32 buffers_shm_id, uint32 buffers_shm_offset) {
-    gles2::GenBuffers& c = GetCmdSpace<gles2::GenBuffers>();
-    c.Init(n, buffers_shm_id, buffers_shm_offset);
+    gles2::GenBuffers* c = GetCmdSpace<gles2::GenBuffers>();
+    if (c) {
+      c->Init(n, buffers_shm_id, buffers_shm_offset);
+    }
   }
 
   void GenBuffersImmediate(GLsizei n, GLuint* buffers) {
     const uint32 size = gles2::GenBuffersImmediate::ComputeSize(n);
-    gles2::GenBuffersImmediate& c =
+    gles2::GenBuffersImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::GenBuffersImmediate>(size);
-    c.Init(n, buffers);
+    if (c) {
+      c->Init(n, buffers);
+    }
   }
 
   void GenerateMipmap(GLenum target) {
-    gles2::GenerateMipmap& c = GetCmdSpace<gles2::GenerateMipmap>();
-    c.Init(target);
+    gles2::GenerateMipmap* c = GetCmdSpace<gles2::GenerateMipmap>();
+    if (c) {
+      c->Init(target);
+    }
   }
 
   void GenFramebuffers(
       GLsizei n, uint32 framebuffers_shm_id, uint32 framebuffers_shm_offset) {
-    gles2::GenFramebuffers& c = GetCmdSpace<gles2::GenFramebuffers>();
-    c.Init(n, framebuffers_shm_id, framebuffers_shm_offset);
+    gles2::GenFramebuffers* c = GetCmdSpace<gles2::GenFramebuffers>();
+    if (c) {
+      c->Init(n, framebuffers_shm_id, framebuffers_shm_offset);
+    }
   }
 
   void GenFramebuffersImmediate(GLsizei n, GLuint* framebuffers) {
     const uint32 size = gles2::GenFramebuffersImmediate::ComputeSize(n);
-    gles2::GenFramebuffersImmediate& c =
+    gles2::GenFramebuffersImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::GenFramebuffersImmediate>(size);
-    c.Init(n, framebuffers);
+    if (c) {
+      c->Init(n, framebuffers);
+    }
   }
 
   void GenRenderbuffers(
       GLsizei n, uint32 renderbuffers_shm_id,
       uint32 renderbuffers_shm_offset) {
-    gles2::GenRenderbuffers& c = GetCmdSpace<gles2::GenRenderbuffers>();
-    c.Init(n, renderbuffers_shm_id, renderbuffers_shm_offset);
+    gles2::GenRenderbuffers* c = GetCmdSpace<gles2::GenRenderbuffers>();
+    if (c) {
+      c->Init(n, renderbuffers_shm_id, renderbuffers_shm_offset);
+    }
   }
 
   void GenRenderbuffersImmediate(GLsizei n, GLuint* renderbuffers) {
     const uint32 size = gles2::GenRenderbuffersImmediate::ComputeSize(n);
-    gles2::GenRenderbuffersImmediate& c =
+    gles2::GenRenderbuffersImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::GenRenderbuffersImmediate>(size);
-    c.Init(n, renderbuffers);
+    if (c) {
+      c->Init(n, renderbuffers);
+    }
   }
 
   void GenTextures(
       GLsizei n, uint32 textures_shm_id, uint32 textures_shm_offset) {
-    gles2::GenTextures& c = GetCmdSpace<gles2::GenTextures>();
-    c.Init(n, textures_shm_id, textures_shm_offset);
+    gles2::GenTextures* c = GetCmdSpace<gles2::GenTextures>();
+    if (c) {
+      c->Init(n, textures_shm_id, textures_shm_offset);
+    }
   }
 
   void GenTexturesImmediate(GLsizei n, GLuint* textures) {
     const uint32 size = gles2::GenTexturesImmediate::ComputeSize(n);
-    gles2::GenTexturesImmediate& c =
+    gles2::GenTexturesImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::GenTexturesImmediate>(size);
-    c.Init(n, textures);
+    if (c) {
+      c->Init(n, textures);
+    }
   }
 
   void GetActiveAttrib(
       GLuint program, GLuint index, uint32 name_bucket_id, uint32 result_shm_id,
       uint32 result_shm_offset) {
-    gles2::GetActiveAttrib& c = GetCmdSpace<gles2::GetActiveAttrib>();
-    c.Init(program, index, name_bucket_id, result_shm_id, result_shm_offset);
+    gles2::GetActiveAttrib* c = GetCmdSpace<gles2::GetActiveAttrib>();
+    if (c) {
+      c->Init(
+          program, index, name_bucket_id, result_shm_id, result_shm_offset);
+    }
   }
 
   void GetActiveUniform(
       GLuint program, GLuint index, uint32 name_bucket_id, uint32 result_shm_id,
       uint32 result_shm_offset) {
-    gles2::GetActiveUniform& c = GetCmdSpace<gles2::GetActiveUniform>();
-    c.Init(program, index, name_bucket_id, result_shm_id, result_shm_offset);
+    gles2::GetActiveUniform* c = GetCmdSpace<gles2::GetActiveUniform>();
+    if (c) {
+      c->Init(
+          program, index, name_bucket_id, result_shm_id, result_shm_offset);
+    }
   }
 
   void GetAttachedShaders(
       GLuint program, uint32 result_shm_id, uint32 result_shm_offset,
       uint32 result_size) {
-    gles2::GetAttachedShaders& c = GetCmdSpace<gles2::GetAttachedShaders>();
-    c.Init(program, result_shm_id, result_shm_offset, result_size);
+    gles2::GetAttachedShaders* c = GetCmdSpace<gles2::GetAttachedShaders>();
+    if (c) {
+      c->Init(program, result_shm_id, result_shm_offset, result_size);
+    }
   }
 
   void GetBooleanv(
       GLenum pname, uint32 params_shm_id, uint32 params_shm_offset) {
-    gles2::GetBooleanv& c = GetCmdSpace<gles2::GetBooleanv>();
-    c.Init(pname, params_shm_id, params_shm_offset);
+    gles2::GetBooleanv* c = GetCmdSpace<gles2::GetBooleanv>();
+    if (c) {
+      c->Init(pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetBufferParameteriv(
       GLenum target, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetBufferParameteriv& c =
+    gles2::GetBufferParameteriv* c =
         GetCmdSpace<gles2::GetBufferParameteriv>();
-    c.Init(target, pname, params_shm_id, params_shm_offset);
+    if (c) {
+      c->Init(target, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetError(uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::GetError& c = GetCmdSpace<gles2::GetError>();
-    c.Init(result_shm_id, result_shm_offset);
+    gles2::GetError* c = GetCmdSpace<gles2::GetError>();
+    if (c) {
+      c->Init(result_shm_id, result_shm_offset);
+    }
   }
 
   void GetFloatv(
       GLenum pname, uint32 params_shm_id, uint32 params_shm_offset) {
-    gles2::GetFloatv& c = GetCmdSpace<gles2::GetFloatv>();
-    c.Init(pname, params_shm_id, params_shm_offset);
+    gles2::GetFloatv* c = GetCmdSpace<gles2::GetFloatv>();
+    if (c) {
+      c->Init(pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetFramebufferAttachmentParameteriv(
       GLenum target, GLenum attachment, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetFramebufferAttachmentParameteriv& c =
+    gles2::GetFramebufferAttachmentParameteriv* c =
         GetCmdSpace<gles2::GetFramebufferAttachmentParameteriv>();
-    c.Init(target, attachment, pname, params_shm_id, params_shm_offset);
+    if (c) {
+      c->Init(target, attachment, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetIntegerv(
       GLenum pname, uint32 params_shm_id, uint32 params_shm_offset) {
-    gles2::GetIntegerv& c = GetCmdSpace<gles2::GetIntegerv>();
-    c.Init(pname, params_shm_id, params_shm_offset);
+    gles2::GetIntegerv* c = GetCmdSpace<gles2::GetIntegerv>();
+    if (c) {
+      c->Init(pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetProgramiv(
       GLuint program, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetProgramiv& c = GetCmdSpace<gles2::GetProgramiv>();
-    c.Init(program, pname, params_shm_id, params_shm_offset);
+    gles2::GetProgramiv* c = GetCmdSpace<gles2::GetProgramiv>();
+    if (c) {
+      c->Init(program, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetProgramInfoLog(GLuint program, uint32 bucket_id) {
-    gles2::GetProgramInfoLog& c = GetCmdSpace<gles2::GetProgramInfoLog>();
-    c.Init(program, bucket_id);
+    gles2::GetProgramInfoLog* c = GetCmdSpace<gles2::GetProgramInfoLog>();
+    if (c) {
+      c->Init(program, bucket_id);
+    }
   }
 
   void GetRenderbufferParameteriv(
       GLenum target, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetRenderbufferParameteriv& c =
+    gles2::GetRenderbufferParameteriv* c =
         GetCmdSpace<gles2::GetRenderbufferParameteriv>();
-    c.Init(target, pname, params_shm_id, params_shm_offset);
+    if (c) {
+      c->Init(target, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetShaderiv(
       GLuint shader, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetShaderiv& c = GetCmdSpace<gles2::GetShaderiv>();
-    c.Init(shader, pname, params_shm_id, params_shm_offset);
+    gles2::GetShaderiv* c = GetCmdSpace<gles2::GetShaderiv>();
+    if (c) {
+      c->Init(shader, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetShaderInfoLog(GLuint shader, uint32 bucket_id) {
-    gles2::GetShaderInfoLog& c = GetCmdSpace<gles2::GetShaderInfoLog>();
-    c.Init(shader, bucket_id);
+    gles2::GetShaderInfoLog* c = GetCmdSpace<gles2::GetShaderInfoLog>();
+    if (c) {
+      c->Init(shader, bucket_id);
+    }
   }
 
   void GetShaderPrecisionFormat(
       GLenum shadertype, GLenum precisiontype, uint32 result_shm_id,
       uint32 result_shm_offset) {
-    gles2::GetShaderPrecisionFormat& c =
+    gles2::GetShaderPrecisionFormat* c =
         GetCmdSpace<gles2::GetShaderPrecisionFormat>();
-    c.Init(shadertype, precisiontype, result_shm_id, result_shm_offset);
+    if (c) {
+      c->Init(shadertype, precisiontype, result_shm_id, result_shm_offset);
+    }
   }
 
   void GetShaderSource(GLuint shader, uint32 bucket_id) {
-    gles2::GetShaderSource& c = GetCmdSpace<gles2::GetShaderSource>();
-    c.Init(shader, bucket_id);
+    gles2::GetShaderSource* c = GetCmdSpace<gles2::GetShaderSource>();
+    if (c) {
+      c->Init(shader, bucket_id);
+    }
   }
 
   void GetString(GLenum name, uint32 bucket_id) {
-    gles2::GetString& c = GetCmdSpace<gles2::GetString>();
-    c.Init(name, bucket_id);
+    gles2::GetString* c = GetCmdSpace<gles2::GetString>();
+    if (c) {
+      c->Init(name, bucket_id);
+    }
   }
 
   void GetTexParameterfv(
       GLenum target, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetTexParameterfv& c = GetCmdSpace<gles2::GetTexParameterfv>();
-    c.Init(target, pname, params_shm_id, params_shm_offset);
+    gles2::GetTexParameterfv* c = GetCmdSpace<gles2::GetTexParameterfv>();
+    if (c) {
+      c->Init(target, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetTexParameteriv(
       GLenum target, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetTexParameteriv& c = GetCmdSpace<gles2::GetTexParameteriv>();
-    c.Init(target, pname, params_shm_id, params_shm_offset);
+    gles2::GetTexParameteriv* c = GetCmdSpace<gles2::GetTexParameteriv>();
+    if (c) {
+      c->Init(target, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetUniformfv(
       GLuint program, GLint location, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetUniformfv& c = GetCmdSpace<gles2::GetUniformfv>();
-    c.Init(program, location, params_shm_id, params_shm_offset);
+    gles2::GetUniformfv* c = GetCmdSpace<gles2::GetUniformfv>();
+    if (c) {
+      c->Init(program, location, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetUniformiv(
       GLuint program, GLint location, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetUniformiv& c = GetCmdSpace<gles2::GetUniformiv>();
-    c.Init(program, location, params_shm_id, params_shm_offset);
+    gles2::GetUniformiv* c = GetCmdSpace<gles2::GetUniformiv>();
+    if (c) {
+      c->Init(program, location, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetVertexAttribfv(
       GLuint index, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetVertexAttribfv& c = GetCmdSpace<gles2::GetVertexAttribfv>();
-    c.Init(index, pname, params_shm_id, params_shm_offset);
+    gles2::GetVertexAttribfv* c = GetCmdSpace<gles2::GetVertexAttribfv>();
+    if (c) {
+      c->Init(index, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetVertexAttribiv(
       GLuint index, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::GetVertexAttribiv& c = GetCmdSpace<gles2::GetVertexAttribiv>();
-    c.Init(index, pname, params_shm_id, params_shm_offset);
+    gles2::GetVertexAttribiv* c = GetCmdSpace<gles2::GetVertexAttribiv>();
+    if (c) {
+      c->Init(index, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void GetVertexAttribPointerv(
       GLuint index, GLenum pname, uint32 pointer_shm_id,
       uint32 pointer_shm_offset) {
-    gles2::GetVertexAttribPointerv& c =
+    gles2::GetVertexAttribPointerv* c =
         GetCmdSpace<gles2::GetVertexAttribPointerv>();
-    c.Init(index, pname, pointer_shm_id, pointer_shm_offset);
+    if (c) {
+      c->Init(index, pname, pointer_shm_id, pointer_shm_offset);
+    }
   }
 
   void Hint(GLenum target, GLenum mode) {
-    gles2::Hint& c = GetCmdSpace<gles2::Hint>();
-    c.Init(target, mode);
+    gles2::Hint* c = GetCmdSpace<gles2::Hint>();
+    if (c) {
+      c->Init(target, mode);
+    }
   }
 
   void IsBuffer(
       GLuint buffer, uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::IsBuffer& c = GetCmdSpace<gles2::IsBuffer>();
-    c.Init(buffer, result_shm_id, result_shm_offset);
+    gles2::IsBuffer* c = GetCmdSpace<gles2::IsBuffer>();
+    if (c) {
+      c->Init(buffer, result_shm_id, result_shm_offset);
+    }
   }
 
   void IsEnabled(GLenum cap, uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::IsEnabled& c = GetCmdSpace<gles2::IsEnabled>();
-    c.Init(cap, result_shm_id, result_shm_offset);
+    gles2::IsEnabled* c = GetCmdSpace<gles2::IsEnabled>();
+    if (c) {
+      c->Init(cap, result_shm_id, result_shm_offset);
+    }
   }
 
   void IsFramebuffer(
       GLuint framebuffer, uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::IsFramebuffer& c = GetCmdSpace<gles2::IsFramebuffer>();
-    c.Init(framebuffer, result_shm_id, result_shm_offset);
+    gles2::IsFramebuffer* c = GetCmdSpace<gles2::IsFramebuffer>();
+    if (c) {
+      c->Init(framebuffer, result_shm_id, result_shm_offset);
+    }
   }
 
   void IsProgram(
       GLuint program, uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::IsProgram& c = GetCmdSpace<gles2::IsProgram>();
-    c.Init(program, result_shm_id, result_shm_offset);
+    gles2::IsProgram* c = GetCmdSpace<gles2::IsProgram>();
+    if (c) {
+      c->Init(program, result_shm_id, result_shm_offset);
+    }
   }
 
   void IsRenderbuffer(
       GLuint renderbuffer, uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::IsRenderbuffer& c = GetCmdSpace<gles2::IsRenderbuffer>();
-    c.Init(renderbuffer, result_shm_id, result_shm_offset);
+    gles2::IsRenderbuffer* c = GetCmdSpace<gles2::IsRenderbuffer>();
+    if (c) {
+      c->Init(renderbuffer, result_shm_id, result_shm_offset);
+    }
   }
 
   void IsShader(
       GLuint shader, uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::IsShader& c = GetCmdSpace<gles2::IsShader>();
-    c.Init(shader, result_shm_id, result_shm_offset);
+    gles2::IsShader* c = GetCmdSpace<gles2::IsShader>();
+    if (c) {
+      c->Init(shader, result_shm_id, result_shm_offset);
+    }
   }
 
   void IsTexture(
       GLuint texture, uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::IsTexture& c = GetCmdSpace<gles2::IsTexture>();
-    c.Init(texture, result_shm_id, result_shm_offset);
+    gles2::IsTexture* c = GetCmdSpace<gles2::IsTexture>();
+    if (c) {
+      c->Init(texture, result_shm_id, result_shm_offset);
+    }
   }
 
   void LineWidth(GLfloat width) {
-    gles2::LineWidth& c = GetCmdSpace<gles2::LineWidth>();
-    c.Init(width);
+    gles2::LineWidth* c = GetCmdSpace<gles2::LineWidth>();
+    if (c) {
+      c->Init(width);
+    }
   }
 
   void LinkProgram(GLuint program) {
-    gles2::LinkProgram& c = GetCmdSpace<gles2::LinkProgram>();
-    c.Init(program);
+    gles2::LinkProgram* c = GetCmdSpace<gles2::LinkProgram>();
+    if (c) {
+      c->Init(program);
+    }
   }
 
   void PixelStorei(GLenum pname, GLint param) {
-    gles2::PixelStorei& c = GetCmdSpace<gles2::PixelStorei>();
-    c.Init(pname, param);
+    gles2::PixelStorei* c = GetCmdSpace<gles2::PixelStorei>();
+    if (c) {
+      c->Init(pname, param);
+    }
   }
 
   void PolygonOffset(GLfloat factor, GLfloat units) {
-    gles2::PolygonOffset& c = GetCmdSpace<gles2::PolygonOffset>();
-    c.Init(factor, units);
+    gles2::PolygonOffset* c = GetCmdSpace<gles2::PolygonOffset>();
+    if (c) {
+      c->Init(factor, units);
+    }
   }
 
   void ReadPixels(
       GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
       GLenum type, uint32 pixels_shm_id, uint32 pixels_shm_offset,
       uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::ReadPixels& c = GetCmdSpace<gles2::ReadPixels>();
-    c.Init(
-        x, y, width, height, format, type, pixels_shm_id, pixels_shm_offset,
-        result_shm_id, result_shm_offset);
+    gles2::ReadPixels* c = GetCmdSpace<gles2::ReadPixels>();
+    if (c) {
+      c->Init(
+          x, y, width, height, format, type, pixels_shm_id, pixels_shm_offset,
+          result_shm_id, result_shm_offset);
+    }
   }
 
   void ReleaseShaderCompiler() {
-    gles2::ReleaseShaderCompiler& c =
+    gles2::ReleaseShaderCompiler* c =
         GetCmdSpace<gles2::ReleaseShaderCompiler>();
-    c.Init();
+    if (c) {
+      c->Init();
+    }
   }
 
   void RenderbufferStorage(
       GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {
-    gles2::RenderbufferStorage& c = GetCmdSpace<gles2::RenderbufferStorage>();
-    c.Init(target, internalformat, width, height);
+    gles2::RenderbufferStorage* c = GetCmdSpace<gles2::RenderbufferStorage>();
+    if (c) {
+      c->Init(target, internalformat, width, height);
+    }
   }
 
   void SampleCoverage(GLclampf value, GLboolean invert) {
-    gles2::SampleCoverage& c = GetCmdSpace<gles2::SampleCoverage>();
-    c.Init(value, invert);
+    gles2::SampleCoverage* c = GetCmdSpace<gles2::SampleCoverage>();
+    if (c) {
+      c->Init(value, invert);
+    }
   }
 
   void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
-    gles2::Scissor& c = GetCmdSpace<gles2::Scissor>();
-    c.Init(x, y, width, height);
+    gles2::Scissor* c = GetCmdSpace<gles2::Scissor>();
+    if (c) {
+      c->Init(x, y, width, height);
+    }
   }
 
   void ShaderBinary(
       GLsizei n, uint32 shaders_shm_id, uint32 shaders_shm_offset,
       GLenum binaryformat, uint32 binary_shm_id, uint32 binary_shm_offset,
       GLsizei length) {
-    gles2::ShaderBinary& c = GetCmdSpace<gles2::ShaderBinary>();
-    c.Init(
-        n, shaders_shm_id, shaders_shm_offset, binaryformat, binary_shm_id,
-        binary_shm_offset, length);
+    gles2::ShaderBinary* c = GetCmdSpace<gles2::ShaderBinary>();
+    if (c) {
+      c->Init(
+          n, shaders_shm_id, shaders_shm_offset, binaryformat, binary_shm_id,
+          binary_shm_offset, length);
+    }
   }
 
   void ShaderSource(
       GLuint shader, uint32 data_shm_id, uint32 data_shm_offset,
       uint32 data_size) {
-    gles2::ShaderSource& c = GetCmdSpace<gles2::ShaderSource>();
-    c.Init(shader, data_shm_id, data_shm_offset, data_size);
+    gles2::ShaderSource* c = GetCmdSpace<gles2::ShaderSource>();
+    if (c) {
+      c->Init(shader, data_shm_id, data_shm_offset, data_size);
+    }
   }
 
   void ShaderSourceImmediate(GLuint shader, uint32 data_size) {
     const uint32 s = 0;  // TODO(gman): compute correct size
-    gles2::ShaderSourceImmediate& c =
+    gles2::ShaderSourceImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::ShaderSourceImmediate>(s);
-    c.Init(shader, data_size);
+    if (c) {
+      c->Init(shader, data_size);
+    }
   }
 
   void ShaderSourceBucket(GLuint shader, uint32 data_bucket_id) {
-    gles2::ShaderSourceBucket& c = GetCmdSpace<gles2::ShaderSourceBucket>();
-    c.Init(shader, data_bucket_id);
+    gles2::ShaderSourceBucket* c = GetCmdSpace<gles2::ShaderSourceBucket>();
+    if (c) {
+      c->Init(shader, data_bucket_id);
+    }
   }
 
   void StencilFunc(GLenum func, GLint ref, GLuint mask) {
-    gles2::StencilFunc& c = GetCmdSpace<gles2::StencilFunc>();
-    c.Init(func, ref, mask);
+    gles2::StencilFunc* c = GetCmdSpace<gles2::StencilFunc>();
+    if (c) {
+      c->Init(func, ref, mask);
+    }
   }
 
   void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) {
-    gles2::StencilFuncSeparate& c = GetCmdSpace<gles2::StencilFuncSeparate>();
-    c.Init(face, func, ref, mask);
+    gles2::StencilFuncSeparate* c = GetCmdSpace<gles2::StencilFuncSeparate>();
+    if (c) {
+      c->Init(face, func, ref, mask);
+    }
   }
 
   void StencilMask(GLuint mask) {
-    gles2::StencilMask& c = GetCmdSpace<gles2::StencilMask>();
-    c.Init(mask);
+    gles2::StencilMask* c = GetCmdSpace<gles2::StencilMask>();
+    if (c) {
+      c->Init(mask);
+    }
   }
 
   void StencilMaskSeparate(GLenum face, GLuint mask) {
-    gles2::StencilMaskSeparate& c = GetCmdSpace<gles2::StencilMaskSeparate>();
-    c.Init(face, mask);
+    gles2::StencilMaskSeparate* c = GetCmdSpace<gles2::StencilMaskSeparate>();
+    if (c) {
+      c->Init(face, mask);
+    }
   }
 
   void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
-    gles2::StencilOp& c = GetCmdSpace<gles2::StencilOp>();
-    c.Init(fail, zfail, zpass);
+    gles2::StencilOp* c = GetCmdSpace<gles2::StencilOp>();
+    if (c) {
+      c->Init(fail, zfail, zpass);
+    }
   }
 
   void StencilOpSeparate(
       GLenum face, GLenum fail, GLenum zfail, GLenum zpass) {
-    gles2::StencilOpSeparate& c = GetCmdSpace<gles2::StencilOpSeparate>();
-    c.Init(face, fail, zfail, zpass);
+    gles2::StencilOpSeparate* c = GetCmdSpace<gles2::StencilOpSeparate>();
+    if (c) {
+      c->Init(face, fail, zfail, zpass);
+    }
   }
 
   void TexImage2D(
       GLenum target, GLint level, GLint internalformat, GLsizei width,
       GLsizei height, GLint border, GLenum format, GLenum type,
       uint32 pixels_shm_id, uint32 pixels_shm_offset) {
-    gles2::TexImage2D& c = GetCmdSpace<gles2::TexImage2D>();
-    c.Init(
-        target, level, internalformat, width, height, border, format, type,
-        pixels_shm_id, pixels_shm_offset);
+    gles2::TexImage2D* c = GetCmdSpace<gles2::TexImage2D>();
+    if (c) {
+      c->Init(
+          target, level, internalformat, width, height, border, format, type,
+          pixels_shm_id, pixels_shm_offset);
+    }
   }
 
   void TexImage2DImmediate(
       GLenum target, GLint level, GLint internalformat, GLsizei width,
       GLsizei height, GLint border, GLenum format, GLenum type) {
     const uint32 s = 0;  // TODO(gman): compute correct size
-    gles2::TexImage2DImmediate& c =
+    gles2::TexImage2DImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::TexImage2DImmediate>(s);
-    c.Init(target, level, internalformat, width, height, border, format, type);
+    if (c) {
+      c->Init(
+          target, level, internalformat, width, height, border, format, type);
+    }
   }
 
   void TexParameterf(GLenum target, GLenum pname, GLfloat param) {
-    gles2::TexParameterf& c = GetCmdSpace<gles2::TexParameterf>();
-    c.Init(target, pname, param);
+    gles2::TexParameterf* c = GetCmdSpace<gles2::TexParameterf>();
+    if (c) {
+      c->Init(target, pname, param);
+    }
   }
 
   void TexParameterfv(
       GLenum target, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::TexParameterfv& c = GetCmdSpace<gles2::TexParameterfv>();
-    c.Init(target, pname, params_shm_id, params_shm_offset);
+    gles2::TexParameterfv* c = GetCmdSpace<gles2::TexParameterfv>();
+    if (c) {
+      c->Init(target, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void TexParameterfvImmediate(
       GLenum target, GLenum pname, const GLfloat* params) {
     const uint32 size = gles2::TexParameterfvImmediate::ComputeSize();
-    gles2::TexParameterfvImmediate& c =
+    gles2::TexParameterfvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::TexParameterfvImmediate>(size);
-    c.Init(target, pname, params);
+    if (c) {
+      c->Init(target, pname, params);
+    }
   }
 
   void TexParameteri(GLenum target, GLenum pname, GLint param) {
-    gles2::TexParameteri& c = GetCmdSpace<gles2::TexParameteri>();
-    c.Init(target, pname, param);
+    gles2::TexParameteri* c = GetCmdSpace<gles2::TexParameteri>();
+    if (c) {
+      c->Init(target, pname, param);
+    }
   }
 
   void TexParameteriv(
       GLenum target, GLenum pname, uint32 params_shm_id,
       uint32 params_shm_offset) {
-    gles2::TexParameteriv& c = GetCmdSpace<gles2::TexParameteriv>();
-    c.Init(target, pname, params_shm_id, params_shm_offset);
+    gles2::TexParameteriv* c = GetCmdSpace<gles2::TexParameteriv>();
+    if (c) {
+      c->Init(target, pname, params_shm_id, params_shm_offset);
+    }
   }
 
   void TexParameterivImmediate(
       GLenum target, GLenum pname, const GLint* params) {
     const uint32 size = gles2::TexParameterivImmediate::ComputeSize();
-    gles2::TexParameterivImmediate& c =
+    gles2::TexParameterivImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::TexParameterivImmediate>(size);
-    c.Init(target, pname, params);
+    if (c) {
+      c->Init(target, pname, params);
+    }
   }
 
   void TexSubImage2D(
       GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
       GLsizei height, GLenum format, GLenum type, uint32 pixels_shm_id,
       uint32 pixels_shm_offset, GLboolean internal) {
-    gles2::TexSubImage2D& c = GetCmdSpace<gles2::TexSubImage2D>();
-    c.Init(
-        target, level, xoffset, yoffset, width, height, format, type,
-        pixels_shm_id, pixels_shm_offset, internal);
+    gles2::TexSubImage2D* c = GetCmdSpace<gles2::TexSubImage2D>();
+    if (c) {
+      c->Init(
+          target, level, xoffset, yoffset, width, height, format, type,
+          pixels_shm_id, pixels_shm_offset, internal);
+    }
   }
 
   void TexSubImage2DImmediate(
       GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
       GLsizei height, GLenum format, GLenum type, GLboolean internal) {
     const uint32 s = 0;  // TODO(gman): compute correct size
-    gles2::TexSubImage2DImmediate& c =
+    gles2::TexSubImage2DImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::TexSubImage2DImmediate>(s);
-    c.Init(
-        target, level, xoffset, yoffset, width, height, format, type,
-        internal);
+    if (c) {
+      c->Init(
+          target, level, xoffset, yoffset, width, height, format, type,
+          internal);
+    }
   }
 
   void Uniform1f(GLint location, GLfloat x) {
-    gles2::Uniform1f& c = GetCmdSpace<gles2::Uniform1f>();
-    c.Init(location, x);
+    gles2::Uniform1f* c = GetCmdSpace<gles2::Uniform1f>();
+    if (c) {
+      c->Init(location, x);
+    }
   }
 
   void Uniform1fv(
       GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) {
-    gles2::Uniform1fv& c = GetCmdSpace<gles2::Uniform1fv>();
-    c.Init(location, count, v_shm_id, v_shm_offset);
+    gles2::Uniform1fv* c = GetCmdSpace<gles2::Uniform1fv>();
+    if (c) {
+      c->Init(location, count, v_shm_id, v_shm_offset);
+    }
   }
 
   void Uniform1fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
     const uint32 size = gles2::Uniform1fvImmediate::ComputeSize(count);
-    gles2::Uniform1fvImmediate& c =
+    gles2::Uniform1fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::Uniform1fvImmediate>(size);
-    c.Init(location, count, v);
+    if (c) {
+      c->Init(location, count, v);
+    }
   }
 
   void Uniform1i(GLint location, GLint x) {
-    gles2::Uniform1i& c = GetCmdSpace<gles2::Uniform1i>();
-    c.Init(location, x);
+    gles2::Uniform1i* c = GetCmdSpace<gles2::Uniform1i>();
+    if (c) {
+      c->Init(location, x);
+    }
   }
 
   void Uniform1iv(
       GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) {
-    gles2::Uniform1iv& c = GetCmdSpace<gles2::Uniform1iv>();
-    c.Init(location, count, v_shm_id, v_shm_offset);
+    gles2::Uniform1iv* c = GetCmdSpace<gles2::Uniform1iv>();
+    if (c) {
+      c->Init(location, count, v_shm_id, v_shm_offset);
+    }
   }
 
   void Uniform1ivImmediate(GLint location, GLsizei count, const GLint* v) {
     const uint32 size = gles2::Uniform1ivImmediate::ComputeSize(count);
-    gles2::Uniform1ivImmediate& c =
+    gles2::Uniform1ivImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::Uniform1ivImmediate>(size);
-    c.Init(location, count, v);
+    if (c) {
+      c->Init(location, count, v);
+    }
   }
 
   void Uniform2f(GLint location, GLfloat x, GLfloat y) {
-    gles2::Uniform2f& c = GetCmdSpace<gles2::Uniform2f>();
-    c.Init(location, x, y);
+    gles2::Uniform2f* c = GetCmdSpace<gles2::Uniform2f>();
+    if (c) {
+      c->Init(location, x, y);
+    }
   }
 
   void Uniform2fv(
       GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) {
-    gles2::Uniform2fv& c = GetCmdSpace<gles2::Uniform2fv>();
-    c.Init(location, count, v_shm_id, v_shm_offset);
+    gles2::Uniform2fv* c = GetCmdSpace<gles2::Uniform2fv>();
+    if (c) {
+      c->Init(location, count, v_shm_id, v_shm_offset);
+    }
   }
 
   void Uniform2fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
     const uint32 size = gles2::Uniform2fvImmediate::ComputeSize(count);
-    gles2::Uniform2fvImmediate& c =
+    gles2::Uniform2fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::Uniform2fvImmediate>(size);
-    c.Init(location, count, v);
+    if (c) {
+      c->Init(location, count, v);
+    }
   }
 
   void Uniform2i(GLint location, GLint x, GLint y) {
-    gles2::Uniform2i& c = GetCmdSpace<gles2::Uniform2i>();
-    c.Init(location, x, y);
+    gles2::Uniform2i* c = GetCmdSpace<gles2::Uniform2i>();
+    if (c) {
+      c->Init(location, x, y);
+    }
   }
 
   void Uniform2iv(
       GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) {
-    gles2::Uniform2iv& c = GetCmdSpace<gles2::Uniform2iv>();
-    c.Init(location, count, v_shm_id, v_shm_offset);
+    gles2::Uniform2iv* c = GetCmdSpace<gles2::Uniform2iv>();
+    if (c) {
+      c->Init(location, count, v_shm_id, v_shm_offset);
+    }
   }
 
   void Uniform2ivImmediate(GLint location, GLsizei count, const GLint* v) {
     const uint32 size = gles2::Uniform2ivImmediate::ComputeSize(count);
-    gles2::Uniform2ivImmediate& c =
+    gles2::Uniform2ivImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::Uniform2ivImmediate>(size);
-    c.Init(location, count, v);
+    if (c) {
+      c->Init(location, count, v);
+    }
   }
 
   void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
-    gles2::Uniform3f& c = GetCmdSpace<gles2::Uniform3f>();
-    c.Init(location, x, y, z);
+    gles2::Uniform3f* c = GetCmdSpace<gles2::Uniform3f>();
+    if (c) {
+      c->Init(location, x, y, z);
+    }
   }
 
   void Uniform3fv(
       GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) {
-    gles2::Uniform3fv& c = GetCmdSpace<gles2::Uniform3fv>();
-    c.Init(location, count, v_shm_id, v_shm_offset);
+    gles2::Uniform3fv* c = GetCmdSpace<gles2::Uniform3fv>();
+    if (c) {
+      c->Init(location, count, v_shm_id, v_shm_offset);
+    }
   }
 
   void Uniform3fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
     const uint32 size = gles2::Uniform3fvImmediate::ComputeSize(count);
-    gles2::Uniform3fvImmediate& c =
+    gles2::Uniform3fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::Uniform3fvImmediate>(size);
-    c.Init(location, count, v);
+    if (c) {
+      c->Init(location, count, v);
+    }
   }
 
   void Uniform3i(GLint location, GLint x, GLint y, GLint z) {
-    gles2::Uniform3i& c = GetCmdSpace<gles2::Uniform3i>();
-    c.Init(location, x, y, z);
+    gles2::Uniform3i* c = GetCmdSpace<gles2::Uniform3i>();
+    if (c) {
+      c->Init(location, x, y, z);
+    }
   }
 
   void Uniform3iv(
       GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) {
-    gles2::Uniform3iv& c = GetCmdSpace<gles2::Uniform3iv>();
-    c.Init(location, count, v_shm_id, v_shm_offset);
+    gles2::Uniform3iv* c = GetCmdSpace<gles2::Uniform3iv>();
+    if (c) {
+      c->Init(location, count, v_shm_id, v_shm_offset);
+    }
   }
 
   void Uniform3ivImmediate(GLint location, GLsizei count, const GLint* v) {
     const uint32 size = gles2::Uniform3ivImmediate::ComputeSize(count);
-    gles2::Uniform3ivImmediate& c =
+    gles2::Uniform3ivImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::Uniform3ivImmediate>(size);
-    c.Init(location, count, v);
+    if (c) {
+      c->Init(location, count, v);
+    }
   }
 
   void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
-    gles2::Uniform4f& c = GetCmdSpace<gles2::Uniform4f>();
-    c.Init(location, x, y, z, w);
+    gles2::Uniform4f* c = GetCmdSpace<gles2::Uniform4f>();
+    if (c) {
+      c->Init(location, x, y, z, w);
+    }
   }
 
   void Uniform4fv(
       GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) {
-    gles2::Uniform4fv& c = GetCmdSpace<gles2::Uniform4fv>();
-    c.Init(location, count, v_shm_id, v_shm_offset);
+    gles2::Uniform4fv* c = GetCmdSpace<gles2::Uniform4fv>();
+    if (c) {
+      c->Init(location, count, v_shm_id, v_shm_offset);
+    }
   }
 
   void Uniform4fvImmediate(GLint location, GLsizei count, const GLfloat* v) {
     const uint32 size = gles2::Uniform4fvImmediate::ComputeSize(count);
-    gles2::Uniform4fvImmediate& c =
+    gles2::Uniform4fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::Uniform4fvImmediate>(size);
-    c.Init(location, count, v);
+    if (c) {
+      c->Init(location, count, v);
+    }
   }
 
   void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
-    gles2::Uniform4i& c = GetCmdSpace<gles2::Uniform4i>();
-    c.Init(location, x, y, z, w);
+    gles2::Uniform4i* c = GetCmdSpace<gles2::Uniform4i>();
+    if (c) {
+      c->Init(location, x, y, z, w);
+    }
   }
 
   void Uniform4iv(
       GLint location, GLsizei count, uint32 v_shm_id, uint32 v_shm_offset) {
-    gles2::Uniform4iv& c = GetCmdSpace<gles2::Uniform4iv>();
-    c.Init(location, count, v_shm_id, v_shm_offset);
+    gles2::Uniform4iv* c = GetCmdSpace<gles2::Uniform4iv>();
+    if (c) {
+      c->Init(location, count, v_shm_id, v_shm_offset);
+    }
   }
 
   void Uniform4ivImmediate(GLint location, GLsizei count, const GLint* v) {
     const uint32 size = gles2::Uniform4ivImmediate::ComputeSize(count);
-    gles2::Uniform4ivImmediate& c =
+    gles2::Uniform4ivImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::Uniform4ivImmediate>(size);
-    c.Init(location, count, v);
+    if (c) {
+      c->Init(location, count, v);
+    }
   }
 
   void UniformMatrix2fv(
       GLint location, GLsizei count, GLboolean transpose, uint32 value_shm_id,
       uint32 value_shm_offset) {
-    gles2::UniformMatrix2fv& c = GetCmdSpace<gles2::UniformMatrix2fv>();
-    c.Init(location, count, transpose, value_shm_id, value_shm_offset);
+    gles2::UniformMatrix2fv* c = GetCmdSpace<gles2::UniformMatrix2fv>();
+    if (c) {
+      c->Init(location, count, transpose, value_shm_id, value_shm_offset);
+    }
   }
 
   void UniformMatrix2fvImmediate(
       GLint location, GLsizei count, GLboolean transpose,
       const GLfloat* value) {
     const uint32 size = gles2::UniformMatrix2fvImmediate::ComputeSize(count);
-    gles2::UniformMatrix2fvImmediate& c =
+    gles2::UniformMatrix2fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::UniformMatrix2fvImmediate>(size);
-    c.Init(location, count, transpose, value);
+    if (c) {
+      c->Init(location, count, transpose, value);
+    }
   }
 
   void UniformMatrix3fv(
       GLint location, GLsizei count, GLboolean transpose, uint32 value_shm_id,
       uint32 value_shm_offset) {
-    gles2::UniformMatrix3fv& c = GetCmdSpace<gles2::UniformMatrix3fv>();
-    c.Init(location, count, transpose, value_shm_id, value_shm_offset);
+    gles2::UniformMatrix3fv* c = GetCmdSpace<gles2::UniformMatrix3fv>();
+    if (c) {
+      c->Init(location, count, transpose, value_shm_id, value_shm_offset);
+    }
   }
 
   void UniformMatrix3fvImmediate(
       GLint location, GLsizei count, GLboolean transpose,
       const GLfloat* value) {
     const uint32 size = gles2::UniformMatrix3fvImmediate::ComputeSize(count);
-    gles2::UniformMatrix3fvImmediate& c =
+    gles2::UniformMatrix3fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::UniformMatrix3fvImmediate>(size);
-    c.Init(location, count, transpose, value);
+    if (c) {
+      c->Init(location, count, transpose, value);
+    }
   }
 
   void UniformMatrix4fv(
       GLint location, GLsizei count, GLboolean transpose, uint32 value_shm_id,
       uint32 value_shm_offset) {
-    gles2::UniformMatrix4fv& c = GetCmdSpace<gles2::UniformMatrix4fv>();
-    c.Init(location, count, transpose, value_shm_id, value_shm_offset);
+    gles2::UniformMatrix4fv* c = GetCmdSpace<gles2::UniformMatrix4fv>();
+    if (c) {
+      c->Init(location, count, transpose, value_shm_id, value_shm_offset);
+    }
   }
 
   void UniformMatrix4fvImmediate(
       GLint location, GLsizei count, GLboolean transpose,
       const GLfloat* value) {
     const uint32 size = gles2::UniformMatrix4fvImmediate::ComputeSize(count);
-    gles2::UniformMatrix4fvImmediate& c =
+    gles2::UniformMatrix4fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::UniformMatrix4fvImmediate>(size);
-    c.Init(location, count, transpose, value);
+    if (c) {
+      c->Init(location, count, transpose, value);
+    }
   }
 
   void UseProgram(GLuint program) {
-    gles2::UseProgram& c = GetCmdSpace<gles2::UseProgram>();
-    c.Init(program);
+    gles2::UseProgram* c = GetCmdSpace<gles2::UseProgram>();
+    if (c) {
+      c->Init(program);
+    }
   }
 
   void ValidateProgram(GLuint program) {
-    gles2::ValidateProgram& c = GetCmdSpace<gles2::ValidateProgram>();
-    c.Init(program);
+    gles2::ValidateProgram* c = GetCmdSpace<gles2::ValidateProgram>();
+    if (c) {
+      c->Init(program);
+    }
   }
 
   void VertexAttrib1f(GLuint indx, GLfloat x) {
-    gles2::VertexAttrib1f& c = GetCmdSpace<gles2::VertexAttrib1f>();
-    c.Init(indx, x);
+    gles2::VertexAttrib1f* c = GetCmdSpace<gles2::VertexAttrib1f>();
+    if (c) {
+      c->Init(indx, x);
+    }
   }
 
   void VertexAttrib1fv(
       GLuint indx, uint32 values_shm_id, uint32 values_shm_offset) {
-    gles2::VertexAttrib1fv& c = GetCmdSpace<gles2::VertexAttrib1fv>();
-    c.Init(indx, values_shm_id, values_shm_offset);
+    gles2::VertexAttrib1fv* c = GetCmdSpace<gles2::VertexAttrib1fv>();
+    if (c) {
+      c->Init(indx, values_shm_id, values_shm_offset);
+    }
   }
 
   void VertexAttrib1fvImmediate(GLuint indx, const GLfloat* values) {
     const uint32 size = gles2::VertexAttrib1fvImmediate::ComputeSize();
-    gles2::VertexAttrib1fvImmediate& c =
+    gles2::VertexAttrib1fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::VertexAttrib1fvImmediate>(size);
-    c.Init(indx, values);
+    if (c) {
+      c->Init(indx, values);
+    }
   }
 
   void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
-    gles2::VertexAttrib2f& c = GetCmdSpace<gles2::VertexAttrib2f>();
-    c.Init(indx, x, y);
+    gles2::VertexAttrib2f* c = GetCmdSpace<gles2::VertexAttrib2f>();
+    if (c) {
+      c->Init(indx, x, y);
+    }
   }
 
   void VertexAttrib2fv(
       GLuint indx, uint32 values_shm_id, uint32 values_shm_offset) {
-    gles2::VertexAttrib2fv& c = GetCmdSpace<gles2::VertexAttrib2fv>();
-    c.Init(indx, values_shm_id, values_shm_offset);
+    gles2::VertexAttrib2fv* c = GetCmdSpace<gles2::VertexAttrib2fv>();
+    if (c) {
+      c->Init(indx, values_shm_id, values_shm_offset);
+    }
   }
 
   void VertexAttrib2fvImmediate(GLuint indx, const GLfloat* values) {
     const uint32 size = gles2::VertexAttrib2fvImmediate::ComputeSize();
-    gles2::VertexAttrib2fvImmediate& c =
+    gles2::VertexAttrib2fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::VertexAttrib2fvImmediate>(size);
-    c.Init(indx, values);
+    if (c) {
+      c->Init(indx, values);
+    }
   }
 
   void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
-    gles2::VertexAttrib3f& c = GetCmdSpace<gles2::VertexAttrib3f>();
-    c.Init(indx, x, y, z);
+    gles2::VertexAttrib3f* c = GetCmdSpace<gles2::VertexAttrib3f>();
+    if (c) {
+      c->Init(indx, x, y, z);
+    }
   }
 
   void VertexAttrib3fv(
       GLuint indx, uint32 values_shm_id, uint32 values_shm_offset) {
-    gles2::VertexAttrib3fv& c = GetCmdSpace<gles2::VertexAttrib3fv>();
-    c.Init(indx, values_shm_id, values_shm_offset);
+    gles2::VertexAttrib3fv* c = GetCmdSpace<gles2::VertexAttrib3fv>();
+    if (c) {
+      c->Init(indx, values_shm_id, values_shm_offset);
+    }
   }
 
   void VertexAttrib3fvImmediate(GLuint indx, const GLfloat* values) {
     const uint32 size = gles2::VertexAttrib3fvImmediate::ComputeSize();
-    gles2::VertexAttrib3fvImmediate& c =
+    gles2::VertexAttrib3fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::VertexAttrib3fvImmediate>(size);
-    c.Init(indx, values);
+    if (c) {
+      c->Init(indx, values);
+    }
   }
 
   void VertexAttrib4f(
       GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
-    gles2::VertexAttrib4f& c = GetCmdSpace<gles2::VertexAttrib4f>();
-    c.Init(indx, x, y, z, w);
+    gles2::VertexAttrib4f* c = GetCmdSpace<gles2::VertexAttrib4f>();
+    if (c) {
+      c->Init(indx, x, y, z, w);
+    }
   }
 
   void VertexAttrib4fv(
       GLuint indx, uint32 values_shm_id, uint32 values_shm_offset) {
-    gles2::VertexAttrib4fv& c = GetCmdSpace<gles2::VertexAttrib4fv>();
-    c.Init(indx, values_shm_id, values_shm_offset);
+    gles2::VertexAttrib4fv* c = GetCmdSpace<gles2::VertexAttrib4fv>();
+    if (c) {
+      c->Init(indx, values_shm_id, values_shm_offset);
+    }
   }
 
   void VertexAttrib4fvImmediate(GLuint indx, const GLfloat* values) {
     const uint32 size = gles2::VertexAttrib4fvImmediate::ComputeSize();
-    gles2::VertexAttrib4fvImmediate& c =
+    gles2::VertexAttrib4fvImmediate* c =
         GetImmediateCmdSpaceTotalSize<gles2::VertexAttrib4fvImmediate>(size);
-    c.Init(indx, values);
+    if (c) {
+      c->Init(indx, values);
+    }
   }
 
   void VertexAttribPointer(
       GLuint indx, GLint size, GLenum type, GLboolean normalized,
       GLsizei stride, GLuint offset) {
-    gles2::VertexAttribPointer& c = GetCmdSpace<gles2::VertexAttribPointer>();
-    c.Init(indx, size, type, normalized, stride, offset);
+    gles2::VertexAttribPointer* c = GetCmdSpace<gles2::VertexAttribPointer>();
+    if (c) {
+      c->Init(indx, size, type, normalized, stride, offset);
+    }
   }
 
   void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
-    gles2::Viewport& c = GetCmdSpace<gles2::Viewport>();
-    c.Init(x, y, width, height);
+    gles2::Viewport* c = GetCmdSpace<gles2::Viewport>();
+    if (c) {
+      c->Init(x, y, width, height);
+    }
   }
 
   void BlitFramebufferEXT(
       GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0,
       GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
-    gles2::BlitFramebufferEXT& c = GetCmdSpace<gles2::BlitFramebufferEXT>();
-    c.Init(
-        srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    gles2::BlitFramebufferEXT* c = GetCmdSpace<gles2::BlitFramebufferEXT>();
+    if (c) {
+      c->Init(
+          srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask,
+          filter);
+    }
   }
 
   void RenderbufferStorageMultisampleEXT(
       GLenum target, GLsizei samples, GLenum internalformat, GLsizei width,
       GLsizei height) {
-    gles2::RenderbufferStorageMultisampleEXT& c =
+    gles2::RenderbufferStorageMultisampleEXT* c =
         GetCmdSpace<gles2::RenderbufferStorageMultisampleEXT>();
-    c.Init(target, samples, internalformat, width, height);
+    if (c) {
+      c->Init(target, samples, internalformat, width, height);
+    }
   }
 
   void TexStorage2DEXT(
       GLenum target, GLsizei levels, GLint internalFormat, GLsizei width,
       GLsizei height) {
-    gles2::TexStorage2DEXT& c = GetCmdSpace<gles2::TexStorage2DEXT>();
-    c.Init(target, levels, internalFormat, width, height);
+    gles2::TexStorage2DEXT* c = GetCmdSpace<gles2::TexStorage2DEXT>();
+    if (c) {
+      c->Init(target, levels, internalFormat, width, height);
+    }
   }
 
   void SwapBuffers() {
-    gles2::SwapBuffers& c = GetCmdSpace<gles2::SwapBuffers>();
-    c.Init();
+    gles2::SwapBuffers* c = GetCmdSpace<gles2::SwapBuffers>();
+    if (c) {
+      c->Init();
+    }
   }
 
   void GetMaxValueInBufferCHROMIUM(
       GLuint buffer_id, GLsizei count, GLenum type, GLuint offset,
       uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::GetMaxValueInBufferCHROMIUM& c =
+    gles2::GetMaxValueInBufferCHROMIUM* c =
         GetCmdSpace<gles2::GetMaxValueInBufferCHROMIUM>();
-    c.Init(buffer_id, count, type, offset, result_shm_id, result_shm_offset);
+    if (c) {
+      c->Init(
+          buffer_id, count, type, offset, result_shm_id, result_shm_offset);
+    }
   }
 
   void GenSharedIdsCHROMIUM(
       GLuint namespace_id, GLuint id_offset, GLsizei n, uint32 ids_shm_id,
       uint32 ids_shm_offset) {
-    gles2::GenSharedIdsCHROMIUM& c =
+    gles2::GenSharedIdsCHROMIUM* c =
         GetCmdSpace<gles2::GenSharedIdsCHROMIUM>();
-    c.Init(namespace_id, id_offset, n, ids_shm_id, ids_shm_offset);
+    if (c) {
+      c->Init(namespace_id, id_offset, n, ids_shm_id, ids_shm_offset);
+    }
   }
 
   void DeleteSharedIdsCHROMIUM(
       GLuint namespace_id, GLsizei n, uint32 ids_shm_id,
       uint32 ids_shm_offset) {
-    gles2::DeleteSharedIdsCHROMIUM& c =
+    gles2::DeleteSharedIdsCHROMIUM* c =
         GetCmdSpace<gles2::DeleteSharedIdsCHROMIUM>();
-    c.Init(namespace_id, n, ids_shm_id, ids_shm_offset);
+    if (c) {
+      c->Init(namespace_id, n, ids_shm_id, ids_shm_offset);
+    }
   }
 
   void RegisterSharedIdsCHROMIUM(
       GLuint namespace_id, GLsizei n, uint32 ids_shm_id,
       uint32 ids_shm_offset) {
-    gles2::RegisterSharedIdsCHROMIUM& c =
+    gles2::RegisterSharedIdsCHROMIUM* c =
         GetCmdSpace<gles2::RegisterSharedIdsCHROMIUM>();
-    c.Init(namespace_id, n, ids_shm_id, ids_shm_offset);
+    if (c) {
+      c->Init(namespace_id, n, ids_shm_id, ids_shm_offset);
+    }
   }
 
   void EnableFeatureCHROMIUM(
       GLuint bucket_id, uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::EnableFeatureCHROMIUM& c =
+    gles2::EnableFeatureCHROMIUM* c =
         GetCmdSpace<gles2::EnableFeatureCHROMIUM>();
-    c.Init(bucket_id, result_shm_id, result_shm_offset);
+    if (c) {
+      c->Init(bucket_id, result_shm_id, result_shm_offset);
+    }
   }
 
   void ResizeCHROMIUM(GLuint width, GLuint height) {
-    gles2::ResizeCHROMIUM& c = GetCmdSpace<gles2::ResizeCHROMIUM>();
-    c.Init(width, height);
+    gles2::ResizeCHROMIUM* c = GetCmdSpace<gles2::ResizeCHROMIUM>();
+    if (c) {
+      c->Init(width, height);
+    }
   }
 
   void GetRequestableExtensionsCHROMIUM(uint32 bucket_id) {
-    gles2::GetRequestableExtensionsCHROMIUM& c =
+    gles2::GetRequestableExtensionsCHROMIUM* c =
         GetCmdSpace<gles2::GetRequestableExtensionsCHROMIUM>();
-    c.Init(bucket_id);
+    if (c) {
+      c->Init(bucket_id);
+    }
   }
 
   void RequestExtensionCHROMIUM(uint32 bucket_id) {
-    gles2::RequestExtensionCHROMIUM& c =
+    gles2::RequestExtensionCHROMIUM* c =
         GetCmdSpace<gles2::RequestExtensionCHROMIUM>();
-    c.Init(bucket_id);
+    if (c) {
+      c->Init(bucket_id);
+    }
   }
 
   void GetMultipleIntegervCHROMIUM(
       uint32 pnames_shm_id, uint32 pnames_shm_offset, GLuint count,
       uint32 results_shm_id, uint32 results_shm_offset, GLsizeiptr size) {
-    gles2::GetMultipleIntegervCHROMIUM& c =
+    gles2::GetMultipleIntegervCHROMIUM* c =
         GetCmdSpace<gles2::GetMultipleIntegervCHROMIUM>();
-    c.Init(
-        pnames_shm_id, pnames_shm_offset, count, results_shm_id,
-        results_shm_offset, size);
+    if (c) {
+      c->Init(
+          pnames_shm_id, pnames_shm_offset, count, results_shm_id,
+          results_shm_offset, size);
+    }
   }
 
   void GetProgramInfoCHROMIUM(GLuint program, uint32 bucket_id) {
-    gles2::GetProgramInfoCHROMIUM& c =
+    gles2::GetProgramInfoCHROMIUM* c =
         GetCmdSpace<gles2::GetProgramInfoCHROMIUM>();
-    c.Init(program, bucket_id);
+    if (c) {
+      c->Init(program, bucket_id);
+    }
   }
 
   void CreateStreamTextureCHROMIUM(
       GLuint client_id, uint32 result_shm_id, uint32 result_shm_offset) {
-    gles2::CreateStreamTextureCHROMIUM& c =
+    gles2::CreateStreamTextureCHROMIUM* c =
         GetCmdSpace<gles2::CreateStreamTextureCHROMIUM>();
-    c.Init(client_id, result_shm_id, result_shm_offset);
+    if (c) {
+      c->Init(client_id, result_shm_id, result_shm_offset);
+    }
   }
 
   void DestroyStreamTextureCHROMIUM(GLuint texture) {
-    gles2::DestroyStreamTextureCHROMIUM& c =
+    gles2::DestroyStreamTextureCHROMIUM* c =
         GetCmdSpace<gles2::DestroyStreamTextureCHROMIUM>();
-    c.Init(texture);
+    if (c) {
+      c->Init(texture);
+    }
   }
 
   void GetTranslatedShaderSourceANGLE(GLuint shader, uint32 bucket_id) {
-    gles2::GetTranslatedShaderSourceANGLE& c =
+    gles2::GetTranslatedShaderSourceANGLE* c =
         GetCmdSpace<gles2::GetTranslatedShaderSourceANGLE>();
-    c.Init(shader, bucket_id);
+    if (c) {
+      c->Init(shader, bucket_id);
+    }
   }
 
   void PostSubBufferCHROMIUM(GLint x, GLint y, GLint width, GLint height) {
-    gles2::PostSubBufferCHROMIUM& c =
+    gles2::PostSubBufferCHROMIUM* c =
         GetCmdSpace<gles2::PostSubBufferCHROMIUM>();
-    c.Init(x, y, width, height);
+    if (c) {
+      c->Init(x, y, width, height);
+    }
   }
 
   void TexImageIOSurface2DCHROMIUM(
       GLenum target, GLsizei width, GLsizei height, GLuint ioSurfaceId,
       GLuint plane) {
-    gles2::TexImageIOSurface2DCHROMIUM& c =
+    gles2::TexImageIOSurface2DCHROMIUM* c =
         GetCmdSpace<gles2::TexImageIOSurface2DCHROMIUM>();
-    c.Init(target, width, height, ioSurfaceId, plane);
+    if (c) {
+      c->Init(target, width, height, ioSurfaceId, plane);
+    }
   }
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_CMD_HELPER_AUTOGEN_H_
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
index 209f259..2f3cf78 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_1_autogen.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
@@ -878,23 +878,23 @@ TEST_F(GLES2DecoderTest1, GenBuffersInvalidArgs) {
 TEST_F(GLES2DecoderTest1, GenBuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenBuffersARB(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
-  GenBuffersImmediate& cmd = *GetImmediateAs<GenBuffersImmediate>();
+  GenBuffersImmediate* cmd = GetImmediateAs<GenBuffersImmediate>();
   GLuint temp = kNewClientId;
   SpecializedSetup<GenBuffersImmediate, 0>(true);
-  cmd.Init(1, &temp);
+  cmd->Init(1, &temp);
   EXPECT_EQ(error::kNoError,
-            ExecuteImmediateCmd(cmd, sizeof(temp)));
+            ExecuteImmediateCmd(*cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(GetBufferInfo(kNewClientId) != NULL);
 }
 
 TEST_F(GLES2DecoderTest1, GenBuffersImmediateInvalidArgs) {
   EXPECT_CALL(*gl_, GenBuffersARB(_, _)).Times(0);
-  GenBuffersImmediate& cmd = *GetImmediateAs<GenBuffersImmediate>();
+  GenBuffersImmediate* cmd = GetImmediateAs<GenBuffersImmediate>();
   SpecializedSetup<GenBuffersImmediate, 0>(false);
-  cmd.Init(1, &client_buffer_id_);
+  cmd->Init(1, &client_buffer_id_);
   EXPECT_EQ(error::kInvalidArguments,
-            ExecuteImmediateCmd(cmd, sizeof(&client_buffer_id_)));
+            ExecuteImmediateCmd(*cmd, sizeof(&client_buffer_id_)));
 }
 
 TEST_F(GLES2DecoderTest1, GenerateMipmapValidArgs) {
@@ -948,23 +948,23 @@ TEST_F(GLES2DecoderTest1, GenFramebuffersInvalidArgs) {
 TEST_F(GLES2DecoderTest1, GenFramebuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenFramebuffersEXT(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
-  GenFramebuffersImmediate& cmd = *GetImmediateAs<GenFramebuffersImmediate>();
+  GenFramebuffersImmediate* cmd = GetImmediateAs<GenFramebuffersImmediate>();
   GLuint temp = kNewClientId;
   SpecializedSetup<GenFramebuffersImmediate, 0>(true);
-  cmd.Init(1, &temp);
+  cmd->Init(1, &temp);
   EXPECT_EQ(error::kNoError,
-            ExecuteImmediateCmd(cmd, sizeof(temp)));
+            ExecuteImmediateCmd(*cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(GetFramebufferInfo(kNewClientId) != NULL);
 }
 
 TEST_F(GLES2DecoderTest1, GenFramebuffersImmediateInvalidArgs) {
   EXPECT_CALL(*gl_, GenFramebuffersEXT(_, _)).Times(0);
-  GenFramebuffersImmediate& cmd = *GetImmediateAs<GenFramebuffersImmediate>();
+  GenFramebuffersImmediate* cmd = GetImmediateAs<GenFramebuffersImmediate>();
   SpecializedSetup<GenFramebuffersImmediate, 0>(false);
-  cmd.Init(1, &client_framebuffer_id_);
+  cmd->Init(1, &client_framebuffer_id_);
   EXPECT_EQ(error::kInvalidArguments,
-            ExecuteImmediateCmd(cmd, sizeof(&client_framebuffer_id_)));
+            ExecuteImmediateCmd(*cmd, sizeof(&client_framebuffer_id_)));
 }
 
 TEST_F(GLES2DecoderTest1, GenRenderbuffersValidArgs) {
@@ -991,25 +991,23 @@ TEST_F(GLES2DecoderTest1, GenRenderbuffersInvalidArgs) {
 TEST_F(GLES2DecoderTest1, GenRenderbuffersImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenRenderbuffersEXT(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
-  GenRenderbuffersImmediate& cmd =
-      *GetImmediateAs<GenRenderbuffersImmediate>();
+  GenRenderbuffersImmediate* cmd = GetImmediateAs<GenRenderbuffersImmediate>();
   GLuint temp = kNewClientId;
   SpecializedSetup<GenRenderbuffersImmediate, 0>(true);
-  cmd.Init(1, &temp);
+  cmd->Init(1, &temp);
   EXPECT_EQ(error::kNoError,
-            ExecuteImmediateCmd(cmd, sizeof(temp)));
+            ExecuteImmediateCmd(*cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(GetRenderbufferInfo(kNewClientId) != NULL);
 }
 
 TEST_F(GLES2DecoderTest1, GenRenderbuffersImmediateInvalidArgs) {
   EXPECT_CALL(*gl_, GenRenderbuffersEXT(_, _)).Times(0);
-  GenRenderbuffersImmediate& cmd =
-      *GetImmediateAs<GenRenderbuffersImmediate>();
+  GenRenderbuffersImmediate* cmd = GetImmediateAs<GenRenderbuffersImmediate>();
   SpecializedSetup<GenRenderbuffersImmediate, 0>(false);
-  cmd.Init(1, &client_renderbuffer_id_);
+  cmd->Init(1, &client_renderbuffer_id_);
   EXPECT_EQ(error::kInvalidArguments,
-            ExecuteImmediateCmd(cmd, sizeof(&client_renderbuffer_id_)));
+            ExecuteImmediateCmd(*cmd, sizeof(&client_renderbuffer_id_)));
 }
 
 TEST_F(GLES2DecoderTest1, GenTexturesValidArgs) {
@@ -1036,23 +1034,23 @@ TEST_F(GLES2DecoderTest1, GenTexturesInvalidArgs) {
 TEST_F(GLES2DecoderTest1, GenTexturesImmediateValidArgs) {
   EXPECT_CALL(*gl_, GenTextures(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
-  GenTexturesImmediate& cmd = *GetImmediateAs<GenTexturesImmediate>();
+  GenTexturesImmediate* cmd = GetImmediateAs<GenTexturesImmediate>();
   GLuint temp = kNewClientId;
   SpecializedSetup<GenTexturesImmediate, 0>(true);
-  cmd.Init(1, &temp);
+  cmd->Init(1, &temp);
   EXPECT_EQ(error::kNoError,
-            ExecuteImmediateCmd(cmd, sizeof(temp)));
+            ExecuteImmediateCmd(*cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_TRUE(GetTextureInfo(kNewClientId) != NULL);
 }
 
 TEST_F(GLES2DecoderTest1, GenTexturesImmediateInvalidArgs) {
   EXPECT_CALL(*gl_, GenTextures(_, _)).Times(0);
-  GenTexturesImmediate& cmd = *GetImmediateAs<GenTexturesImmediate>();
+  GenTexturesImmediate* cmd = GetImmediateAs<GenTexturesImmediate>();
   SpecializedSetup<GenTexturesImmediate, 0>(false);
-  cmd.Init(1, &client_texture_id_);
+  cmd->Init(1, &client_texture_id_);
   EXPECT_EQ(error::kInvalidArguments,
-            ExecuteImmediateCmd(cmd, sizeof(&client_texture_id_)));
+            ExecuteImmediateCmd(*cmd, sizeof(&client_texture_id_)));
 }
 // TODO(gman): GetActiveAttrib