Change command buffer client code to use structures.

I didn't update the big_test although I'm happy to
do that in another CL. 

I changed the CB renderer code to use this. The only
place I didn't is the state handling code. I'll
consider changing that in another CL.

I changed DoCommand so it gets passed the entire
command data including the command itself where
as it used to get passed the command buffer entry
after the command. I wanted to put the commands
into the structures as I think it makes them easier
to use since they can then correctly set their header.
I could have left DoCommand as is but there would
have been a lot of funky pointer math and I thought
this change made it cleaner.

Some questions I had while doing this.

There are a few places in the code that use 
unsigned int instead of uint32. It seems
we should use uint32 because unsigned int
is not guarnteed to be 32bits. So for example
ResourceID is unsigned int right now.

The CMD::Set/CMD::Init/CommandBufferHelper commands
are currently fairly untyped. For example 
DESTROY_TEXTURE takes a uint32 id. Should it take
a ResourceID instead? DRAW should maybe take an
enum for primitive_type? If we decide to do that
I'd like to do it in another CL.

There's no checking for overflow. We could add
a bunch of DCHECK like DCHECK_LE(width, 65536) 
or DCHECK_LE(semantic_index, 16). I'd like to
do those in another CL as well as I think we
need to discuss what commands we want to change.

All the code is in .h files because we want all
of this code to inline. Theoretically this should
be just as efficient as poking values into arrays
in the opt builds.

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

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

44 files changed, 4607 insertions, 1914 deletions

diff --git a/o3d/command_buffer/client/cross/big_test_client.cc b/o3d/command_buffer/client/cross/big_test_client.cc
index cf42ee5..568b81f 100644
--- a/o3d/command_buffer/client/cross/big_test_client.cc
+++ b/o3d/command_buffer/client/cross/big_test_client.cc
@@ -47,30 +47,6 @@ namespace command_buffer {
 
 namespace math = Vectormath::Aos;
 
-// Adds a Clear command into the command buffer.
-// Parameters:
-//   cmd_buffer: the command buffer helper.
-//   buffers: a bitfield of which buffers to clear (a combination of
-//     GAPIInterface::COLOR, GAPIInterface::DEPTH and GAPIInterface::STENCIL).
-//   color: the color buffer clear value.
-//   depth: the depth buffer clear value.
-//   stencil: the stencil buffer clear value.
-void ClearCmd(CommandBufferHelper *cmd_buffer,
-              const unsigned int buffers,
-              const RGBA &color,
-              float depth,
-              unsigned int stencil) {
-  CommandBufferEntry args[7];
-  args[0].value_uint32 = buffers;
-  args[1].value_float = color.red;
-  args[2].value_float = color.green;
-  args[3].value_float = color.blue;
-  args[4].value_float = color.alpha;
-  args[5].value_float = depth;
-  args[6].value_uint32 = stencil;
-  cmd_buffer->AddCommand(command_buffer::CLEAR, 7, args);
-}
-
 // Adds a SetViewport command into the buffer.
 // Parameters:
 //   cmd_buffer: the command buffer helper.
@@ -83,14 +59,7 @@ void SetViewportCmd(CommandBufferHelper *cmd_buffer,
                     unsigned int height,
                     float z_near,
                     float z_far) {
-  CommandBufferEntry args[6];
-  args[0].value_uint32 = x;
-  args[1].value_uint32 = y;
-  args[2].value_uint32 = width;
-  args[3].value_uint32 = height;
-  args[4].value_float = z_near;
-  args[5].value_float = z_far;
-  cmd_buffer->AddCommand(command_buffer::SET_VIEWPORT, 6, args);
+  cmd_buffer->SetViewport(x, y, width, height, z_near, z_far);
 }
 
 // Copy a data buffer to args, for IMMEDIATE commands. Returns the number of
@@ -143,88 +112,51 @@ void BigTestClient(nacl::HtpHandle handle) {
 
     // Clear the buffers.
     RGBA color = {0.2f, 0.2f, 0.2f, 1.f};
-    ClearCmd(&cmd_buffer, GAPIInterface::COLOR | GAPIInterface::DEPTH, color,
-             1.f, 0);
+    cmd_buffer.Clear(GAPIInterface::COLOR | GAPIInterface::DEPTH,
+                     color.red, color.green, color.blue, color.alpha,
+                     1.f, 0);
 
     const ResourceID vertex_buffer_id = 1;
     const ResourceID vertex_struct_id = 1;
 
-    // AddCommand copies the args, so it is safe to re-use args across various
-    // calls.
-    // 20 is the largest command we use (SET_PARAM_DATA_IMMEDIATE for matrices).
-    CommandBufferEntry args[20];
-
-    CustomVertex vertices[4] = {
+    static const CustomVertex vertices[4] = {
       {-.5f, -.5f, 0.f, 1.f,  0, 0},
       {.5f,  -.5f, 0.f, 1.f,  1, 0},
       {-.5f,  .5f, 0.f, 1.f,  0, 1},
       {.5f,   .5f, 0.f, 1.f,  1, 1},
     };
-    args[0].value_uint32 = vertex_buffer_id;
-    args[1].value_uint32 = sizeof(vertices);  // size
-    args[2].value_uint32 = 0;  // flags
-    cmd_buffer.AddCommand(command_buffer::CREATE_VERTEX_BUFFER, 3, args);
+    cmd_buffer.CreateVertexBuffer(vertex_buffer_id, sizeof(vertices), 0);
 
     memcpy(shm_address, vertices, sizeof(vertices));
-    args[0].value_uint32 = vertex_buffer_id;
-    args[1].value_uint32 = 0;  // offset in VB
-    args[2].value_uint32 = sizeof(vertices);  // size
-    args[3].value_uint32 = shm_id;  // shm
-    args[4].value_uint32 = 0;  // offset in shm
-    cmd_buffer.AddCommand(command_buffer::SET_VERTEX_BUFFER_DATA, 5, args);
+    cmd_buffer.SetVertexBufferData(
+        vertex_buffer_id, 0, sizeof(vertices), shm_id, 0);
     unsigned int token = cmd_buffer.InsertToken();
 
-    args[0].value_uint32 = vertex_struct_id;
-    args[1].value_uint32 = 2;  // input count
-    cmd_buffer.AddCommand(command_buffer::CREATE_VERTEX_STRUCT, 2, args);
+    cmd_buffer.CreateVertexStruct(vertex_struct_id, 2);
 
     // Set POSITION input stream
-    args[0].value_uint32 = vertex_struct_id;
-    args[1].value_uint32 = 0;                               // input
-    args[2].value_uint32 = vertex_buffer_id;                // buffer
-    args[3].value_uint32 = 0;                               // offset
-    args[4].value_uint32 =
-        set_vertex_input_cmd::Stride::MakeValue(sizeof(CustomVertex)) |
-        set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT4) |
-        set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::POSITION) |
-        set_vertex_input_cmd::SemanticIndex::MakeValue(0);
-    cmd_buffer.AddCommand(command_buffer::SET_VERTEX_INPUT, 5, args);
+    cmd_buffer.SetVertexInput(vertex_struct_id, 0, vertex_buffer_id, 0,
+                              vertex_struct::POSITION, 0,
+                              vertex_struct::FLOAT4, sizeof(CustomVertex));
 
     // Set TEXCOORD0 input stream
-    args[1].value_uint32 = 1;                               // input
-    args[3].value_uint32 = 16;                              // offset
-    args[4].value_uint32 =
-        set_vertex_input_cmd::Stride::MakeValue(sizeof(CustomVertex)) |
-        set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT2) |
-        set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::TEX_COORD) |
-        set_vertex_input_cmd::SemanticIndex::MakeValue(0);
-    cmd_buffer.AddCommand(command_buffer::SET_VERTEX_INPUT, 5, args);
+    cmd_buffer.SetVertexInput(vertex_struct_id, 1, vertex_buffer_id, 16,
+                              vertex_struct::TEX_COORD, 0,
+                              vertex_struct::FLOAT2, sizeof(CustomVertex));
 
     // wait for previous transfer to be executed, so that we can re-use the
     // transfer shared memory buffer.
     cmd_buffer.WaitForToken(token);
     memcpy(shm_address, effect_data, sizeof(effect_data));
     const ResourceID effect_id = 1;
-    args[0].value_uint32 = effect_id;
-    args[1].value_uint32 = sizeof(effect_data);  // size
-    args[2].value_uint32 = shm_id;  // shm
-    args[3].value_uint32 = 0;  // offset in shm
-    cmd_buffer.AddCommand(command_buffer::CREATE_EFFECT, 4, args);
+    cmd_buffer.CreateEffect(effect_id, sizeof(effect_data), shm_id, 0);
     token = cmd_buffer.InsertToken();
 
     // Create a 4x4 2D texture.
     const ResourceID texture_id = 1;
-    args[0].value_uint32 = texture_id;
-    args[1].value_uint32 =
-        create_texture_2d_cmd::Width::MakeValue(4) |
-        create_texture_2d_cmd::Height::MakeValue(4);
-    args[2].value_uint32 =
-        create_texture_2d_cmd::Levels::MakeValue(0) |
-        create_texture_2d_cmd::Format::MakeValue(texture::ARGB8) |
-        create_texture_2d_cmd::Flags::MakeValue(0);
-    cmd_buffer.AddCommand(command_buffer::CREATE_TEXTURE_2D, 3, args);
-
-    unsigned int texels[4] = {
+    cmd_buffer.CreateTexture2d(texture_id, 4, 4, 1, texture::ARGB8, 0);
+
+    static const unsigned int texels[4] = {
       0xff0000ff,
       0xffff00ff,
       0xff00ffff,
@@ -237,68 +169,40 @@ void BigTestClient(nacl::HtpHandle handle) {
     // Creates a 4x4 texture by uploading 2x2 data in each quadrant.
     for (unsigned int x = 0; x < 2; ++x)
       for (unsigned int y = 0; y < 2; ++y) {
-        args[0].value_uint32 = texture_id;
-        args[1].value_uint32 =
-            set_texture_data_cmd::X::MakeValue(x*2) |
-            set_texture_data_cmd::Y::MakeValue(y*2);
-        args[2].value_uint32 =
-            set_texture_data_cmd::Width::MakeValue(2) |
-            set_texture_data_cmd::Height::MakeValue(2);
-        args[3].value_uint32 =
-            set_texture_data_cmd::Z::MakeValue(0) |
-            set_texture_data_cmd::Depth::MakeValue(1);
-        args[4].value_uint32 = set_texture_data_cmd::Level::MakeValue(0);
-        args[5].value_uint32 = sizeof(texels[0]) * 2;  // row_pitch
-        args[6].value_uint32 = 0;  // slice_pitch
-        args[7].value_uint32 = sizeof(texels);  // size
-        args[8].value_uint32 = shm_id;
-        args[9].value_uint32 = 0;
-        cmd_buffer.AddCommand(command_buffer::SET_TEXTURE_DATA, 10, args);
+        cmd_buffer.SetTextureData(texture_id, x * 2, y * 2, 0, 2, 2, 1, 0, 0,
+                                  sizeof(texels[0]) * 2,  // row_pitch
+                                  0,  // slice_pitch
+                                  sizeof(texels),  // size
+                                  shm_id,
+                                  0);
       }
     token = cmd_buffer.InsertToken();
 
     const ResourceID sampler_id = 1;
-    args[0].value_uint32 = sampler_id;
-    cmd_buffer.AddCommand(command_buffer::CREATE_SAMPLER, 1, args);
-
-    args[0].value_uint32 = sampler_id;
-    args[1].value_uint32 = texture_id;
-    cmd_buffer.AddCommand(command_buffer::SET_SAMPLER_TEXTURE, 2, args);
-
-    args[0].value_uint32 = sampler_id;
-    args[1].value_uint32 =
-        set_sampler_states::AddressingU::MakeValue(sampler::CLAMP_TO_EDGE) |
-        set_sampler_states::AddressingV::MakeValue(sampler::CLAMP_TO_EDGE) |
-        set_sampler_states::AddressingW::MakeValue(sampler::CLAMP_TO_EDGE) |
-        set_sampler_states::MagFilter::MakeValue(sampler::POINT) |
-        set_sampler_states::MinFilter::MakeValue(sampler::POINT) |
-        set_sampler_states::MipFilter::MakeValue(sampler::NONE) |
-        set_sampler_states::MaxAnisotropy::MakeValue(1);
-    cmd_buffer.AddCommand(command_buffer::SET_SAMPLER_STATES, 2, args);
+    cmd_buffer.CreateSampler(sampler_id);
+    cmd_buffer.SetSamplerTexture(sampler_id, texture_id);
+    cmd_buffer.SetSamplerStates(sampler_id,
+                                sampler::CLAMP_TO_EDGE,
+                                sampler::CLAMP_TO_EDGE,
+                                sampler::CLAMP_TO_EDGE,
+                                sampler::POINT,
+                                sampler::POINT,
+                                sampler::NONE,
+                                1);
 
     // Create a parameter for the sampler.
     const ResourceID sampler_param_id = 1;
     {
-      const char param_name[] = "s0";
-      args[0].value_uint32 = sampler_param_id;
-      args[1].value_uint32 = effect_id;
-      args[2].value_uint32 = sizeof(param_name);
-      unsigned int arg_count = CopyToArgs(args + 3, param_name,
-                                          sizeof(param_name));
-      cmd_buffer.AddCommand(command_buffer::CREATE_PARAM_BY_NAME_IMMEDIATE,
-                            3 + arg_count, args);
+      static const char param_name[] = "s0";
+      cmd_buffer.CreateParamByNameImmediate(sampler_param_id, effect_id,
+                                            sizeof(param_name), param_name);
     }
 
     const ResourceID matrix_param_id = 2;
     {
-      const char param_name[] = "worldViewProj";
-      args[0].value_uint32 = matrix_param_id;
-      args[1].value_uint32 = effect_id;
-      args[2].value_uint32 = sizeof(param_name);
-      unsigned int arg_count = CopyToArgs(args + 3, param_name,
-                                          sizeof(param_name));
-      cmd_buffer.AddCommand(command_buffer::CREATE_PARAM_BY_NAME_IMMEDIATE,
-                            3 + arg_count, args);
+      static const char param_name[] = "worldViewProj";
+      cmd_buffer.CreateParamByNameImmediate(matrix_param_id, effect_id,
+                                            sizeof(param_name), param_name);
     }
 
     float t = 0.f;
@@ -307,34 +211,21 @@ void BigTestClient(nacl::HtpHandle handle) {
       math::Matrix4 m =
           math::Matrix4::translation(math::Vector3(0.f, 0.f, .5f));
       m *= math::Matrix4::rotationY(t * 2 * 3.1415926f);
-      cmd_buffer.AddCommand(command_buffer::BEGIN_FRAME, 0 , NULL);
+      cmd_buffer.BeginFrame();
       // Clear the background with an animated color (black to red).
-      ClearCmd(&cmd_buffer, GAPIInterface::COLOR | GAPIInterface::DEPTH, color,
-               1.f, 0);
-
-      args[0].value_uint32 = vertex_struct_id;
-      cmd_buffer.AddCommand(command_buffer::SET_VERTEX_STRUCT, 1, args);
-
-      args[0].value_uint32 = effect_id;
-      cmd_buffer.AddCommand(command_buffer::SET_EFFECT, 1, args);
-
-      args[0].value_uint32 = sampler_param_id;
-      args[1].value_uint32 = sizeof(Uint32);  // NOLINT
-      args[2].value_uint32 = sampler_id;
-      cmd_buffer.AddCommand(command_buffer::SET_PARAM_DATA_IMMEDIATE, 3, args);
-
-      args[0].value_uint32 = matrix_param_id;
-      args[1].value_uint32 = sizeof(m);
-      unsigned int arg_count = CopyToArgs(args + 2, &m, sizeof(m));
-      cmd_buffer.AddCommand(command_buffer::SET_PARAM_DATA_IMMEDIATE,
-                            2 + arg_count, args);
-
-      args[0].value_uint32 = GAPIInterface::TRIANGLE_STRIPS;
-      args[1].value_uint32 = 0;  // first
-      args[2].value_uint32 = 2;  // primitive count
-      cmd_buffer.AddCommand(command_buffer::DRAW, 3, args);
-
-      cmd_buffer.AddCommand(command_buffer::END_FRAME, 0 , NULL);
+      cmd_buffer.Clear(GAPIInterface::COLOR | GAPIInterface::DEPTH,
+                       color.red, color.green, color.blue, color.alpha,
+                       1.f, 0);
+
+      cmd_buffer.SetVertexStruct(vertex_struct_id);
+      cmd_buffer.SetEffect(effect_id);
+      cmd_buffer.SetParamDataImmediate(
+          sampler_param_id, sizeof(uint32), &sampler_id);  // NOLINT
+      cmd_buffer.SetParamDataImmediate(
+          matrix_param_id, sizeof(m), &m);
+      cmd_buffer.Draw(GAPIInterface::TRIANGLE_STRIPS, 0, 2);
+
+      cmd_buffer.EndFrame();
       cmd_buffer.Flush();
     }
 
diff --git a/o3d/command_buffer/client/cross/buffer_sync_proxy_test.cc b/o3d/command_buffer/client/cross/buffer_sync_proxy_test.cc
index 790a693..f19c6bf 100644
--- a/o3d/command_buffer/client/cross/buffer_sync_proxy_test.cc
+++ b/o3d/command_buffer/client/cross/buffer_sync_proxy_test.cc
@@ -229,7 +229,7 @@ TEST_F(BufferSyncProxyTest, TestSignalGetChanges) {
 // message and returns the correct value.
 TEST_F(BufferSyncProxyTest, TestGetStatus) {
   RPCSendInterfaceMock::SendCallExpect expect;
-  expect._return = BufferSyncInterface::PARSING;
+  expect._return = BufferSyncInterface::kParsing;
   expect.message_id = BufferRPCImpl::GET_STATUS;
   expect.data = NULL;
   expect.size = 0;
@@ -237,14 +237,14 @@ TEST_F(BufferSyncProxyTest, TestGetStatus) {
   expect.handle_count = 0;
   server_mock()->AddSendCallExpect(expect);
 
-  EXPECT_EQ(BufferSyncInterface::PARSING, proxy()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParsing, proxy()->GetStatus());
 }
 
 // Tests the implementation of GetParseError, checking that it sends the correct
 // message and returns the correct value.
 TEST_F(BufferSyncProxyTest, TestGetParseError) {
   RPCSendInterfaceMock::SendCallExpect expect;
-  expect._return = BufferSyncInterface::PARSE_UNKNOWN_COMMAND;
+  expect._return = BufferSyncInterface::kParseUnknownCommand;
   expect.message_id = BufferRPCImpl::GET_PARSE_ERROR;
   expect.data = NULL;
   expect.size = 0;
@@ -252,7 +252,7 @@ TEST_F(BufferSyncProxyTest, TestGetParseError) {
   expect.handle_count = 0;
   server_mock()->AddSendCallExpect(expect);
 
-  EXPECT_EQ(BufferSyncInterface::PARSE_UNKNOWN_COMMAND,
+  EXPECT_EQ(BufferSyncInterface::kParseUnknownCommand,
             proxy()->GetParseError());
 }
 
diff --git a/o3d/command_buffer/client/cross/cmd_buffer_helper.cc b/o3d/command_buffer/client/cross/cmd_buffer_helper.cc
index f844576..209f297 100644
--- a/o3d/command_buffer/client/cross/cmd_buffer_helper.cc
+++ b/o3d/command_buffer/client/cross/cmd_buffer_helper.cc
@@ -43,7 +43,7 @@ CommandBufferHelper::CommandBufferHelper(BufferSyncInterface *interface)
       entry_count_(0),
       token_(0) {
   // The interface should be connected already.
-  DCHECK_NE(BufferSyncInterface::NOT_CONNECTED, interface_->GetStatus());
+  DCHECK_NE(BufferSyncInterface::kNotConnected, interface_->GetStatus());
 }
 
 bool CommandBufferHelper::Init(unsigned int entry_count) {
@@ -94,7 +94,7 @@ unsigned int CommandBufferHelper::InsertToken() {
   ++token_;
   CommandBufferEntry args;
   args.value_uint32 = token_;
-  AddCommand(SET_TOKEN, 1, &args);
+  AddCommand(command_buffer::kSetToken, 1, &args);
   if (token_ == 0) {
     // we wrapped
     Finish();
@@ -129,20 +129,20 @@ void CommandBufferHelper::WaitForGetChange() {
     // If get_ didn't change or is invalid (-1), it means an error may have
     // occured. Check that.
     BufferSyncInterface::ParserStatus status = interface_->GetStatus();
-    if (status != BufferSyncInterface::PARSING) {
+    if (status != BufferSyncInterface::kParsing) {
       switch (status) {
-        case BufferSyncInterface::NOT_CONNECTED:
+        case BufferSyncInterface::kNotConnected:
           LOG(FATAL) << "Service disconnected.";
           return;
-        case BufferSyncInterface::NO_BUFFER:
+        case BufferSyncInterface::kNoBuffer:
           LOG(FATAL) << "Service doesn't have a buffer set.";
           return;
-        case BufferSyncInterface::PARSE_ERROR: {
+        case BufferSyncInterface::kParseError: {
           BufferSyncInterface::ParseError error = interface_->GetParseError();
           LOG(WARNING) << "Parse error: " << error;
           return;
         }
-        case BufferSyncInterface::PARSING:
+        case BufferSyncInterface::kParsing:
           break;
       }
     }
@@ -181,5 +181,12 @@ void CommandBufferHelper::WaitForAvailableEntries(unsigned int count) {
   while (AvailableEntries() < count) WaitForGetChange();
 }
 
+CommandBufferEntry* CommandBufferHelper::GetSpace(uint32 entries) {
+  WaitForAvailableEntries(entries);
+  CommandBufferEntry* space = &entries_[put_];
+  put_ += entries;
+  return space;
+}
+
 }  // namespace command_buffer
 }  // namespace o3d
diff --git a/o3d/command_buffer/client/cross/cmd_buffer_helper.h b/o3d/command_buffer/client/cross/cmd_buffer_helper.h
index 775835b..8e13555 100644
--- a/o3d/command_buffer/client/cross/cmd_buffer_helper.h
+++ b/o3d/command_buffer/client/cross/cmd_buffer_helper.h
@@ -90,6 +90,27 @@ class CommandBufferHelper {
   //     the size of the buffer minus one.
   void WaitForAvailableEntries(unsigned int count);
 
+  // Adds a command data to the command buffer. This may wait until sufficient
+  // space is available.
+  // Parameters:
+  //   entries: The command entries to add.
+  //   count: The number of entries.
+  void AddCommandData(const CommandBufferEntry* entries, unsigned int count) {
+    WaitForAvailableEntries(count);
+    for (; count > 0; --count) {
+      entries_[put_++] = *entries++;
+    }
+    DCHECK_LE(put_, entry_count_);
+    if (put_ == entry_count_) put_ = 0;
+  }
+
+  // A typed version of AddCommandData.
+  template <typename T>
+  void AddTypedCmdData(const T& cmd) {
+    AddCommandData(reinterpret_cast<const CommandBufferEntry*>(&cmd),
+                   ComputeNumEntries(sizeof(cmd)));
+  }
+
   // Adds a command to the command buffer. This may wait until sufficient space
   // is available.
   // Parameters:
@@ -99,7 +120,7 @@ class CommandBufferHelper {
   //     function returns).
   void AddCommand(unsigned int command,
                   unsigned int arg_count,
-                  CommandBufferEntry *args) {
+                  const CommandBufferEntry *args) {
     CommandHeader header;
     header.size = arg_count + 1;
     header.command = command;
@@ -130,13 +151,612 @@ class CommandBufferHelper {
   // Returns the buffer interface used to send synchronous commands.
   BufferSyncInterface *interface() { return interface_; }
 
+  // Waits for a certain amount of space to be available. Returns address
+  // of space.
+  CommandBufferEntry* GetSpace(uint32 entries);
+
+  // Typed version of GetSpace. Gets enough room for the given type and returns
+  // a reference to it.
+  template <typename T>
+  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);
+  }
+
+  // Typed version of GetSpace for immediate commands.
+  template <typename T>
+  T& GetImmediateCmdSpace(size_t space) {
+    COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN);
+    uint32 space_needed = ComputeNumEntries(sizeof(T) + space);
+    void* data = GetSpace(space_needed);
+    return *reinterpret_cast<T*>(data);
+  }
+
+  // ------------------ Individual commands ----------------------
+
+  void Noop(uint32 skip_count) {
+    cmd::Noop& cmd = GetImmediateCmdSpace<cmd::Noop>(
+        skip_count * sizeof(CommandBufferEntry));
+    cmd.Init(skip_count);
+  }
+
+
+  void SetToken(uint32 token) {
+    cmd::SetToken& cmd = GetCmdSpace<cmd::SetToken>();
+    cmd.Init(token);
+  }
+
+
+  void BeginFrame() {
+    cmd::BeginFrame& cmd = GetCmdSpace<cmd::BeginFrame>();
+    cmd.Init();
+  }
+
+
+  void EndFrame() {
+    cmd::EndFrame& cmd = GetCmdSpace<cmd::EndFrame>();
+    cmd.Init();
+  }
+
+  void Clear(
+      uint32 buffers,
+      float red, float green, float blue, float alpha,
+      float depth, uint32 stencil) {
+    cmd::Clear& cmd = GetCmdSpace<cmd::Clear>();
+    cmd.Init(buffers, red, green, blue, alpha, depth, stencil);
+  }
+
+  void SetViewport(
+      uint32 left,
+      uint32 top,
+      uint32 width,
+      uint32 height,
+      float z_min,
+      float z_max) {
+    cmd::SetViewport& cmd = GetCmdSpace<cmd::SetViewport>();
+    cmd.Init(left, top, width, height, z_min, z_max);
+  }
+
+  void CreateVertexBuffer(uint32 id, uint32 size, uint32 flags) {
+    cmd::CreateVertexBuffer& cmd = GetCmdSpace<cmd::CreateVertexBuffer>();
+    cmd.Init(id, size, flags);
+  }
+
+  void DestroyVertexBuffer(uint32 id) {
+    cmd::DestroyVertexBuffer& cmd = GetCmdSpace<cmd::DestroyVertexBuffer>();
+    cmd.Init(id);
+  }
+
+  void SetVertexBufferDataImmediate(
+      uint32 id, uint32 offset,
+      const void* data, uint32 size) {
+    cmd::SetVertexBufferDataImmediate& cmd =
+        GetImmediateCmdSpace<cmd::SetVertexBufferDataImmediate>(size);
+    cmd.Init(id, offset, data, size);
+  }
+
+  void SetVertexBufferData(
+      uint32 id, uint32 offset, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::SetVertexBufferData& cmd =
+        GetCmdSpace<cmd::SetVertexBufferData>();
+    cmd.Init(id, offset, size,
+             shared_memory_id, shared_memory_offset);
+  }
+
+  void GetVertexBufferData(
+      uint32 id, uint32 offset, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::GetVertexBufferData& cmd =
+        GetCmdSpace<cmd::GetVertexBufferData>();
+    cmd.Init(id, offset, size,
+             shared_memory_id, shared_memory_offset);
+  }
+
+  void CreateIndexBuffer(uint32 id, uint32 size, uint32 flags) {
+    cmd::CreateIndexBuffer& cmd =
+        GetCmdSpace<cmd::CreateIndexBuffer>();
+    cmd.Init(id, size, flags);
+  }
+
+  void DestroyIndexBuffer(uint32 id) {
+    cmd::DestroyIndexBuffer& cmd = GetCmdSpace<cmd::DestroyIndexBuffer>();
+    cmd.Init(id);
+  }
+
+  void SetIndexBufferDataImmediate(
+      uint32 id, uint32 offset, const void* data, uint32 size) {
+    cmd::SetIndexBufferDataImmediate& cmd =
+        GetImmediateCmdSpace<cmd::SetIndexBufferDataImmediate>(size);
+    cmd.Init(id, offset, data, size);
+  }
+
+  void SetIndexBufferData(
+      uint32 id, uint32 offset, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::SetIndexBufferData& cmd = GetCmdSpace<cmd::SetIndexBufferData>();
+    cmd.Init(id, offset, size, shared_memory_id, shared_memory_offset);
+  }
+
+  void GetIndexBufferData(
+      uint32 id, uint32 offset, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::GetIndexBufferData& cmd = GetCmdSpace<cmd::GetIndexBufferData>();
+    cmd.Init(id, offset, size, shared_memory_id, shared_memory_offset);
+  }
+
+  void CreateVertexStruct(uint32 id, uint32 input_count) {
+    cmd::CreateVertexStruct& cmd = GetCmdSpace<cmd::CreateVertexStruct>();
+    cmd.Init(id, input_count);
+  }
+
+  void DestroyVertexStruct(uint32 id) {
+    cmd::DestroyVertexStruct& cmd = GetCmdSpace<cmd::DestroyVertexStruct>();
+    cmd.Init(id);
+  }
+
+  void SetVertexInput(
+      uint32 vertex_struct_id,
+      uint32 input_index,
+      uint32 vertex_buffer_id,
+      uint32 offset,
+      uint8 semantic,
+      uint32 semantic_index,
+      uint8 type,
+      uint32 stride) {
+    cmd::SetVertexInput& cmd = GetCmdSpace<cmd::SetVertexInput>();
+    cmd.Init(
+        vertex_struct_id,
+        input_index,
+        vertex_buffer_id,
+        offset,
+        semantic,
+        semantic_index,
+        type,
+        stride);
+  }
+
+  void SetVertexStruct(uint32 id) {
+    cmd::SetVertexStruct& cmd = GetCmdSpace<cmd::SetVertexStruct>();
+    cmd.Init(id);
+  }
+
+  void Draw(uint32 primitive_type, uint32 first, uint32 count) {
+    cmd::Draw& cmd = GetCmdSpace<cmd::Draw>();
+    cmd.Init(primitive_type, first, count);
+  }
+
+  void DrawIndexed(
+      uint32 primitive_type,
+      uint32 index_buffer_id,
+      uint32 first,
+      uint32 count,
+      uint32 min_index,
+      uint32 max_index) {
+    cmd::DrawIndexed& cmd = GetCmdSpace<cmd::DrawIndexed>();
+    cmd.Init(
+        primitive_type,
+        index_buffer_id,
+        first,
+        count,
+        min_index,
+        max_index);
+  }
+
+  void CreateEffect(
+      uint32 id, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::CreateEffect& cmd = GetCmdSpace<cmd::CreateEffect>();
+    cmd.Init(id, size, shared_memory_id, shared_memory_offset);
+  }
+
+  void CreateEffectImmediate(uint32 id, uint32 size, const void* data) {
+    cmd::CreateEffectImmediate& cmd =
+        GetImmediateCmdSpace<cmd::CreateEffectImmediate>(size);
+    cmd.Init(id, size, data);
+  }
+
+  void DestroyEffect(uint32 id) {
+    cmd::DestroyEffect& cmd = GetCmdSpace<cmd::DestroyEffect>();
+    cmd.Init(id);
+  }
+
+  void SetEffect(uint32 id) {
+    cmd::SetEffect& cmd = GetCmdSpace<cmd::SetEffect>();
+    cmd.Init(id);
+  }
+
+  void GetParamCount(
+      uint32 id, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::GetParamCount& cmd = GetCmdSpace<cmd::GetParamCount>();
+    cmd.Init(id, size, shared_memory_id, shared_memory_offset);
+  }
+
+  void CreateParam(uint32 param_id, uint32 effect_id, uint32 index) {
+    cmd::CreateParam& cmd = GetCmdSpace<cmd::CreateParam>();
+    cmd.Init(param_id, effect_id, index);
+  }
+
+  void CreateParamByName(
+      uint32 param_id, uint32 effect_id, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::CreateParamByName& cmd = GetCmdSpace<cmd::CreateParamByName>();
+    cmd.Init(param_id, effect_id, size, shared_memory_id, shared_memory_offset);
+  }
+
+  void CreateParamByNameImmediate(
+      uint32 param_id, uint32 effect_id, uint32 size, const void* data) {
+    cmd::CreateParamByNameImmediate& cmd =
+        GetImmediateCmdSpace<cmd::CreateParamByNameImmediate>(size);
+    cmd.Init(param_id, effect_id, size, data);
+  }
+
+  void DestroyParam(uint32 id) {
+    cmd::DestroyParam& cmd = GetCmdSpace<cmd::DestroyParam>();
+    cmd.Init(id);
+  }
+
+  void SetParamData(
+      uint32 id, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::SetParamData& cmd = GetCmdSpace<cmd::SetParamData>();
+    cmd.Init(id, size, shared_memory_id, shared_memory_offset);
+  }
+
+  void SetParamDataImmediate(uint32 id, uint32 size, const void* data) {
+    cmd::SetParamDataImmediate& cmd =
+        GetImmediateCmdSpace<cmd::SetParamDataImmediate>(size);
+    cmd.Init(id, size, data);
+  }
+
+  void GetParamDesc(
+      uint32 id, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::GetParamDesc& cmd = GetCmdSpace<cmd::GetParamDesc>();
+    cmd.Init(id, size, shared_memory_id, shared_memory_offset);
+  }
+
+  void GetStreamCount(
+      uint32 id, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::GetStreamCount& cmd = GetCmdSpace<cmd::GetStreamCount>();
+    cmd.Init(id, size, shared_memory_id, shared_memory_offset);
+  }
+
+  void GetStreamDesc(
+      uint32 id, uint32 index, uint32 size,
+      uint32 shared_memory_id, uint32 shared_memory_offset) {
+    cmd::GetStreamDesc& cmd = GetCmdSpace<cmd::GetStreamDesc>();
+    cmd.Init(id, index, size, shared_memory_id, shared_memory_offset);
+  }
+
+  void DestroyTexture(uint32 id) {
+    cmd::DestroyTexture& cmd = GetCmdSpace<cmd::DestroyTexture>();
+    cmd.Init(id);
+  }
+
+  void CreateTexture2d(
+      uint32 texture_id,
+      uint32 width, uint32 height,
+      uint32 levels, uint32 format,
+      uint32 enable_render_surfaces) {
+    cmd::CreateTexture2d& cmd = GetCmdSpace<cmd::CreateTexture2d>();
+    cmd.Init(texture_id,
+             width, height, levels, format,
+             enable_render_surfaces);
+  }
+
+  void CreateTexture3d(
+      uint32 texture_id,
+      uint32 width, uint32 height, uint32 depth,
+      uint32 levels, uint32 format,
+      uint32 enable_render_surfaces) {
+    cmd::CreateTexture3d& cmd = GetCmdSpace<cmd::CreateTexture3d>();
+    cmd.Init(texture_id,
+             width, height, depth,
+             levels, format,
+             enable_render_surfaces);
+  }
+
+  void CreateTextureCube(
+      uint32 texture_id,
+      uint32 edge_length, uint32 levels, uint32 format,
+      uint32 enable_render_surfaces) {
+    cmd::CreateTextureCube& cmd = GetCmdSpace<cmd::CreateTextureCube>();
+    cmd.Init(texture_id,
+             edge_length, levels, format,
+             enable_render_surfaces);
+  }
+
+  void SetTextureData(
+      uint32 texture_id,
+      uint32 x,
+      uint32 y,
+      uint32 z,
+      uint32 width,
+      uint32 height,
+      uint32 depth,
+      uint32 level,
+      uint32 face,
+      uint32 row_pitch,
+      uint32 slice_pitch,
+      uint32 size,
+      uint32 shared_memory_id,
+      uint32 shared_memory_offset) {
+    cmd::SetTextureData& cmd = GetCmdSpace<cmd::SetTextureData>();
+    cmd.Init(
+        texture_id,
+        x,
+        y,
+        z,
+        width,
+        height,
+        depth,
+        level,
+        face,
+        row_pitch,
+        slice_pitch,
+        size,
+        shared_memory_id,
+        shared_memory_offset);
+  }
+
+  void SetTextureDataImmediate(
+      uint32 texture_id,
+      uint32 x,
+      uint32 y,
+      uint32 z,
+      uint32 width,
+      uint32 height,
+      uint32 depth,
+      uint32 level,
+      uint32 face,
+      uint32 row_pitch,
+      uint32 slice_pitch,
+      uint32 size,
+      const void* data) {
+    cmd::SetTextureDataImmediate& cmd =
+        GetImmediateCmdSpace<cmd::SetTextureDataImmediate>(size);
+    cmd.Init(
+        texture_id,
+        x,
+        y,
+        z,
+        width,
+        height,
+        depth,
+        level,
+        face,
+        row_pitch,
+        slice_pitch,
+        size,
+        data);
+  }
+
+  void GetTextureData(
+      uint32 texture_id,
+      uint32 x,
+      uint32 y,
+      uint32 z,
+      uint32 width,
+      uint32 height,
+      uint32 depth,
+      uint32 level,
+      uint32 face,
+      uint32 row_pitch,
+      uint32 slice_pitch,
+      uint32 size,
+      uint32 shared_memory_id,
+      uint32 shared_memory_offset) {
+    cmd::GetTextureData& cmd = GetCmdSpace<cmd::GetTextureData>();
+    cmd.Init(
+        texture_id,
+        x,
+        y,
+        z,
+        width,
+        height,
+        depth,
+        level,
+        face,
+        row_pitch,
+        slice_pitch,
+        size,
+        shared_memory_id,
+        shared_memory_offset);
+  }
+
+  void CreateSampler(uint32 id) {
+    cmd::CreateSampler& cmd = GetCmdSpace<cmd::CreateSampler>();
+    cmd.Init(id);
+  }
+
+  void DestroySampler(uint32 id) {
+    cmd::DestroySampler& cmd = GetCmdSpace<cmd::DestroySampler>();
+    cmd.Init(id);
+  }
+
+  void SetSamplerStates(uint32 id,
+      uint32 address_u_value,
+      uint32 address_v_value,
+      uint32 address_w_value,
+      uint32 mag_filter_value,
+      uint32 min_filter_value,
+      uint32 mip_filter_value,
+      uint32 max_anisotropy) {
+    cmd::SetSamplerStates& cmd = GetCmdSpace<cmd::SetSamplerStates>();
+    cmd.Init(
+        id,
+        address_u_value,
+        address_v_value,
+        address_w_value,
+        mag_filter_value,
+        min_filter_value,
+        mip_filter_value,
+        max_anisotropy);
+  }
+
+  void SetSamplerBorderColor(
+      uint32 id,
+      float red, float green, float blue, float alpha) {
+    cmd::SetSamplerBorderColor& cmd =
+        GetCmdSpace<cmd::SetSamplerBorderColor>();
+    cmd.Init(id, red, green, blue, alpha);
+  }
+
+  void SetSamplerTexture(uint32 id, uint32 texture_id) {
+    cmd::SetSamplerTexture& cmd = GetCmdSpace<cmd::SetSamplerTexture>();
+    cmd.Init(id, texture_id);
+  }
+
+  void SetScissor(
+      uint32 x,
+      uint32 y,
+      uint32 width,
+      uint32 height,
+      bool enable) {
+    cmd::SetScissor& cmd = GetCmdSpace<cmd::SetScissor>();
+    cmd.Init(
+        x,
+        y,
+        width,
+        height,
+        enable);
+  }
+
+  void SetPolygonOffset(float slope_factor, float units) {
+    cmd::SetPolygonOffset& cmd = GetCmdSpace<cmd::SetPolygonOffset>();
+    cmd.Init(slope_factor, units);
+  }
+
+  void SetPointLineRaster(
+      bool line_smooth_enable, bool point_sprite_enable, float point_size) {
+    cmd::SetPointLineRaster& cmd = GetCmdSpace<cmd::SetPointLineRaster>();
+    cmd.Init(line_smooth_enable, point_sprite_enable, point_size);
+  }
+
+  void SetPolygonRaster(uint32 fill_mode, uint32 cull_mode) {
+    cmd::SetPolygonRaster& cmd = GetCmdSpace<cmd::SetPolygonRaster>();
+    cmd.Init(fill_mode, cull_mode);
+  }
+
+  void SetAlphaTest(uint32 func, bool enable, float value) {
+    cmd::SetAlphaTest& cmd = GetCmdSpace<cmd::SetAlphaTest>();
+    cmd.Init(func, enable, value);
+  }
+
+  void SetDepthTest(uint32 func, bool write_enable, bool enable) {
+    cmd::SetDepthTest& cmd = GetCmdSpace<cmd::SetDepthTest>();
+    cmd.Init(func, write_enable, enable);
+  }
+
+  void SetStencilTest(
+      uint8 write_mask,
+      uint8 compare_mask,
+      uint8 reference_value,
+      bool separate_ccw,
+      bool enable,
+      uint8 cw_func,
+      uint8 cw_pass_op,
+      uint8 cw_fail_op,
+      uint8 cw_z_fail_op,
+      uint8 ccw_func,
+      uint8 ccw_pass_op,
+      uint8 ccw_fail_op,
+      uint8 ccw_z_fail_op) {
+    cmd::SetStencilTest& cmd = GetCmdSpace<cmd::SetStencilTest>();
+    cmd.Init(
+        write_mask,
+        compare_mask,
+        reference_value,
+        separate_ccw,
+        enable,
+        cw_func,
+        cw_pass_op,
+        cw_fail_op,
+        cw_z_fail_op,
+        ccw_func,
+        ccw_pass_op,
+        ccw_fail_op,
+        ccw_z_fail_op);
+  }
+
+  void SetColorWrite(uint8 mask, bool dither_enable) {
+    cmd::SetColorWrite& cmd = GetCmdSpace<cmd::SetColorWrite>();
+    cmd.Init(mask, dither_enable);
+  }
+
+  void SetBlending(
+      uint8 color_src_func,
+      uint8 color_dst_func,
+      uint8 color_eq,
+      uint8 alpha_src_func,
+      uint8 alpha_dst_func,
+      uint8 alpha_eq,
+      bool separate_alpha,
+      bool enable) {
+    cmd::SetBlending& cmd = GetCmdSpace<cmd::SetBlending>();
+    cmd.Init(
+        color_src_func,
+        color_dst_func,
+        color_eq,
+        alpha_src_func,
+        alpha_dst_func,
+        alpha_eq,
+        separate_alpha,
+        enable);
+  }
+
+  void SetBlendingColor(float red, float green, float blue, float alpha) {
+    cmd::SetBlendingColor& cmd = GetCmdSpace<cmd::SetBlendingColor>();
+    cmd.Init(red, green, blue, alpha);
+  }
+
+  void CreateRenderSurface(
+      uint32 id, uint32 texture_id,
+      uint32 width, uint32 height,
+      uint32 level, uint32 side) {
+    cmd::CreateRenderSurface& cmd = GetCmdSpace<cmd::CreateRenderSurface>();
+    cmd.Init(id, texture_id, width, height, level, side);
+  }
+
+  void DestroyRenderSurface(uint32 id) {
+    cmd::DestroyRenderSurface& cmd =
+        GetCmdSpace<cmd::DestroyRenderSurface>();
+    cmd.Init(id);
+  }
+
+  void CreateDepthSurface(uint32 id, uint32 width, uint32 height) {
+    cmd::CreateDepthSurface& cmd = GetCmdSpace<cmd::CreateDepthSurface>();
+    cmd.Init(id, width, height);
+  }
+
+  void DestroyDepthSurface(uint32 id) {
+    cmd::DestroyDepthSurface& cmd = GetCmdSpace<cmd::DestroyDepthSurface>();
+    cmd.Init(id);
+  }
+
+  void SetRenderSurface(uint32 render_surface_id, uint32 depth_surface_id) {
+    cmd::SetRenderSurface& cmd = GetCmdSpace<cmd::SetRenderSurface>();
+    cmd.Init(render_surface_id, depth_surface_id);
+  }
+
+  void SetBackSurfaces() {
+    cmd::SetBackSurfaces& cmd = GetCmdSpace<cmd::SetBackSurfaces>();
+    cmd.Init();
+  }
+
  private:
   // Waits until get changes, updating the value of get_.
   void WaitForGetChange();
 
   // Returns the number of available entries (they may not be contiguous).
   unsigned int AvailableEntries() {
-    return (get_ - put_ - 1 + entry_count_) % entry_count_;
+    return static_cast<unsigned int>(
+        (get_ - put_ - 1 + entry_count_) % entry_count_);
   }
 
   BufferSyncInterface *interface_;
diff --git a/o3d/command_buffer/client/cross/cmd_buffer_helper_test.cc b/o3d/command_buffer/client/cross/cmd_buffer_helper_test.cc
index e25bcd9..8bb4104 100644
--- a/o3d/command_buffer/client/cross/cmd_buffer_helper_test.cc
+++ b/o3d/command_buffer/client/cross/cmd_buffer_helper_test.cc
@@ -58,7 +58,7 @@ class CommandBufferHelperTest : public testing::Test {
     // ignore noops in the mock - we don't want to inspect the internals of the
     // helper.
     EXPECT_CALL(*api_mock_, DoCommand(0, 0, _))
-        .WillRepeatedly(Return(BufferSyncInterface::PARSE_NO_ERROR));
+        .WillRepeatedly(Return(BufferSyncInterface::kParseNoError));
     engine_.reset(new CommandBufferEngine(api_mock_.get()));
     api_mock_->set_engine(engine_.get());
 
@@ -126,22 +126,22 @@ TEST_F(CommandBufferHelperTest, TestCommandProcessing) {
   // helper.
   EXPECT_TRUE(engine()->rpc_impl() != NULL);
   EXPECT_TRUE(engine()->parser() != NULL);
-  EXPECT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   EXPECT_EQ(0, engine()->Get());
 
   // Add 3 commands through the helper
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 1, 0, NULL);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 1, 0, NULL);
 
   CommandBufferEntry args1[2];
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 2, 2, args1);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 2, 2, args1);
 
   CommandBufferEntry args2[2];
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 2, args2);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 3, 2, args2);
 
   helper()->Flush();
   // Check that the engine has work to do now.
@@ -156,8 +156,8 @@ TEST_F(CommandBufferHelperTest, TestCommandProcessing) {
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check the error status.
-  ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 }
 
 // Checks that commands in the buffer are properly executed when wrapping the
@@ -169,7 +169,7 @@ TEST_F(CommandBufferHelperTest, TestCommandWrapping) {
   args1[1].value_float = 4.f;
 
   for (unsigned int i = 0; i < 5; ++i) {
-    AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, i+1, 2, args1);
+    AddCommandWithExpect(BufferSyncInterface::kParseNoError, i+1, 2, args1);
   }
 
   helper()->Finish();
@@ -177,8 +177,8 @@ TEST_F(CommandBufferHelperTest, TestCommandWrapping) {
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check the error status.
-  ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 }
 
 
@@ -191,9 +191,9 @@ TEST_F(CommandBufferHelperTest, TestRecoverableError) {
   args[1].value_float = 4.f;
 
   // Create a command buffer with 3 commands, 2 of them generating errors
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 1, 2, args);
-  AddCommandWithExpect(BufferSyncInterface::PARSE_UNKNOWN_COMMAND, 2, 2, args);
-  AddCommandWithExpect(BufferSyncInterface::PARSE_INVALID_ARGUMENTS, 3, 2,
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 1, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseUnknownCommand, 2, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseInvalidArguments, 3, 2,
                        args);
 
   helper()->Finish();
@@ -201,10 +201,10 @@ TEST_F(CommandBufferHelperTest, TestRecoverableError) {
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check that the error status was set to the first error.
-  EXPECT_EQ(BufferSyncInterface::PARSE_UNKNOWN_COMMAND,
+  EXPECT_EQ(BufferSyncInterface::kParseUnknownCommand,
             engine()->GetParseError());
   // Check that the error status was reset after the query.
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 
   engine()->CloseConnection();
 }
@@ -217,10 +217,10 @@ TEST_F(CommandBufferHelperTest, TestAvailableEntries) {
   args[1].value_float = 4.f;
 
   // Add 2 commands through the helper - 8 entries
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 1, 0, NULL);
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 2, 0, NULL);
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 2, args);
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 4, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 1, 0, NULL);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 2, 0, NULL);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 3, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 4, 2, args);
 
   // Ask for 5 entries.
   helper()->WaitForAvailableEntries(5);
@@ -229,7 +229,7 @@ TEST_F(CommandBufferHelperTest, TestAvailableEntries) {
   CheckFreeSpace(put, 5);
 
   // Add more commands.
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 5, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 5, 2, args);
 
   // Wait until everything is done done.
   helper()->Finish();
@@ -238,8 +238,8 @@ TEST_F(CommandBufferHelperTest, TestAvailableEntries) {
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check the error status.
-  ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 }
 
 // Checks that the InsertToken/WaitForToken work.
@@ -249,16 +249,16 @@ TEST_F(CommandBufferHelperTest, TestToken) {
   args[1].value_float = 4.f;
 
   // Add a first command.
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 3, 2, args);
   // keep track of the buffer position.
   CommandBufferOffset command1_put = get_helper_put();
   unsigned int token = helper()->InsertToken();
 
-  EXPECT_CALL(*api_mock(), DoCommand(SET_TOKEN, 1, _))
+  EXPECT_CALL(*api_mock(), DoCommand(kSetToken, 1, _))
       .WillOnce(DoAll(Invoke(api_mock(), &AsyncAPIMock::SetToken),
-                      Return(BufferSyncInterface::PARSE_NO_ERROR)));
+                      Return(BufferSyncInterface::kParseNoError)));
   // Add another command.
-  AddCommandWithExpect(BufferSyncInterface::PARSE_NO_ERROR, 4, 2, args);
+  AddCommandWithExpect(BufferSyncInterface::kParseNoError, 4, 2, args);
   helper()->WaitForToken(token);
   // check that the get pointer is beyond the first command.
   EXPECT_LE(command1_put, engine()->Get());
@@ -268,8 +268,8 @@ TEST_F(CommandBufferHelperTest, TestToken) {
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check the error status.
-  ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 }
 
 }  // namespace command_buffer
diff --git a/o3d/command_buffer/client/cross/effect_helper.cc b/o3d/command_buffer/client/cross/effect_helper.cc
index ced1b3b..b9254cc 100644
--- a/o3d/command_buffer/client/cross/effect_helper.cc
+++ b/o3d/command_buffer/client/cross/effect_helper.cc
@@ -52,18 +52,14 @@ bool EffectHelper::CreateEffectParameters(ResourceID effect_id,
 
   // Get the param count.
   Uint32 *retval = shm_allocator_->AllocTyped<Uint32>(1);
-  CommandBufferEntry args[4];
-  args[0].value_uint32 = effect_id;
-  args[1].value_uint32 = sizeof(*retval);
-  args[2].value_uint32 = shm_id_;
-  args[3].value_uint32 = shm_allocator_->GetOffset(retval);
-  helper_->AddCommand(GET_PARAM_COUNT, 4, args);
+  helper_->GetParamCount(effect_id, sizeof(*retval),
+                         shm_id_, shm_allocator_->GetOffset(retval));
   // Finish has to be called to get the result.
   helper_->Finish();
 
   // We could have failed if the effect_id is invalid.
   if (helper_->interface()->GetParseError() !=
-      BufferSyncInterface::PARSE_NO_ERROR) {
+      BufferSyncInterface::kParseNoError) {
     shm_allocator_->Free(retval);
     return false;
   }
@@ -79,10 +75,7 @@ bool EffectHelper::CreateEffectParameters(ResourceID effect_id,
   for (unsigned int i = 0; i < param_count; ++i) {
     EffectParamDesc *desc = &((*descs)[i]);
     desc->id = param_id_allocator_->AllocateID();
-    args[0].value_uint32 = desc->id;
-    args[1].value_uint32 = effect_id;
-    args[2].value_uint32 = i;
-    helper_->AddCommand(CREATE_PARAM, 3, args);
+    helper_->CreateParam(desc->id, effect_id, i);
   }
 
   // Read param descriptions in batches. We use as much shared memory as
@@ -97,16 +90,14 @@ bool EffectHelper::CreateEffectParameters(ResourceID effect_id,
     for (unsigned int j = 0 ; j < count; ++j) {
       EffectParamDesc *desc = &((*descs)[i + j]);
       Desc *raw_desc = raw_descs + j;
-      args[0].value_uint32 = desc->id;
-      args[1].value_uint32 = sizeof(*raw_desc);
-      args[2].value_uint32 = shm_id_;
-      args[3].value_uint32 = shm_allocator_->GetOffset(raw_desc);
-      helper_->AddCommand(GET_PARAM_DESC, 4, args);
+      helper_->GetParamDesc(desc->id, sizeof(*raw_desc),
+                            shm_id_,
+                            shm_allocator_->GetOffset(raw_desc));
     }
     // Finish to get the results.
     helper_->Finish();
     DCHECK_EQ(helper_->interface()->GetParseError(),
-              BufferSyncInterface::PARSE_NO_ERROR);
+              BufferSyncInterface::kParseNoError);
     for (unsigned int j = 0 ; j < count; ++j) {
       EffectParamDesc *desc = &((*descs)[i + j]);
       Desc *raw_desc = raw_descs + j;
@@ -133,18 +124,16 @@ bool EffectHelper::GetParamStrings(EffectParamDesc *desc) {
     // Not enough memory to get the param desc.
     return false;
   }
-  CommandBufferEntry args[4];
-  args[0].value_uint32 = desc->id;
-  args[1].value_uint32 = size;
-  args[2].value_uint32 = shm_id_;
-  args[3].value_uint32 = shm_allocator_->GetOffset(raw_desc);
-  helper_->AddCommand(GET_PARAM_DESC, 4, args);
+  helper_->GetParamDesc(desc->id, size,
+                        shm_id_,
+                        shm_allocator_->GetOffset(raw_desc));
+
   // Finish to get the results.
   helper_->Finish();
 
   // We could have failed if the param ID is invalid.
   if (helper_->interface()->GetParseError() !=
-      BufferSyncInterface::PARSE_NO_ERROR) {
+      BufferSyncInterface::kParseNoError) {
     shm_allocator_->Free(raw_desc);
     return false;
   }
@@ -162,13 +151,13 @@ bool EffectHelper::GetParamStrings(EffectParamDesc *desc) {
       // Not enough memory to get the param desc.
       return false;
     }
-    args[1].value_uint32 = size;
-    args[3].value_uint32 = shm_allocator_->GetOffset(raw_desc);
-    helper_->AddCommand(GET_PARAM_DESC, 4, args);
+    helper_->GetParamDesc(desc->id, size,
+                          shm_id_,
+                          shm_allocator_->GetOffset(raw_desc));
     // Finish to get the results.
     helper_->Finish();
     DCHECK_EQ(helper_->interface()->GetParseError(),
-              BufferSyncInterface::PARSE_NO_ERROR);
+              BufferSyncInterface::kParseNoError);
     DCHECK_EQ(raw_desc->size, size);
   }
 
@@ -201,11 +190,9 @@ bool EffectHelper::GetParamStrings(EffectParamDesc *desc) {
 
 void EffectHelper::DestroyEffectParameters(
     const std::vector<EffectParamDesc> &descs) {
-  CommandBufferEntry args[1];
   for (unsigned int i = 0; i < descs.size(); ++i) {
     const EffectParamDesc &desc = descs[i];
-    args[0].value_uint32 = desc.id;
-    helper_->AddCommand(DESTROY_PARAM, 1, args);
+    helper_->DestroyParam(desc.id);
     param_id_allocator_->FreeID(desc.id);
   }
 }
@@ -217,18 +204,15 @@ bool EffectHelper::GetEffectStreams(ResourceID effect_id,
 
   // Get the param count.
   Uint32 *retval = shm_allocator_->AllocTyped<Uint32>(1);
-  CommandBufferEntry args[5];
-  args[0].value_uint32 = effect_id;
-  args[1].value_uint32 = sizeof(*retval);
-  args[2].value_uint32 = shm_id_;
-  args[3].value_uint32 = shm_allocator_->GetOffset(retval);
-  helper_->AddCommand(GET_STREAM_COUNT, 4, args);
+  helper_->GetStreamCount(effect_id, sizeof(*retval),
+                          shm_id_,
+                          shm_allocator_->GetOffset(retval));
   // Finish has to be called to get the result.
   helper_->Finish();
 
   // We could have failed if the effect_id is invalid.
   if (helper_->interface()->GetParseError() !=
-      BufferSyncInterface::PARSE_NO_ERROR) {
+      BufferSyncInterface::kParseNoError) {
     shm_allocator_->Free(retval);
     return false;
   }
@@ -253,17 +237,14 @@ bool EffectHelper::GetEffectStreams(ResourceID effect_id,
     for (unsigned int j = 0 ; j < count; ++j) {
       EffectStreamDesc *desc = &((*descs)[i + j]);
       Desc *raw_desc = raw_descs + j;
-      args[0].value_uint32 = effect_id;
-      args[1].value_uint32 = i+j;
-      args[2].value_uint32 = sizeof(*raw_desc);
-      args[3].value_uint32 = shm_id_;
-      args[4].value_uint32 = shm_allocator_->GetOffset(raw_desc);
-      helper_->AddCommand(GET_STREAM_DESC, 5, args);
+      helper_->GetStreamDesc(effect_id, i + j, sizeof(*raw_desc),
+                             shm_id_,
+                             shm_allocator_->GetOffset(raw_desc));
     }
     // Finish to get the results.
     helper_->Finish();
     DCHECK_EQ(helper_->interface()->GetParseError(),
-              BufferSyncInterface::PARSE_NO_ERROR);
+              BufferSyncInterface::kParseNoError);
     for (unsigned int j = 0 ; j < count; ++j) {
       EffectStreamDesc *desc = &((*descs)[i + j]);
       Desc *raw_desc = raw_descs + j;
diff --git a/o3d/command_buffer/client/cross/fenced_allocator_test.cc b/o3d/command_buffer/client/cross/fenced_allocator_test.cc
index 93dedca..9d63cc0 100644
--- a/o3d/command_buffer/client/cross/fenced_allocator_test.cc
+++ b/o3d/command_buffer/client/cross/fenced_allocator_test.cc
@@ -50,8 +50,8 @@ using testing::_;
 
 // Test fixture for FencedAllocator test - Creates a FencedAllocator, using a
 // CommandBufferHelper with a mock AsyncAPIInterface for its interface (calling
-// it directly, not through the RPC mechanism), making sure NOOPs are ignored
-// and SET_TOKEN are properly forwarded to the engine.
+// it directly, not through the RPC mechanism), making sure Noops are ignored
+// and SetToken are properly forwarded to the engine.
 class FencedAllocatorTest : public testing::Test {
  public:
   static const unsigned int kBufferSize = 1024;
@@ -61,12 +61,12 @@ class FencedAllocatorTest : public testing::Test {
     api_mock_.reset(new AsyncAPIMock);
     // ignore noops in the mock - we don't want to inspect the internals of the
     // helper.
-    EXPECT_CALL(*api_mock_, DoCommand(NOOP, 0, _))
-        .WillRepeatedly(Return(BufferSyncInterface::PARSE_NO_ERROR));
+    EXPECT_CALL(*api_mock_, DoCommand(kNoop, 0, _))
+        .WillRepeatedly(Return(BufferSyncInterface::kParseNoError));
     // Forward the SetToken calls to the engine
-    EXPECT_CALL(*api_mock(), DoCommand(SET_TOKEN, 1, _))
+    EXPECT_CALL(*api_mock(), DoCommand(kSetToken, 1, _))
         .WillRepeatedly(DoAll(Invoke(api_mock(), &AsyncAPIMock::SetToken),
-                              Return(BufferSyncInterface::PARSE_NO_ERROR)));
+                              Return(BufferSyncInterface::kParseNoError)));
     engine_.reset(new CommandBufferEngine(api_mock_.get()));
     api_mock_->set_engine(engine_.get());
 
@@ -312,7 +312,7 @@ TEST_F(FencedAllocatorTest, TestGetLargestFreeOrPendingSize) {
 // Test fixture for FencedAllocatorWrapper test - Creates a
 // FencedAllocatorWrapper, using a CommandBufferHelper with a mock
 // AsyncAPIInterface for its interface (calling it directly, not through the
-// RPC mechanism), making sure NOOPs are ignored and SET_TOKEN are properly
+// RPC mechanism), making sure Noops are ignored and SetToken are properly
 // forwarded to the engine.
 class FencedAllocatorWrapperTest : public testing::Test {
  public:
@@ -323,12 +323,12 @@ class FencedAllocatorWrapperTest : public testing::Test {
     api_mock_.reset(new AsyncAPIMock);
     // ignore noops in the mock - we don't want to inspect the internals of the
     // helper.
-    EXPECT_CALL(*api_mock_, DoCommand(NOOP, 0, _))
-        .WillRepeatedly(Return(BufferSyncInterface::PARSE_NO_ERROR));
+    EXPECT_CALL(*api_mock_, DoCommand(kNoop, 0, _))
+        .WillRepeatedly(Return(BufferSyncInterface::kParseNoError));
     // Forward the SetToken calls to the engine
-    EXPECT_CALL(*api_mock(), DoCommand(SET_TOKEN, 1, _))
+    EXPECT_CALL(*api_mock(), DoCommand(kSetToken, 1, _))
         .WillRepeatedly(DoAll(Invoke(api_mock(), &AsyncAPIMock::SetToken),
-                              Return(BufferSyncInterface::PARSE_NO_ERROR)));
+                              Return(BufferSyncInterface::kParseNoError)));
     engine_.reset(new CommandBufferEngine(api_mock_.get()));
     api_mock_->set_engine(engine_.get());
 
diff --git a/o3d/command_buffer/common/cross/buffer_sync_api.h b/o3d/command_buffer/common/cross/buffer_sync_api.h
index 62d6011..e216e7a 100644
--- a/o3d/command_buffer/common/cross/buffer_sync_api.h
+++ b/o3d/command_buffer/common/cross/buffer_sync_api.h
@@ -49,21 +49,21 @@ typedef size_t CommandBufferOffset;
 class BufferSyncInterface {
  public:
   // Status of the command buffer service. It does not process commands
-  // (meaning: get will not change) unless in PARSING state.
+  // (meaning: get will not change) unless in kParsing state.
   enum ParserStatus {
-    NOT_CONNECTED,  // The service is not connected - initial state.
-    NO_BUFFER,      // The service is connected but no buffer was set.
-    PARSING,        // The service is connected, and parsing commands from the
+    kNotConnected,  // The service is not connected - initial state.
+    kNoBuffer,      // The service is connected but no buffer was set.
+    kParsing,       // The service is connected, and parsing commands from the
                     // buffer.
-    PARSE_ERROR,    // Parsing stopped because a parse error was found.
+    kParseError,    // Parsing stopped because a parse error was found.
   };
 
   enum ParseError {
-    PARSE_NO_ERROR,
-    PARSE_INVALID_SIZE,
-    PARSE_OUT_OF_BOUNDS,
-    PARSE_UNKNOWN_COMMAND,
-    PARSE_INVALID_ARGUMENTS,
+    kParseNoError,
+    kParseInvalidSize,
+    kParseOutOfBounds,
+    kParseUnknownCommand,
+    kParseInvalidArguments,
   };
 
   // Invalid shared memory Id, returned by RegisterSharedMemory in case of
@@ -155,8 +155,8 @@ class BufferSyncInterface {
 
   // Gets the current parse error. The current parse error is set when the
   // service is in the PARSE_ERROR status. It may also be set while in the
-  // PARSING state, if a recoverable error (like PARSE_UNKNOWN_METHOD) was
-  // encountered. Getting the error resets it to PARSE_NO_ERROR.
+  // kParsing state, if a recoverable error (like PARSE_UNKNOWN_METHOD) was
+  // encountered. Getting the error resets it to kParseNoError.
   // Returns:
   //   The current parse error.
   virtual ParseError GetParseError() = 0;
diff --git a/o3d/command_buffer/common/cross/cmd_buffer_format.h b/o3d/command_buffer/common/cross/cmd_buffer_format.h
index 51d0e9b..63bcc8be 100644
--- a/o3d/command_buffer/common/cross/cmd_buffer_format.h
+++ b/o3d/command_buffer/common/cross/cmd_buffer_format.h
@@ -30,7 +30,31 @@
  */
 
 
-// This file contains the binary format definition of the command buffer.
+// This file contains the binary format definition of the command buffer and
+// command buffer commands.
+// It is recommended you use the CommandBufferHelper object to create commands
+// but if you want to go lower level you can use the structures here to help.
+//
+// A few ways to use them:
+//
+// Fill out a structure in place:
+//
+// cmd::SetViewport::Set(ptrToSomeSharedMemory,
+//                       left, right, width, height, z_min, z_max);
+//
+// Fill out consecutive commands:
+//
+// Note that each cmd::XXX::Set function returns a pointer to the place
+// the next command should go.
+//
+// void* dest = ptrToSomeSharedMemory;
+// dest = cmd::SetViewport::Set(dest, left, right, width, height, min, max);
+// dest = cmd::Clear::Set(dest, buffers, r, g, b, a, depth, stencil);
+// dest = cmd::Draw::Set(dest, primitive_type, first, count);
+//
+// NOTE: The types in this file must be POD types. That means they can not have
+// constructors, destructors, virtual functions or inheritance and they can only
+// use other POD types or intrinsics as members.
 
 #ifndef O3D_COMMAND_BUFFER_COMMON_CROSS_CMD_BUFFER_FORMAT_H_
 #define O3D_COMMAND_BUFFER_COMMON_CROSS_CMD_BUFFER_FORMAT_H_
@@ -43,11 +67,44 @@
 namespace o3d {
 namespace command_buffer {
 
+// Computes the number of command buffer entries needed for a certain size. In
+// other words it rounds up to a multiple of entries.
+inline uint32 ComputeNumEntries(size_t size_in_bytes) {
+  return static_cast<uint32>(
+      (size_in_bytes + sizeof(uint32) - 1) / sizeof(uint32));  // NOLINT
+}
+
+// Rounds up to a multiple of entries in bytes.
+inline size_t RoundSizeToMultipleOfEntries(size_t size_in_bytes) {
+  return ComputeNumEntries(size_in_bytes) * sizeof(uint32);  // NOLINT
+}
+
 // Struct that defines the command header in the command buffer.
 struct CommandHeader {
   Uint32 size:8;
   Uint32 command:24;
+
+  void Init(uint32 _command, uint32 _size) {
+    command = _command;
+    size = _size;
+  }
+
+  // Sets the header based on the passed in command. Can not be used for
+  // variable sized commands like immediate commands or Noop.
+  template <typename T>
+  void SetCmd() {
+    COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed);
+    Init(T::kCmdId, ComputeNumEntries(sizeof(T)));  // NOLINT
+  }
+
+  // Sets the header by a size in bytes.
+  template <typename T>
+  void SetCmdBySize(uint32 size_in_bytes) {
+    COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN);
+    Init(T::kCmdId, ComputeNumEntries(sizeof(T) + size_in_bytes));  // NOLINT
+  }
 };
+
 COMPILE_ASSERT(sizeof(CommandHeader) == 4, Sizeof_CommandHeader_is_not_4);
 
 // Union that defines possible command buffer entries.
@@ -61,16 +118,17 @@ union CommandBufferEntry {
 COMPILE_ASSERT(sizeof(CommandBufferEntry) == 4,
                Sizeof_CommandBufferEntry_is_not_4);
 
-// Bitfields for the SET_VERTEX_INPUT command.
+// Bitfields for the SetVertexInput command.
 namespace set_vertex_input_cmd {
 // argument 4
-typedef BitField<0, 4> SemanticIndex;
+typedef BitField<0, 4> SemanticIndex;  // TODO(gman): shouldn't this be bigger
+                                       // than 4 bits for future expansion?
 typedef BitField<4, 4> Semantic;
 typedef BitField<8, 8> Type;
 typedef BitField<16, 16> Stride;
 }  // namespace set_vertex_input_cmd
 
-// Bitfields for the CREATE_TEXTURE_2D command.
+// Bitfields for the CreateTexture2d command.
 namespace create_texture_2d_cmd {
 // argument 1
 typedef BitField<0, 16> Width;
@@ -82,7 +140,7 @@ typedef BitField<8, 8> Format;
 typedef BitField<16, 16> Flags;
 }  // namespace create_texture_2d_cmd
 
-// Bitfields for the CREATE_TEXTURE_3D command.
+// Bitfields for the CreateTexture3d command.
 namespace create_texture_3d_cmd {
 // argument 1
 typedef BitField<0, 16> Width;
@@ -97,7 +155,7 @@ typedef BitField<8, 8> Format;
 typedef BitField<16, 16> Flags;
 }  // namespace create_texture_3d_cmd
 
-// Bitfields for the CREATE_TEXTURE_CUBE command.
+// Bitfields for the CreateTextureCube command.
 namespace create_texture_cube_cmd {
 // argument 1
 typedef BitField<0, 16> Side;
@@ -109,7 +167,7 @@ typedef BitField<8, 8> Format;
 typedef BitField<16, 16> Flags;
 }  // namespace create_texture_cube_cmd
 
-// Bitfields for the CREATE_RENDER_SURFACE command.
+// Bitfields for the CreateRenderSurface command.
 namespace create_render_surface_cmd {
 // argument 1
 typedef BitField<0, 16> Width;
@@ -119,7 +177,14 @@ typedef BitField<0, 16> Levels;
 typedef BitField<16, 16> Side;
 }  // namespace create_render_surface_cmd
 
-// Bitfields for the SET_TEXTURE_DATA command.
+// Bitfields for the CreateDepthSurface command.
+namespace create_depth_surface_cmd {
+// argument 1
+typedef BitField<0, 16> Width;
+typedef BitField<16, 16> Height;
+}  // namespace create_depth_surface_cmd
+
+// Bitfields for the SetTextureData command.
 namespace set_texture_data_cmd {
 // argument 1
 typedef BitField<0, 16> X;
@@ -136,7 +201,7 @@ typedef BitField<4, 3> Face;
 typedef BitField<7, 25> Unused;
 }  // namespace set_texture_data_cmd
 
-// Bitfields for the SET_TEXTURE_DATA_IMMEDIATE command.
+// Bitfields for the SetTextureDataImmediate command.
 namespace set_texture_data_immediate_cmd {
 // argument 1
 typedef BitField<0, 16> X;
@@ -153,7 +218,7 @@ typedef BitField<4, 3> Face;
 typedef BitField<7, 25> Unused;
 }  // namespace set_texture_data_immediate_cmd
 
-// Bitfields for the GET_TEXTURE_DATA command.
+// Bitfields for the GetTextureData command.
 namespace get_texture_data_cmd {
 // argument 1
 typedef BitField<0, 16> X;
@@ -170,7 +235,7 @@ typedef BitField<4, 3> Face;
 typedef BitField<7, 25> Unused;
 }  // namespace get_texture_data_cmd
 
-// Bitfields for the SET_SAMPLER_STATES command.
+// Bitfields for the SetSamplerStates command.
 namespace set_sampler_states {
 // argument 2
 typedef BitField<0, 3> AddressingU;
@@ -278,75 +343,75 @@ typedef BitField<31, 1> Enable;
 //
 // NOTE: THE ORDER OF THESE MUST NOT CHANGE (their id is derived by order)
 #define O3D_COMMAND_BUFFER_CMDS \
-  O3D_COMMAND_BUFFER_CMD_OP(NOOP)                              /*  0 */ \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_TOKEN)                                  \
-  O3D_COMMAND_BUFFER_CMD_OP(BEGIN_FRAME)                                \
-  O3D_COMMAND_BUFFER_CMD_OP(END_FRAME)                                  \
-  O3D_COMMAND_BUFFER_CMD_OP(CLEAR)                                      \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_VERTEX_BUFFER)                       \
-  O3D_COMMAND_BUFFER_CMD_OP(DESTROY_VERTEX_BUFFER)                      \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_VERTEX_BUFFER_DATA)                     \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_VERTEX_BUFFER_DATA_IMMEDIATE)           \
-  O3D_COMMAND_BUFFER_CMD_OP(GET_VERTEX_BUFFER_DATA)                     \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_INDEX_BUFFER)               /* 10 */ \
-  O3D_COMMAND_BUFFER_CMD_OP(DESTROY_INDEX_BUFFER)                       \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_INDEX_BUFFER_DATA)                      \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_INDEX_BUFFER_DATA_IMMEDIATE)            \
-  O3D_COMMAND_BUFFER_CMD_OP(GET_INDEX_BUFFER_DATA)                      \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_VERTEX_STRUCT)                       \
-  O3D_COMMAND_BUFFER_CMD_OP(DESTROY_VERTEX_STRUCT)                      \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_VERTEX_INPUT)                           \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_VERTEX_STRUCT)                          \
-  O3D_COMMAND_BUFFER_CMD_OP(DRAW)                                       \
-  O3D_COMMAND_BUFFER_CMD_OP(DRAW_INDEXED)                      /* 20 */ \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_EFFECT)                              \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_EFFECT_IMMEDIATE)                    \
-  O3D_COMMAND_BUFFER_CMD_OP(DESTROY_EFFECT)                             \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_EFFECT)                                 \
-  O3D_COMMAND_BUFFER_CMD_OP(GET_PARAM_COUNT)                            \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_PARAM)                               \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_PARAM_BY_NAME)                       \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_PARAM_BY_NAME_IMMEDIATE)             \
-  O3D_COMMAND_BUFFER_CMD_OP(DESTROY_PARAM)                              \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_PARAM_DATA)                    /* 30 */ \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_PARAM_DATA_IMMEDIATE)                   \
-  O3D_COMMAND_BUFFER_CMD_OP(GET_PARAM_DESC)                             \
-  O3D_COMMAND_BUFFER_CMD_OP(GET_STREAM_COUNT)                           \
-  O3D_COMMAND_BUFFER_CMD_OP(GET_STREAM_DESC)                            \
-  O3D_COMMAND_BUFFER_CMD_OP(DESTROY_TEXTURE)                            \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_TEXTURE_2D)                          \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_TEXTURE_3D)                          \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_TEXTURE_CUBE)                        \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_TEXTURE_DATA)                           \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_TEXTURE_DATA_IMMEDIATE)        /* 40 */ \
-  O3D_COMMAND_BUFFER_CMD_OP(GET_TEXTURE_DATA)                           \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_SAMPLER)                             \
-  O3D_COMMAND_BUFFER_CMD_OP(DESTROY_SAMPLER)                            \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_SAMPLER_STATES)                         \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_SAMPLER_BORDER_COLOR)                   \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_SAMPLER_TEXTURE)                        \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_VIEWPORT)                               \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_SCISSOR)                                \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_POINT_LINE_RASTER)                      \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_POLYGON_RASTER)                /* 50 */ \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_POLYGON_OFFSET)                         \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_ALPHA_TEST)                             \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_DEPTH_TEST)                             \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_STENCIL_TEST)                           \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_BLENDING)                               \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_BLENDING_COLOR)                         \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_COLOR_WRITE)                            \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_RENDER_SURFACE)                      \
-  O3D_COMMAND_BUFFER_CMD_OP(DESTROY_RENDER_SURFACE)                     \
-  O3D_COMMAND_BUFFER_CMD_OP(CREATE_DEPTH_SURFACE)              /* 60 */ \
-  O3D_COMMAND_BUFFER_CMD_OP(DESTROY_DEPTH_SURFACE)                      \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_RENDER_SURFACE)                         \
-  O3D_COMMAND_BUFFER_CMD_OP(SET_BACK_SURFACES)                          \
+  O3D_COMMAND_BUFFER_CMD_OP(Noop)                          /*  0 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetToken)                      /*  1 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(BeginFrame)                    /*  2 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(EndFrame)                      /*  3 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(Clear)                         /*  4 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateVertexBuffer)            /*  5 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(DestroyVertexBuffer)           /*  6 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetVertexBufferData)           /*  7 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetVertexBufferDataImmediate)  /*  8 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(GetVertexBufferData)           /*  9 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateIndexBuffer)             /* 10 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(DestroyIndexBuffer)            /* 11 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetIndexBufferData)            /* 12 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetIndexBufferDataImmediate)   /* 13 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(GetIndexBufferData)            /* 14 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateVertexStruct)            /* 15 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(DestroyVertexStruct)           /* 16 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetVertexInput)                /* 17 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetVertexStruct)               /* 18 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(Draw)                          /* 19 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(DrawIndexed)                   /* 20 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateEffect)                  /* 21 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateEffectImmediate)         /* 22 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(DestroyEffect)                 /* 23 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetEffect)                     /* 24 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(GetParamCount)                 /* 25 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateParam)                   /* 26 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateParamByName)             /* 27 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateParamByNameImmediate)    /* 28 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(DestroyParam)                  /* 29 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetParamData)                  /* 30 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetParamDataImmediate)         /* 31 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(GetParamDesc)                  /* 32 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(GetStreamCount)                /* 33 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(GetStreamDesc)                 /* 34 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(DestroyTexture)                /* 35 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateTexture2d)               /* 36 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateTexture3d)               /* 37 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateTextureCube)             /* 38 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetTextureData)                /* 39 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetTextureDataImmediate)       /* 40 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(GetTextureData)                /* 41 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateSampler)                 /* 42 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(DestroySampler)                /* 43 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetSamplerStates)              /* 44 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetSamplerBorderColor)         /* 45 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetSamplerTexture)             /* 46 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetViewport)                   /* 47 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetScissor)                    /* 48 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetPointLineRaster)            /* 49 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetPolygonRaster)              /* 50 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetPolygonOffset)              /* 51 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetAlphaTest)                  /* 52 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetDepthTest)                  /* 53 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetStencilTest)                /* 54 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetBlending)                   /* 55 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetBlendingColor)              /* 56 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetColorWrite)                 /* 57 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateRenderSurface)           /* 58 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(DestroyRenderSurface)          /* 59 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(CreateDepthSurface)            /* 60 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(DestroyDepthSurface)           /* 61 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetRenderSurface)              /* 62 */ \
+  O3D_COMMAND_BUFFER_CMD_OP(SetBackSurfaces)               /* 63 */ \
 
 
 // GAPI commands.
 enum CommandId {
-  #define O3D_COMMAND_BUFFER_CMD_OP(name) name,
+  #define O3D_COMMAND_BUFFER_CMD_OP(name) k ## name,
 
   O3D_COMMAND_BUFFER_CMDS
 
@@ -359,40 +424,191 @@ namespace cmd {
 // structures.
 O3D_PUSH_STRUCTURE_PACKING_1;
 
+// Gets the address of memory just after a structure in a typesafe way. This is
+// used for IMMEDIATE commands to get the address of the place to put the data.
+// Immediate command put their data direclty in the command buffer.
+// Parameters:
+//   cmd: Address of command.
+template <typename T>
+void* ImmediateDataAddress(T* cmd) {
+  COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN);
+  return reinterpret_cast<char*>(cmd) + sizeof(*cmd);
+}
+
+// Gets the address of the place to put the next command in a typesafe way.
+// This can only be used for fixed sized commands.
+template <typename T>
+// Parameters:
+//   cmd: Address of command.
+void* NextCmdAddress(void* cmd) {
+  COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed);
+  return reinterpret_cast<char*>(cmd) + sizeof(T);
+}
+
+// Gets the address of the place to put the next command in a typesafe way.
+// This can only be used for variable sized command like IMMEDIATE commands.
+// Parameters:
+//   cmd: Address of command.
+//   size_of_data_in_bytes: Size of the data for the command.
+template <typename T>
+void* NextImmediateCmdAddress(void* cmd, uint32 size_of_data_in_bytes) {
+  COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN);
+  return reinterpret_cast<char*>(cmd) + sizeof(T) +   // NOLINT
+      RoundSizeToMultipleOfEntries(size_of_data_in_bytes);
+}
+
 enum ArgFlags {
   kFixed = 0x0,
   kAtLeastN = 0x1,
 };
 
 struct SharedMemory {
+  void Init(uint32 _id, uint32 _offset) {
+    id = _id;
+    offset = _offset;
+  }
+
   uint32 id;
   uint32 offset;
 };
 
-struct NOOP {
-  static const CommandId kCmdId = command_buffer::NOOP;
+COMPILE_ASSERT(offsetof(SharedMemory, id) == 0,
+               Offsetof_SharedMemory_id_not_0);
+COMPILE_ASSERT(offsetof(SharedMemory, offset) == 4,
+               Offsetof_SharedMemory_offset_not_4);
+
+struct Noop {
+  typedef Noop ValueType;
+  static const CommandId kCmdId = command_buffer::kNoop;
   static const ArgFlags kArgFlags = kAtLeastN;
+
+  void SetHeader(uint32 skip_count) {
+    header.Init(kCmdId, skip_count + 1);
+  }
+
+  void Init(uint32 skip_count) {
+    SetHeader(skip_count);
+  }
+
+  static void* Set(void* cmd, uint32 skip_count) {
+    static_cast<ValueType*>(cmd)->Init(skip_count);
+    return NextImmediateCmdAddress<ValueType>(
+        cmd, skip_count * sizeof(CommandBufferEntry));  // NOLINT
+  }
+
+  CommandHeader header;
 };
 
-struct SET_TOKEN {
-  static const CommandId kCmdId = command_buffer::SET_TOKEN;
+COMPILE_ASSERT(sizeof(Noop) == 4, Sizeof_Noop_is_not_4);
+COMPILE_ASSERT(offsetof(Noop, header) == 0, Offsetof_Noop_header_not_0);
+
+struct SetToken {
+  typedef SetToken ValueType;
+  static const CommandId kCmdId = command_buffer::kSetToken;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _token) {
+    SetHeader();
+    token = _token;
+  }
+  static void* Set(void* cmd, uint32 token) {
+    static_cast<ValueType*>(cmd)->Init(token);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 token;
 };
 
-struct BEGIN_FRAME {
-  static const CommandId kCmdId = command_buffer::BEGIN_FRAME;
+COMPILE_ASSERT(sizeof(SetToken) == 8, Sizeof_SetToken_is_not_8);
+COMPILE_ASSERT(offsetof(SetToken, header) == 0,
+               Offsetof_SetToken_header_not_0);
+COMPILE_ASSERT(offsetof(SetToken, token) == 4,
+               Offsetof_SetToken_token_not_4);
+
+struct BeginFrame {
+  typedef BeginFrame ValueType;
+  static const CommandId kCmdId = command_buffer::kBeginFrame;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init() {
+    SetHeader();
+  }
+  static void* Set(void* cmd) {
+    static_cast<ValueType*>(cmd)->Init();
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
 };
 
-struct END_FRAME {
-  static const CommandId kCmdId = command_buffer::END_FRAME;
+COMPILE_ASSERT(sizeof(BeginFrame) == 4, Sizeof_BeginFrame_is_not_4);
+COMPILE_ASSERT(offsetof(BeginFrame, header) == 0,
+               OffsetOf_BeginFrame_header_not_0);
+
+struct EndFrame {
+  typedef EndFrame ValueType;
+  static const CommandId kCmdId = command_buffer::kEndFrame;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init() {
+    SetHeader();
+  }
+  static void* Set(void* cmd) {
+    static_cast<ValueType*>(cmd)->Init();
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
 };
 
-struct CLEAR {
-  static const CommandId kCmdId = command_buffer::CLEAR;
+COMPILE_ASSERT(sizeof(EndFrame) == 4, Sizeof_EndFrame_is_not_4);
+COMPILE_ASSERT(offsetof(EndFrame, header) == 0,
+               OffsetOf_EndFrame_header_not_0);
+
+struct Clear {
+  typedef Clear ValueType;
+  static const CommandId kCmdId = command_buffer::kClear;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _buffers, float _red, float _green, float _blue,
+            float _alpha, float _depth, uint32 _stencil) {
+    SetHeader();
+    buffers = _buffers;
+    red = _red;
+    green = _green;
+    blue = _blue;
+    alpha = _alpha;
+    depth = _depth;
+    stencil = _stencil;
+  }
+
+  static void* Set(void* cmd, uint32 buffers,
+                   float red, float green, float blue, float alpha,
+                   float depth,
+                   uint32 stencil) {
+    static_cast<ValueType*>(cmd)->Init(
+        buffers, red, green, blue, alpha, depth, stencil);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 buffers;
   float red;
   float green;
@@ -402,9 +618,67 @@ struct CLEAR {
   uint32 stencil;
 };
 
-struct SET_VIEWPORT {
-  static const CommandId kCmdId = command_buffer::SET_VIEWPORT;
+COMPILE_ASSERT(sizeof(Clear) == 32, Sizeof_Clear_is_not_32);
+COMPILE_ASSERT(offsetof(Clear, header) == 0,
+               OffsetOf_Clear_header_not_0);
+COMPILE_ASSERT(offsetof(Clear, buffers) == 4,
+               OffsetOf_Clear_buffers_not_4);
+COMPILE_ASSERT(offsetof(Clear, red) == 8,
+               OffsetOf_Clear_red_not_8);
+COMPILE_ASSERT(offsetof(Clear, green) == 12,
+               OffsetOf_Clear_green_not_12);
+COMPILE_ASSERT(offsetof(Clear, blue) == 16,
+               OffsetOf_Clear_blue_not_16);
+COMPILE_ASSERT(offsetof(Clear, alpha) == 20,
+               OffsetOf_Clear_alpha_not_20);
+COMPILE_ASSERT(offsetof(Clear, depth) == 24,
+               OffsetOf_Clear_depth_not_24);
+COMPILE_ASSERT(offsetof(Clear, stencil) == 28,
+               OffsetOf_Clear_stencil_not_28);
+
+struct SetViewport {
+  typedef SetViewport ValueType;
+  static const CommandId kCmdId = command_buffer::kSetViewport;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(
+      uint32 _left,
+      uint32 _top,
+      uint32 _width,
+      uint32 _height,
+      float _z_min,
+      float _z_max) {
+    SetHeader();
+    left = _left;
+    top = _top;
+    width = _width;
+    height = _height;
+    z_min = _z_min;
+    z_max = _z_max;
+  }
+
+  static void* Set(void* cmd,
+      uint32 left,
+      uint32 top,
+      uint32 width,
+      uint32 height,
+      float z_min,
+      float z_max) {
+    static_cast<ValueType*>(cmd)->Init(
+      left,
+      top,
+      width,
+      height,
+      z_min,
+      z_max);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 left;
   uint32 top;
   uint32 width;
@@ -413,119 +687,659 @@ struct SET_VIEWPORT {
   float z_max;
 };
 
-struct CREATE_VERTEX_BUFFER {
-  static const CommandId kCmdId = command_buffer::CREATE_VERTEX_BUFFER;
+COMPILE_ASSERT(sizeof(SetViewport) == 28, Sizeof_SetViewport_is_not_28);
+COMPILE_ASSERT(offsetof(SetViewport, header) == 0,
+               OffsetOf_SetViewport_header_not_0);
+COMPILE_ASSERT(offsetof(SetViewport, left) == 4,
+               OffsetOf_SetViewport_left_not_4);
+COMPILE_ASSERT(offsetof(SetViewport, top) == 8,
+               OffsetOf_SetViewport_top_not_8);
+COMPILE_ASSERT(offsetof(SetViewport, width) == 12,
+               OffsetOf_SetViewport_width_not_12);
+COMPILE_ASSERT(offsetof(SetViewport, height) == 16,
+               OffsetOf_SetViewport_height_not_16);
+COMPILE_ASSERT(offsetof(SetViewport, z_min) == 20,
+               OffsetOf_SetViewport_z_min_not_20);
+COMPILE_ASSERT(offsetof(SetViewport, z_max) == 24,
+               OffsetOf_SetViewport_z_max_not_24);
+
+struct CreateVertexBuffer {
+  typedef CreateVertexBuffer ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateVertexBuffer;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _size, uint32 _flags) {
+    SetHeader();
+    id = _id;
+    size = _size;
+    flags = _flags;
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 size, uint32 flags) {
+    static_cast<ValueType*>(cmd)->Init(id, size, flags);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 size;
   uint32 flags;
 };
 
-struct DESTROY_VERTEX_BUFFER {
-  static const CommandId kCmdId = command_buffer::DESTROY_VERTEX_BUFFER;
+COMPILE_ASSERT(sizeof(CreateVertexBuffer) == 16,
+               Sizeof_CreateVertexBuffer_is_not_16);
+COMPILE_ASSERT(offsetof(CreateVertexBuffer, header) == 0,
+               OffsetOf_CreateVertexBuffer_header_not_0);
+COMPILE_ASSERT(offsetof(CreateVertexBuffer, id) == 4,
+               OffsetOf_CreateVertexBuffer_id_not_4);
+COMPILE_ASSERT(offsetof(CreateVertexBuffer, size) == 8,
+               OffsetOf_CreateVertexBuffer_size_not_8);
+COMPILE_ASSERT(offsetof(CreateVertexBuffer, flags) == 12,
+               OffsetOf_CreateVertexBuffer_flags_not_12);
+
+struct DestroyVertexBuffer {
+  typedef DestroyVertexBuffer ValueType;
+  static const CommandId kCmdId = command_buffer::kDestroyVertexBuffer;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct SET_VERTEX_BUFFER_DATA_IMMEDIATE {
-  static const CommandId kCmdId = command_buffer::SET_VERTEX_BUFFER_DATA_IMMEDIATE;
+COMPILE_ASSERT(sizeof(DestroyVertexBuffer) == 8,
+               Sizeof_DestroyVertexBuffer_is_not_8);
+COMPILE_ASSERT(offsetof(DestroyVertexBuffer, header) == 0,
+               OffsetOf_DestroyVertexBuffer_header_not_0);
+COMPILE_ASSERT(offsetof(DestroyVertexBuffer, id) == 4,
+               OffsetOf_DestroyVertexBuffer_id_not_4);
+
+struct SetVertexBufferDataImmediate {
+  typedef SetVertexBufferDataImmediate ValueType;
+  static const CommandId kCmdId = command_buffer::kSetVertexBufferDataImmediate;
   static const ArgFlags kArgFlags = kAtLeastN;
+
+  void SetHeader(uint32 size) {
+    header.SetCmdBySize<ValueType>(size);
+  }
+
+  void Init(uint32 _id, uint32 _offset, const void* data, uint32 size) {
+    SetHeader(size);
+    id = _id;
+    offset = _offset;
+    memcpy(ImmediateDataAddress(this), data, size);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 offset,
+                   const void* data, uint32 size) {
+    static_cast<ValueType*>(cmd)->Init(id, offset, data, size);
+    return NextImmediateCmdAddress<ValueType>(cmd, size);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 offset;
 };
 
-struct SET_VERTEX_BUFFER_DATA {
-  static const CommandId kCmdId = command_buffer::SET_VERTEX_BUFFER_DATA;
+COMPILE_ASSERT(sizeof(SetVertexBufferDataImmediate) == 12,
+               Sizeof_SetVertexBufferDataImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(SetVertexBufferDataImmediate, header) == 0,
+               OffsetOf_SetVertexBufferDataImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(SetVertexBufferDataImmediate, id) == 4,
+               OffsetOf_SetVertexBufferDataImmediate_id_not_4);
+COMPILE_ASSERT(offsetof(SetVertexBufferDataImmediate, offset) == 8,
+               OffsetOf_SetVertexBufferDataImmediate_offset_not_8);
+
+struct SetVertexBufferData {
+  typedef SetVertexBufferData ValueType;
+  static const CommandId kCmdId = command_buffer::kSetVertexBufferData;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _offset, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    id = _id;
+    offset = _offset;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 offset, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(id, offset, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 offset;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct GET_VERTEX_BUFFER_DATA {
-  static const CommandId kCmdId = command_buffer::GET_VERTEX_BUFFER_DATA;
+COMPILE_ASSERT(sizeof(SetVertexBufferData) == 24,
+               Sizeof_SetVertexBufferData_is_not_24);
+COMPILE_ASSERT(offsetof(SetVertexBufferData, header) == 0,
+               OffsetOf_SetVertexBufferData_header_not_0);
+COMPILE_ASSERT(offsetof(SetVertexBufferData, id) == 4,
+               OffsetOf_SetVertexBufferData_id_not_4);
+COMPILE_ASSERT(offsetof(SetVertexBufferData, offset) == 8,
+               OffsetOf_SetVertexBufferData_offset_not_8);
+COMPILE_ASSERT(offsetof(SetVertexBufferData, size) == 12,
+               OffsetOf_SetVertexBufferData_size_not_12);
+COMPILE_ASSERT(offsetof(SetVertexBufferData, shared_memory) == 16,
+               OffsetOf_SetVertexBufferData_shared_memory_not_16);
+
+struct GetVertexBufferData {
+  typedef GetVertexBufferData ValueType;
+  static const CommandId kCmdId = command_buffer::kGetVertexBufferData;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _offset, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    id = _id;
+    offset = _offset;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 offset, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(id, offset, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 offset;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct CREATE_INDEX_BUFFER {
-  static const CommandId kCmdId = command_buffer::CREATE_INDEX_BUFFER;
+COMPILE_ASSERT(sizeof(GetVertexBufferData) == 24,
+               Sizeof_GetVertexBufferData_is_not_24);
+COMPILE_ASSERT(offsetof(GetVertexBufferData, header) == 0,
+               OffsetOf_GetVertexBufferData_header_not_0);
+COMPILE_ASSERT(offsetof(GetVertexBufferData, id) == 4,
+               OffsetOf_GetVertexBufferData_id_not_4);
+COMPILE_ASSERT(offsetof(GetVertexBufferData, offset) == 8,
+               OffsetOf_GetVertexBufferData_offset_not_8);
+COMPILE_ASSERT(offsetof(GetVertexBufferData, size) == 12,
+               OffsetOf_GetVertexBufferData_size_not_12);
+COMPILE_ASSERT(offsetof(GetVertexBufferData, shared_memory) == 16,
+               OffsetOf_GetVertexBufferData_shared_memory_not_16);
+
+struct CreateIndexBuffer {
+  typedef CreateIndexBuffer ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateIndexBuffer;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _size, uint32 _flags) {
+    SetHeader();
+    id = _id;
+    size = _size;
+    flags = _flags;
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 size, uint32 flags) {
+    static_cast<ValueType*>(cmd)->Init(id, size, flags);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 size;
   uint32 flags;
 };
 
-struct DESTROY_INDEX_BUFFER {
-  static const CommandId kCmdId = command_buffer::DESTROY_INDEX_BUFFER;
+COMPILE_ASSERT(sizeof(CreateIndexBuffer) == 16,
+               Sizeof_CreateIndexBuffer_is_not_16);
+COMPILE_ASSERT(offsetof(CreateIndexBuffer, header) == 0,
+               OffsetOf_CreateIndexBuffer_header_not_0);
+COMPILE_ASSERT(offsetof(CreateIndexBuffer, id) == 4,
+               OffsetOf_CreateIndexBuffer_id_not_4);
+COMPILE_ASSERT(offsetof(CreateIndexBuffer, size) == 8,
+               OffsetOf_CreateIndexBuffer_size_not_8);
+COMPILE_ASSERT(offsetof(CreateIndexBuffer, flags) == 12,
+               OffsetOf_CreateIndexBuffer_flags_not_12);
+
+struct DestroyIndexBuffer {
+  typedef DestroyIndexBuffer ValueType;
+  static const CommandId kCmdId = command_buffer::kDestroyIndexBuffer;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct SET_INDEX_BUFFER_DATA_IMMEDIATE {
-  static const CommandId kCmdId = command_buffer::SET_INDEX_BUFFER_DATA_IMMEDIATE;
+COMPILE_ASSERT(sizeof(DestroyIndexBuffer) == 8,
+               Sizeof_DestroyIndexBuffer_is_not_8);
+COMPILE_ASSERT(offsetof(DestroyIndexBuffer, header) == 0,
+               OffsetOf_DestroyIndexBuffer_header_not_0);
+COMPILE_ASSERT(offsetof(DestroyIndexBuffer, id) == 4,
+               OffsetOf_DestroyIndexBuffer_id_not_4);
+
+struct SetIndexBufferDataImmediate {
+  typedef SetIndexBufferDataImmediate ValueType;
+  static const CommandId kCmdId = command_buffer::kSetIndexBufferDataImmediate;
   static const ArgFlags kArgFlags = kAtLeastN;
+
+  void SetHeader(uint32 size) {
+    header.SetCmdBySize<ValueType>(size);
+  }
+
+  void Init(uint32 _id, uint32 _offset, const void* data, uint32 size) {
+    SetHeader(size);
+    id = _id;
+    offset = _offset;
+    memcpy(ImmediateDataAddress(this), data, size);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 offset, const void* data,
+                   uint32 size) {
+    static_cast<ValueType*>(cmd)->Init(id, offset, data, size);
+    return NextImmediateCmdAddress<ValueType>(cmd, size);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 offset;
 };
 
-struct SET_INDEX_BUFFER_DATA {
-  static const CommandId kCmdId = command_buffer::SET_INDEX_BUFFER_DATA;
+COMPILE_ASSERT(sizeof(SetIndexBufferDataImmediate) == 12,
+               Sizeof_SetIndexBufferDataImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(SetIndexBufferDataImmediate, header) == 0,
+               OffsetOf_SetIndexBufferDataImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(SetIndexBufferDataImmediate, id) == 4,
+               OffsetOf_SetIndexBufferDataImmediate_id_not_4);
+COMPILE_ASSERT(offsetof(SetIndexBufferDataImmediate, offset) == 8,
+               OffsetOf_SetIndexBufferDataImmediate_offset_not_8);
+
+struct SetIndexBufferData {
+  typedef SetIndexBufferData ValueType;
+  static const CommandId kCmdId = command_buffer::kSetIndexBufferData;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _offset, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    id = _id;
+    offset = _offset;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 offset, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(id, offset, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 offset;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct GET_INDEX_BUFFER_DATA {
-  static const CommandId kCmdId = command_buffer::GET_INDEX_BUFFER_DATA;
+COMPILE_ASSERT(sizeof(SetIndexBufferData) == 24,
+               Sizeof_SetIndexBufferData_is_not_24);
+COMPILE_ASSERT(offsetof(SetIndexBufferData, header) == 0,
+               OffsetOf_SetIndexBufferData_header_not_0);
+COMPILE_ASSERT(offsetof(SetIndexBufferData, id) == 4,
+               OffsetOf_SetIndexBufferData_id_not_4);
+COMPILE_ASSERT(offsetof(SetIndexBufferData, offset) == 8,
+               OffsetOf_SetIndexBufferData_offset_not_8);
+COMPILE_ASSERT(offsetof(SetIndexBufferData, size) == 12,
+               OffsetOf_SetIndexBufferData_size_not_12);
+COMPILE_ASSERT(offsetof(SetIndexBufferData, shared_memory) == 16,
+               OffsetOf_SetIndexBufferData_shared_memory_not_16);
+
+struct GetIndexBufferData {
+  typedef GetIndexBufferData ValueType;
+  static const CommandId kCmdId = command_buffer::kGetIndexBufferData;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _offset, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    id = _id;
+    offset = _offset;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 offset, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(id, offset, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 offset;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct CREATE_VERTEX_STRUCT {
-  static const CommandId kCmdId = command_buffer::CREATE_VERTEX_STRUCT;
+COMPILE_ASSERT(sizeof(GetIndexBufferData) == 24,
+               Sizeof_GetIndexBufferData_is_not_24);
+COMPILE_ASSERT(offsetof(GetIndexBufferData, header) == 0,
+               OffsetOf_GetIndexBufferData_header_not_0);
+COMPILE_ASSERT(offsetof(GetIndexBufferData, id) == 4,
+               OffsetOf_GetIndexBufferData_id_not_4);
+COMPILE_ASSERT(offsetof(GetIndexBufferData, offset) == 8,
+               OffsetOf_GetIndexBufferData_offset_not_8);
+COMPILE_ASSERT(offsetof(GetIndexBufferData, size) == 12,
+               OffsetOf_GetIndexBufferData_size_not_12);
+COMPILE_ASSERT(offsetof(GetIndexBufferData, shared_memory) == 16,
+               OffsetOf_GetIndexBufferData_shared_memory_not_16);
+
+struct CreateVertexStruct {
+  typedef CreateVertexStruct ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateVertexStruct;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _input_count) {
+    SetHeader();
+    id = _id;
+    input_count = _input_count;
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 input_count) {
+    static_cast<ValueType*>(cmd)->Init(id, input_count);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 input_count;
 };
 
-struct DESTROY_VERTEX_STRUCT {
-  static const CommandId kCmdId = command_buffer::DESTROY_VERTEX_STRUCT;
+COMPILE_ASSERT(sizeof(CreateVertexStruct) == 12,
+               Sizeof_CreateVertexStruct_is_not_12);
+COMPILE_ASSERT(offsetof(CreateVertexStruct, header) == 0,
+               OffsetOf_CreateVertexStruct_header_not_0);
+COMPILE_ASSERT(offsetof(CreateVertexStruct, id) == 4,
+               OffsetOf_CreateVertexStruct_id_not_4);
+COMPILE_ASSERT(offsetof(CreateVertexStruct, input_count) == 8,
+               OffsetOf_CreateVertexStruct_input_count_not_8);
+
+struct DestroyVertexStruct {
+  typedef DestroyVertexStruct ValueType;
+  static const CommandId kCmdId = command_buffer::kDestroyVertexStruct;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct SET_VERTEX_INPUT {
-  static const CommandId kCmdId = command_buffer::SET_VERTEX_INPUT;
-  static const ArgFlags kArgFlags = kAtLeastN;
-};
+COMPILE_ASSERT(sizeof(DestroyVertexStruct) == 8,
+               Sizeof_DestroyVertexStruct_is_not_8);
+COMPILE_ASSERT(offsetof(DestroyVertexStruct, header) == 0,
+               OffsetOf_DestroyVertexStruct_header_not_0);
+COMPILE_ASSERT(offsetof(DestroyVertexStruct, id) == 4,
+               OffsetOf_DestroyVertexStruct_id_not_4);
 
-struct SET_VERTEX_STRUCT {
-  static const CommandId kCmdId = command_buffer::SET_VERTEX_STRUCT;
+struct SetVertexInput {
+  typedef SetVertexInput ValueType;
+  static const CommandId kCmdId = command_buffer::kSetVertexInput;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _vertex_struct_id,
+            uint32 _input_index,
+            uint32 _vertex_buffer_id,
+            uint32 _offset,
+            uint8 _semantic,
+            uint32 _semantic_index,
+            uint8 _type,
+            uint32 _stride) {
+    SetHeader();
+    vertex_struct_id = _vertex_struct_id;
+    input_index = _input_index;
+    vertex_buffer_id = _vertex_buffer_id;
+    offset = _offset;
+    fixme4 =
+        set_vertex_input_cmd::Semantic::MakeValue(_semantic) |
+        set_vertex_input_cmd::SemanticIndex::MakeValue(_semantic_index) |
+        set_vertex_input_cmd::Type::MakeValue(_type) |
+        set_vertex_input_cmd::Stride::MakeValue(_stride);
+  }
+
+  static void* Set(
+      void* cmd,
+      uint32 vertex_struct_id,
+      uint32 input_index,
+      uint32 vertex_buffer_id,
+      uint32 offset,
+      uint8 semantic,
+      uint32 semantic_index,
+      uint8 type,
+      uint32 stride) {
+    static_cast<ValueType*>(cmd)->Init(
+        vertex_struct_id,
+        input_index,
+        vertex_buffer_id,
+        offset,
+        semantic,
+        semantic_index,
+        type,
+        stride);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
+  uint32 vertex_struct_id;
+  uint32 input_index;
+  uint32 vertex_buffer_id;
+  uint32 offset;
+  uint32 fixme4;
+};
+
+COMPILE_ASSERT(sizeof(SetVertexInput) == 24,
+               Sizeof_SetVertexInput_is_not_24);
+COMPILE_ASSERT(offsetof(SetVertexInput, header) == 0,
+               OffsetOf_SetVertexInput_header_not_0);
+COMPILE_ASSERT(offsetof(SetVertexInput, vertex_struct_id) == 4,
+               OffsetOf_SetVertexInput_vertex_struct_id_not_4);
+COMPILE_ASSERT(offsetof(SetVertexInput, input_index) == 8,
+               OffsetOf_SetVertexInput_input_index_not_8);
+COMPILE_ASSERT(offsetof(SetVertexInput, vertex_buffer_id) == 12,
+               OffsetOf_SetVertexInput_vertex_buffer_id_not_12);
+COMPILE_ASSERT(offsetof(SetVertexInput, offset) == 16,
+               OffsetOf_SetVertexInput_offset_not_16);
+COMPILE_ASSERT(offsetof(SetVertexInput, fixme4) == 20,
+               OffsetOf_SetVertexInput_fixme4_not_20);
+
+struct SetVertexStruct {
+  typedef SetVertexStruct ValueType;
+  static const CommandId kCmdId = command_buffer::kSetVertexStruct;
+  static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct DRAW {
-  static const CommandId kCmdId = command_buffer::DRAW;
+COMPILE_ASSERT(sizeof(SetVertexStruct) == 8,
+               Sizeof_SetVertexStruct_is_not_8);
+COMPILE_ASSERT(offsetof(SetVertexStruct, header) == 0,
+               OffsetOf_SetVertexStruct_header_not_0);
+COMPILE_ASSERT(offsetof(SetVertexStruct, id) == 4,
+               OffsetOf_SetVertexStruct_id_not_4);
+
+struct Draw {
+  typedef Draw ValueType;
+  static const CommandId kCmdId = command_buffer::kDraw;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _primitive_type, uint32 _first, uint32 _count) {
+    SetHeader();
+    primitive_type = _primitive_type;
+    first = _first;
+    count = _count;
+  }
+
+  static void* Set(void* cmd, uint32 primitive_type, uint32 first,
+                   uint32 count) {
+    static_cast<ValueType*>(cmd)->Init(primitive_type, first, count);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 primitive_type;
   uint32 first;
   uint32 count;
 };
 
-struct DRAW_INDEXED {
-  static const CommandId kCmdId = command_buffer::DRAW_INDEXED;
+COMPILE_ASSERT(sizeof(Draw) == 16, Sizeof_DRAW_is_not_16);
+COMPILE_ASSERT(offsetof(Draw, header) == 0,
+               OffsetOf_Draw_header_not_0);
+COMPILE_ASSERT(offsetof(Draw, primitive_type) == 4,
+               OffsetOf_Draw_primitive_type_not_4);
+COMPILE_ASSERT(offsetof(Draw, first) == 8,
+               OffsetOf_Draw_first_not_8);
+COMPILE_ASSERT(offsetof(Draw, count) == 12,
+               OffsetOf_Draw_count_not_12);
+
+struct DrawIndexed {
+  typedef DrawIndexed ValueType;
+  static const CommandId kCmdId = command_buffer::kDrawIndexed;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(
+      uint32 _primitive_type,
+      uint32 _index_buffer_id,
+      uint32 _first,
+      uint32 _count,
+      uint32 _min_index,
+      uint32 _max_index) {
+    SetHeader();
+    primitive_type = _primitive_type;
+    index_buffer_id = _index_buffer_id;
+    first = _first;
+    count = _count;
+    min_index = _min_index;
+    max_index = _max_index;
+  }
+
+  static void* Set(void* cmd,
+      uint32 primitive_type,
+      uint32 index_buffer_id,
+      uint32 first,
+      uint32 count,
+      uint32 min_index,
+      uint32 max_index) {
+    static_cast<ValueType*>(cmd)->Init(
+        primitive_type,
+        index_buffer_id,
+        first,
+        count,
+        min_index,
+        max_index);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 primitive_type;
   uint32 index_buffer_id;
   uint32 first;
@@ -534,175 +1348,1218 @@ struct DRAW_INDEXED {
   uint32 max_index;
 };
 
-struct CREATE_EFFECT {
-  static const CommandId kCmdId = command_buffer::CREATE_EFFECT;
+COMPILE_ASSERT(sizeof(DrawIndexed) == 28, Sizeof_DrawIndexed_is_not_28);
+COMPILE_ASSERT(offsetof(DrawIndexed, header) == 0,
+               OffsetOf_DrawIndexed_header_not_0);
+COMPILE_ASSERT(offsetof(DrawIndexed, primitive_type) == 4,
+               OffsetOf_DrawIndexed_primitive_type_not_4);
+COMPILE_ASSERT(offsetof(DrawIndexed, index_buffer_id) == 8,
+               OffsetOf_DrawIndexed_index_buffer_id_not_8);
+COMPILE_ASSERT(offsetof(DrawIndexed, first) == 12,
+               OffsetOf_DrawIndexed_first_not_12);
+COMPILE_ASSERT(offsetof(DrawIndexed, count) == 16,
+               OffsetOf_DrawIndexed_count_not_16);
+COMPILE_ASSERT(offsetof(DrawIndexed, min_index) == 20,
+               OffsetOf_DrawIndexed_min_index_not_20);
+COMPILE_ASSERT(offsetof(DrawIndexed, max_index) == 24,
+               OffsetOf_DrawIndexed_max_index_not_24);
+
+struct CreateEffect {
+  typedef CreateEffect ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateEffect;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    id = _id;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(id, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct CREATE_EFFECT_IMMEDIATE {
-  static const CommandId kCmdId = command_buffer::CREATE_EFFECT_IMMEDIATE;
+COMPILE_ASSERT(sizeof(CreateEffect) == 20, Sizeof_CreateEffect_is_not_20);
+COMPILE_ASSERT(offsetof(CreateEffect, header) == 0,
+               OffsetOf_CreateEffect_header_not_0);
+COMPILE_ASSERT(offsetof(CreateEffect, id) == 4,
+               OffsetOf_CreateEffect_id_not_4);
+COMPILE_ASSERT(offsetof(CreateEffect, size) == 8,
+               OffsetOf_CreateEffect_size_not_8);
+COMPILE_ASSERT(offsetof(CreateEffect, shared_memory) == 12,
+               OffsetOf_CreateEffect_shared_memory_not_12);
+
+struct CreateEffectImmediate {
+  typedef CreateEffectImmediate ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateEffectImmediate;
   static const ArgFlags kArgFlags = kAtLeastN;
+
+  void SetHeader(uint32 size) {
+    header.SetCmdBySize<ValueType>(size);
+  }
+
+  void Init(uint32 _id, uint32 _size, const void* data) {
+    SetHeader(_size);
+    id = _id;
+    size = _size;
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 size, const void* data) {
+    static_cast<ValueType*>(cmd)->Init(id, size, data);
+    return NextImmediateCmdAddress<ValueType>(cmd, size);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 size;
 };
 
-struct DESTROY_EFFECT {
-  static const CommandId kCmdId = command_buffer::DESTROY_EFFECT;
+COMPILE_ASSERT(sizeof(CreateEffectImmediate) == 12,
+               Sizeof_CreateEffectImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(CreateEffectImmediate, header) == 0,
+               OffsetOf_CreateEffectImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(CreateEffectImmediate, id) == 4,
+               OffsetOf_CreateEffectImmediate_id_not_4);
+COMPILE_ASSERT(offsetof(CreateEffectImmediate, size) == 8,
+               OffsetOf_CreateEffectImmediate_size_not_8);
+
+struct DestroyEffect {
+  typedef DestroyEffect ValueType;
+  static const CommandId kCmdId = command_buffer::kDestroyEffect;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct SET_EFFECT {
-  static const CommandId kCmdId = command_buffer::SET_EFFECT;
+COMPILE_ASSERT(sizeof(DestroyEffect) == 8, Sizeof_DestroyEffect_is_not_8);
+COMPILE_ASSERT(offsetof(DestroyEffect, header) == 0,
+               OffsetOf_DestroyEffect_header_not_0);
+COMPILE_ASSERT(offsetof(DestroyEffect, id) == 4,
+               OffsetOf_DestroyEffect_id_not_4);
+
+struct SetEffect {
+  typedef SetEffect ValueType;
+  static const CommandId kCmdId = command_buffer::kSetEffect;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct GET_PARAM_COUNT {
-  static const CommandId kCmdId = command_buffer::GET_PARAM_COUNT;
+COMPILE_ASSERT(sizeof(SetEffect) == 8, Sizeof_SetEffect_is_not_8);
+COMPILE_ASSERT(offsetof(SetEffect, header) == 0,
+               OffsetOf_SetEffect_header_not_0);
+COMPILE_ASSERT(offsetof(SetEffect, id) == 4,
+               OffsetOf_SetEffect_id_not_4);
+
+struct GetParamCount {
+  typedef GetParamCount ValueType;
+  static const CommandId kCmdId = command_buffer::kGetParamCount;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    id = _id;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(id, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct CREATE_PARAM {
-  static const CommandId kCmdId = command_buffer::CREATE_PARAM;
+COMPILE_ASSERT(sizeof(GetParamCount) == 20, Sizeof_GetParamCount_is_not_20);
+COMPILE_ASSERT(offsetof(GetParamCount, header) == 0,
+               OffsetOf_GetParamCount_header_not_0);
+COMPILE_ASSERT(offsetof(GetParamCount, id) == 4,
+               OffsetOf_GetParamCount_id_not_4);
+COMPILE_ASSERT(offsetof(GetParamCount, size) == 8,
+               OffsetOf_GetParamCount_size_not_8);
+COMPILE_ASSERT(offsetof(GetParamCount, shared_memory) == 12,
+               OffsetOf_GetParamCount_shared_memory_not_12);
+
+struct CreateParam {
+  typedef CreateParam ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateParam;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _param_id, uint32 _effect_id, uint32 _index) {
+    SetHeader();
+    param_id = _param_id;
+    effect_id = _effect_id;
+    index = _index;
+  }
+
+  static void* Set(void* cmd,
+                   uint32 param_id, uint32 effect_id, uint32 index) {
+    static_cast<ValueType*>(cmd)->Init(param_id, effect_id, index);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 param_id;
   uint32 effect_id;
   uint32 index;
 };
 
-struct CREATE_PARAM_BY_NAME {
-  static const CommandId kCmdId = command_buffer::CREATE_PARAM_BY_NAME;
+COMPILE_ASSERT(sizeof(CreateParam) == 16, Sizeof_CreateParam_is_not_16);
+COMPILE_ASSERT(offsetof(CreateParam, header) == 0,
+               OffsetOf_CreateParam_header_not_0);
+COMPILE_ASSERT(offsetof(CreateParam, param_id) == 4,
+               OffsetOf_CreateParam_param_id_not_4);
+COMPILE_ASSERT(offsetof(CreateParam, effect_id) == 8,
+               OffsetOf_CreateParam_effect_id_not_8);
+COMPILE_ASSERT(offsetof(CreateParam, index) == 12,
+               OffsetOf_CreateParam_index_not_12);
+
+struct CreateParamByName {
+  typedef CreateParamByName ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateParamByName;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _param_id, uint32 _effect_id, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    param_id = _param_id;
+    effect_id = _effect_id;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 param_id, uint32 effect_id, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(param_id, effect_id, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 param_id;
   uint32 effect_id;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct CREATE_PARAM_BY_NAME_IMMEDIATE {
-  static const CommandId kCmdId = command_buffer::CREATE_PARAM_BY_NAME_IMMEDIATE;
+COMPILE_ASSERT(sizeof(CreateParamByName) == 24,
+               Sizeof_CreateParamByName_is_not_24);
+COMPILE_ASSERT(offsetof(CreateParamByName, header) == 0,
+               OffsetOf_CreateParamByName_header_not_0);
+COMPILE_ASSERT(offsetof(CreateParamByName, param_id) == 4,
+               OffsetOf_CreateParamByName_param_id_not_4);
+COMPILE_ASSERT(offsetof(CreateParamByName, effect_id) == 8,
+               OffsetOf_CreateParamByName_effect_id_not_8);
+COMPILE_ASSERT(offsetof(CreateParamByName, size) == 12,
+               OffsetOf_CreateParamByName_size_not_12);
+COMPILE_ASSERT(offsetof(CreateParamByName, shared_memory) == 16,
+               OffsetOf_CreateParamByName_shared_memory_not_16);
+
+struct CreateParamByNameImmediate {
+  typedef CreateParamByNameImmediate ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateParamByNameImmediate;
   static const ArgFlags kArgFlags = kAtLeastN;
+
+  void SetHeader(uint32 size) {
+    header.SetCmdBySize<ValueType>(size);
+  }
+
+  void Init(uint32 _param_id, uint32 _effect_id, uint32 _size,
+            const void* data) {
+    SetHeader(_size);
+    param_id = _param_id;
+    effect_id = _effect_id;
+    size = _size;
+    memcpy(ImmediateDataAddress(this), data, _size);
+  }
+
+  static void* Set(void* cmd, uint32 param_id, uint32 effect_id, uint32 size,
+                   const void* data) {
+    static_cast<ValueType*>(cmd)->Init(param_id, effect_id, size, data);
+    return NextImmediateCmdAddress<ValueType>(cmd, size);
+  }
+
+  CommandHeader header;
   uint32 param_id;
   uint32 effect_id;
   uint32 size;
 };
 
-struct DESTROY_PARAM {
-  static const CommandId kCmdId = command_buffer::DESTROY_PARAM;
+COMPILE_ASSERT(sizeof(CreateParamByNameImmediate) == 16,
+               Sizeof_CreateParamByNameImmediate_is_not_16);
+COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, header) == 0,
+               OffsetOf_CreateParamByNameImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, param_id) == 4,
+               OffsetOf_CreateParamByNameImmediate_param_id_not_4);
+COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, effect_id) == 8,
+               OffsetOf_CreateParamByNameImmediate_effect_id_not_8);
+COMPILE_ASSERT(offsetof(CreateParamByNameImmediate, size) == 12,
+               OffsetOf_CreateParamByNameImmediate_size_not_12);
+
+struct DestroyParam {
+  typedef DestroyParam ValueType;
+  static const CommandId kCmdId = command_buffer::kDestroyParam;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct SET_PARAM_DATA {
-  static const CommandId kCmdId = command_buffer::SET_PARAM_DATA;
+COMPILE_ASSERT(sizeof(DestroyParam) == 8, Sizeof_DestroyParam_is_not_8);
+COMPILE_ASSERT(offsetof(DestroyParam, header) == 0,
+               OffsetOf_DestroyParam_header_not_0);
+COMPILE_ASSERT(offsetof(DestroyParam, id) == 4,
+               OffsetOf_DestroyParam_id_not_4);
+
+struct SetParamData {
+  typedef SetParamData ValueType;
+  static const CommandId kCmdId = command_buffer::kSetParamData;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    id = _id;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(id, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct SET_PARAM_DATA_IMMEDIATE {
-  static const CommandId kCmdId = command_buffer::SET_PARAM_DATA_IMMEDIATE;
+COMPILE_ASSERT(sizeof(SetParamData) == 20, Sizeof_SetParamData_is_not_20);
+COMPILE_ASSERT(offsetof(SetParamData, header) == 0,
+               OffsetOf_SetParamData_header_not_0);
+COMPILE_ASSERT(offsetof(SetParamData, id) == 4,
+               OffsetOf_SetParamData_id_not_4);
+COMPILE_ASSERT(offsetof(SetParamData, size) == 8,
+               OffsetOf_SetParamData_size_not_8);
+COMPILE_ASSERT(offsetof(SetParamData, shared_memory) == 12,
+               OffsetOf_SetParamData_shared_memory_not_12);
+
+struct SetParamDataImmediate {
+  typedef SetParamDataImmediate ValueType;
+  static const CommandId kCmdId = command_buffer::kSetParamDataImmediate;
   static const ArgFlags kArgFlags = kAtLeastN;
+
+  void SetHeader(uint32 size) {
+    header.SetCmdBySize<ValueType>(size);
+  }
+
+  void Init(uint32 _id, uint32 _size, const void* data) {
+    SetHeader(_size);
+    id = _id;
+    size = _size;
+    memcpy(ImmediateDataAddress(this), data, _size);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 size, const void* data) {
+    static_cast<ValueType*>(cmd)->Init(id, size, data);
+    return NextImmediateCmdAddress<ValueType>(cmd, size);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 size;
 };
 
-struct GET_PARAM_DESC {
-  static const CommandId kCmdId = command_buffer::GET_PARAM_DESC;
+COMPILE_ASSERT(sizeof(SetParamDataImmediate) == 12,
+               Sizeof_SetParamDataImmediate_is_not_12);
+COMPILE_ASSERT(offsetof(SetParamDataImmediate, header) == 0,
+               OffsetOf_SetParamDataImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(SetParamDataImmediate, id) == 4,
+               OffsetOf_SetParamDataImmediate_id_not_4);
+COMPILE_ASSERT(offsetof(SetParamDataImmediate, size) == 8,
+               OffsetOf_SetParamDataImmediate_size_not_8);
+
+struct GetParamDesc {
+  typedef GetParamDesc ValueType;
+  static const CommandId kCmdId = command_buffer::kGetParamDesc;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    id = _id;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(id, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct GET_STREAM_COUNT {
-  static const CommandId kCmdId = command_buffer::GET_STREAM_COUNT;
+COMPILE_ASSERT(sizeof(GetParamDesc) == 20, Sizeof_GetParamDesc_is_not_20);
+COMPILE_ASSERT(offsetof(GetParamDesc, header) == 0,
+               OffsetOf_GetParamDesc_header_not_0);
+COMPILE_ASSERT(offsetof(GetParamDesc, id) == 4,
+               OffsetOf_GetParamDesc_id_not_4);
+COMPILE_ASSERT(offsetof(GetParamDesc, size) == 8,
+               OffsetOf_GetParamDesc_size_not_8);
+COMPILE_ASSERT(offsetof(GetParamDesc, shared_memory) == 12,
+               OffsetOf_GetParamDesc_shared_memory_not_12);
+
+struct GetStreamCount {
+  typedef GetStreamCount ValueType;
+  static const CommandId kCmdId = command_buffer::kGetStreamCount;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    id = _id;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(id, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct GET_STREAM_DESC {
-  static const CommandId kCmdId = command_buffer::GET_STREAM_DESC;
+COMPILE_ASSERT(sizeof(GetStreamCount) == 20,
+               Sizeof_GetStreamCount_is_not_20);
+COMPILE_ASSERT(offsetof(GetStreamCount, header) == 0,
+               OffsetOf_GetStreamCount_header_not_0);
+COMPILE_ASSERT(offsetof(GetStreamCount, id) == 4,
+               OffsetOf_GetStreamCount_id_not_4);
+COMPILE_ASSERT(offsetof(GetStreamCount, size) == 8,
+               OffsetOf_GetStreamCount_size_not_8);
+COMPILE_ASSERT(offsetof(GetStreamCount, shared_memory) == 12,
+               OffsetOf_GetStreamCount_shared_memory_not_12);
+
+struct GetStreamDesc {
+  typedef GetStreamDesc ValueType;
+  static const CommandId kCmdId = command_buffer::kGetStreamDesc;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _index, uint32 _size,
+            uint32 shared_memory_id, uint32 shared_memory_offset) {
+    SetHeader();
+    id = _id;
+    index = _index;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 index, uint32 size,
+                   uint32 shared_memory_id, uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(id, index, size,
+                                       shared_memory_id, shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 index;
   uint32 size;
   SharedMemory shared_memory;
 };
 
-struct DESTROY_TEXTURE {
-  static const CommandId kCmdId = command_buffer::DESTROY_TEXTURE;
+COMPILE_ASSERT(sizeof(GetStreamDesc) == 24, Sizeof_GetStreamDesc_is_not_24);
+COMPILE_ASSERT(offsetof(GetStreamDesc, header) == 0,
+               OffsetOf_GetStreamDesc_header_not_0);
+COMPILE_ASSERT(offsetof(GetStreamDesc, id) ==4 ,
+               OffsetOf_GetStreamDesc_id_not_4);
+COMPILE_ASSERT(offsetof(GetStreamDesc, index) == 8,
+               OffsetOf_GetStreamDesc_index_not_8);
+COMPILE_ASSERT(offsetof(GetStreamDesc, size) == 12,
+               OffsetOf_GetStreamDesc_size_not_12);
+COMPILE_ASSERT(offsetof(GetStreamDesc, shared_memory) == 16,
+               OffsetOf_GetStreamDesc_shared_memory_not_16);
+
+struct DestroyTexture {
+  typedef DestroyTexture ValueType;
+  static const CommandId kCmdId = command_buffer::kDestroyTexture;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct CREATE_TEXTURE_2D {
-  static const CommandId kCmdId = command_buffer::CREATE_TEXTURE_2D;
-  static const ArgFlags kArgFlags = kAtLeastN;
+COMPILE_ASSERT(sizeof(DestroyTexture) == 8, Sizeof_DestroyTexture_is_not_8);
+COMPILE_ASSERT(offsetof(DestroyTexture, header) == 0,
+               OffsetOf_DestroyTexture_header_not_0);
+COMPILE_ASSERT(offsetof(DestroyTexture, id) == 4,
+               OffsetOf_DestroyTexture_id_not_4);
+
+struct CreateTexture2d {
+  typedef CreateTexture2d ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateTexture2d;
+  static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _texture_id,
+            uint32 _width, uint32 _height, uint32 _levels, uint32 _format,
+            uint32 _enable_render_surfaces) {
+    SetHeader();
+    texture_id = _texture_id;
+    fixme1 =
+        create_texture_2d_cmd::Width::MakeValue(_width) |
+        create_texture_2d_cmd::Height::MakeValue(_height);
+    fixme2 =
+        create_texture_2d_cmd::Levels::MakeValue(_levels) |
+        create_texture_2d_cmd::Format::MakeValue(_format) |
+        create_texture_2d_cmd::Flags::MakeValue(_enable_render_surfaces);
+  }
+
+  static void* Set(void* cmd, uint32 texture_id,
+                   uint32 width, uint32 height, uint32 levels, uint32 format,
+                   uint32 enable_render_surfaces) {
+    static_cast<ValueType*>(cmd)->Init(texture_id,
+                                       width, height, levels, format,
+                                       enable_render_surfaces);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
+  uint32 texture_id;
+  uint32 fixme1;
+  uint32 fixme2;
 };
 
-struct CREATE_TEXTURE_3D {
-  static const CommandId kCmdId = command_buffer::CREATE_TEXTURE_3D;
-  static const ArgFlags kArgFlags = kAtLeastN;
+COMPILE_ASSERT(sizeof(CreateTexture2d) == 16,
+               Sizeof_CreateTexture2d_is_not_16);
+COMPILE_ASSERT(offsetof(CreateTexture2d, header) == 0,
+               OffsetOf_CreateTexture2d_header_not_0);
+COMPILE_ASSERT(offsetof(CreateTexture2d, texture_id) == 4,
+               OffsetOf_CreateTexture2d_texture_id_not_4);
+COMPILE_ASSERT(offsetof(CreateTexture2d, fixme1) == 8,
+               OffsetOf_CreateTexture2d_fixme1_not_8);
+COMPILE_ASSERT(offsetof(CreateTexture2d, fixme2) == 12,
+               OffsetOf_CreateTexture2d_fixme2_not_12);
+
+struct CreateTexture3d {
+  typedef CreateTexture3d ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateTexture3d;
+  static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _texture_id,
+            uint32 _width, uint32 _height, uint32 _depth,
+            uint32 _levels, uint32 _format,
+            uint32 _enable_render_surfaces) {
+    SetHeader();
+    texture_id = _texture_id;
+    fixme1 =
+        create_texture_3d_cmd::Width::MakeValue(_width) |
+        create_texture_3d_cmd::Height::MakeValue(_height);
+    fixme2 =
+        create_texture_3d_cmd::Depth::MakeValue(_depth);
+    fixme3 =
+        create_texture_3d_cmd::Levels::MakeValue(_levels) |
+        create_texture_3d_cmd::Format::MakeValue(_format) |
+        create_texture_3d_cmd::Flags::MakeValue(_enable_render_surfaces);
+  }
+
+  static void* Set(void* cmd, uint32 texture_id,
+                   uint32 width, uint32 height, uint32 depth,
+                   uint32 levels, uint32 format,
+                   uint32 enable_render_surfaces) {
+    static_cast<ValueType*>(cmd)->Init(texture_id,
+                                       width, height, depth,
+                                       levels, format,
+                                       enable_render_surfaces);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
-};
+  CommandHeader header;
+  uint32 texture_id;
+  uint32 fixme1;
+  uint32 fixme2;
+  uint32 fixme3;
+};
+
+COMPILE_ASSERT(sizeof(CreateTexture3d) == 20,
+               Sizeof_CreateTexture3d_is_not_20);
+COMPILE_ASSERT(offsetof(CreateTexture3d, header) == 0,
+               OffsetOf_CreateTexture3d_header_not_0);
+COMPILE_ASSERT(offsetof(CreateTexture3d, texture_id) == 4,
+               OffsetOf_CreateTexture3d_texture_id_not_4);
+COMPILE_ASSERT(offsetof(CreateTexture3d, fixme1) == 8,
+               OffsetOf_CreateTexture3d_fixme1_not_8);
+COMPILE_ASSERT(offsetof(CreateTexture3d, fixme2) == 12,
+               OffsetOf_CreateTexture3d_fixme2_not_12);
+COMPILE_ASSERT(offsetof(CreateTexture3d, fixme3) == 16,
+               OffsetOf_CreateTexture3d_fixme3_not_16);
+
+struct CreateTextureCube {
+  typedef CreateTextureCube ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateTextureCube;
+  static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _texture_id,
+            uint32 _edge_length, uint32 _levels, uint32 _format,
+            uint32 _enable_render_surfaces) {
+    SetHeader();
+    texture_id = _texture_id;
+    edge_length = _edge_length;
+    fixme2 =
+        create_texture_2d_cmd::Levels::MakeValue(_levels) |
+        create_texture_2d_cmd::Format::MakeValue(_format) |
+        create_texture_2d_cmd::Flags::MakeValue(_enable_render_surfaces);
+  }
+
+  static void* Set(void* cmd, uint32 texture_id,
+                   uint32 edge_length, uint32 levels, uint32 format,
+                   uint32 enable_render_surfaces) {
+    static_cast<ValueType*>(cmd)->Init(texture_id,
+                                       edge_length, levels, format,
+                                       enable_render_surfaces);
+    return NextCmdAddress<ValueType>(cmd);
+  }
 
-struct CREATE_TEXTURE_CUBE {
-  static const CommandId kCmdId = command_buffer::CREATE_TEXTURE_CUBE;
-  static const ArgFlags kArgFlags = kAtLeastN;
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
+  uint32 texture_id;
+  uint32 edge_length;
+  uint32 fixme2;
 };
 
-struct SET_TEXTURE_DATA {
-  static const CommandId kCmdId = command_buffer::SET_TEXTURE_DATA;
-  static const ArgFlags kArgFlags = kAtLeastN;
+COMPILE_ASSERT(sizeof(CreateTextureCube) == 16,
+               Sizeof_CreateTextureCube_is_not_16);
+COMPILE_ASSERT(offsetof(CreateTextureCube, header) == 0,
+               OffsetOf_CreateTextureCube_header_not_0);
+COMPILE_ASSERT(offsetof(CreateTextureCube, texture_id) == 4,
+               OffsetOf_CreateTextureCube_texture_id_not_4);
+COMPILE_ASSERT(offsetof(CreateTextureCube, edge_length) == 8,
+               OffsetOf_CreateTextureCube_edge_length_not_8);
+COMPILE_ASSERT(offsetof(CreateTextureCube, fixme2) == 12,
+               OffsetOf_CreateTextureCube_fixme2_not_12);
+
+struct SetTextureData {
+  typedef SetTextureData ValueType;
+  static const CommandId kCmdId = command_buffer::kSetTextureData;
+  static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(
+      uint32 _texture_id,
+      uint32 _x,
+      uint32 _y,
+      uint32 _z,
+      uint32 _width,
+      uint32 _height,
+      uint32 _depth,
+      uint32 _level,
+      uint32 _face,
+      uint32 _row_pitch,
+      uint32 _slice_pitch,
+      uint32 _size,
+      uint32 shared_memory_id,
+      uint32 shared_memory_offset) {
+    SetHeader();
+    texture_id = _texture_id;
+    fixme1 =
+        set_texture_data_cmd::X::MakeValue(_x) |
+        set_texture_data_cmd::Y::MakeValue(_y);
+    fixme2 =
+        set_texture_data_cmd::Width::MakeValue(_width) |
+        set_texture_data_cmd::Height::MakeValue(_height);
+    fixme3 =
+        set_texture_data_cmd::Z::MakeValue(_z) |
+        set_texture_data_cmd::Depth::MakeValue(_depth);
+    fixme4 =
+        set_texture_data_cmd::Level::MakeValue(_level) |
+        set_texture_data_cmd::Face::MakeValue(_face);
+    row_pitch = _row_pitch;
+    slice_pitch = _slice_pitch;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(
+      void* cmd,
+      uint32 texture_id,
+      uint32 x,
+      uint32 y,
+      uint32 z,
+      uint32 width,
+      uint32 height,
+      uint32 depth,
+      uint32 level,
+      uint32 face,
+      uint32 row_pitch,
+      uint32 slice_pitch,
+      uint32 size,
+      uint32 shared_memory_id,
+      uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(
+        texture_id,
+        x,
+        y,
+        z,
+        width,
+        height,
+        depth,
+        level,
+        face,
+        row_pitch,
+        slice_pitch,
+        size,
+        shared_memory_id,
+        shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
+  uint32 texture_id;
+  uint32 fixme1;
+  uint32 fixme2;
+  uint32 fixme3;
+  uint32 fixme4;
+  uint32 row_pitch;
+  uint32 slice_pitch;
+  uint32 size;
+  SharedMemory shared_memory;
 };
 
-struct SET_TEXTURE_DATA_IMMEDIATE {
-  static const CommandId kCmdId = command_buffer::SET_TEXTURE_DATA_IMMEDIATE;
+COMPILE_ASSERT(sizeof(SetTextureData) == 44,
+               Sizeof_SetTextureData_is_not_44);
+COMPILE_ASSERT(offsetof(SetTextureData, header) == 0,
+               OffsetOf_SetTextureData_header_not_0);
+COMPILE_ASSERT(offsetof(SetTextureData, texture_id) == 4,
+               OffsetOf_SetTextureData_texture_id_not_4);
+COMPILE_ASSERT(offsetof(SetTextureData, fixme1) == 8,
+               OffsetOf_SetTextureData_fixme1_not_8);
+COMPILE_ASSERT(offsetof(SetTextureData, fixme2) == 12,
+               OffsetOf_SetTextureData_fixme2_not_12);
+COMPILE_ASSERT(offsetof(SetTextureData, fixme3) == 16,
+               OffsetOf_SetTextureData_fixme3_not_16);
+COMPILE_ASSERT(offsetof(SetTextureData, fixme4) == 20,
+               OffsetOf_SetTextureData_fixme4_not_20);
+COMPILE_ASSERT(offsetof(SetTextureData, row_pitch) == 24,
+               OffsetOf_SetTextureData_row_pitch_not_24);
+COMPILE_ASSERT(offsetof(SetTextureData, slice_pitch) == 28,
+               OffsetOf_SetTextureData_slice_pitch_not_28);
+COMPILE_ASSERT(offsetof(SetTextureData, size) == 32,
+               OffsetOf_SetTextureData_size_not_32);
+COMPILE_ASSERT(offsetof(SetTextureData, shared_memory) == 36,
+               OffsetOf_SetTextureData_shared_memory_not_36);
+
+struct SetTextureDataImmediate {
+  typedef SetTextureDataImmediate ValueType;
+  static const CommandId kCmdId = command_buffer::kSetTextureDataImmediate;
   static const ArgFlags kArgFlags = kAtLeastN;
+
+  void SetHeader(uint32 size) {
+    header.SetCmdBySize<ValueType>(size);
+  }
+
+  void Init(
+      uint32 _texture_id,
+      uint32 _x,
+      uint32 _y,
+      uint32 _z,
+      uint32 _width,
+      uint32 _height,
+      uint32 _depth,
+      uint32 _level,
+      uint32 _face,
+      uint32 _row_pitch,
+      uint32 _slice_pitch,
+      uint32 _size,
+      const void* data) {
+    SetHeader(_size);
+    texture_id = _texture_id;
+    fixme1 =
+        set_texture_data_cmd::X::MakeValue(_x) |
+        set_texture_data_cmd::Y::MakeValue(_y);
+    fixme2 =
+        set_texture_data_cmd::Width::MakeValue(_width) |
+        set_texture_data_cmd::Height::MakeValue(_height);
+    fixme3 =
+        set_texture_data_cmd::Z::MakeValue(_z) |
+        set_texture_data_cmd::Depth::MakeValue(_depth);
+    fixme4 =
+        set_texture_data_cmd::Level::MakeValue(_level) |
+        set_texture_data_cmd::Face::MakeValue(_face);
+    row_pitch = _row_pitch;
+    slice_pitch = _slice_pitch;
+    size = _size;
+    memcpy(ImmediateDataAddress(this), data, _size);
+  }
+
+  static void* Set(
+      void* cmd,
+      uint32 texture_id,
+      uint32 x,
+      uint32 y,
+      uint32 z,
+      uint32 width,
+      uint32 height,
+      uint32 depth,
+      uint32 level,
+      uint32 face,
+      uint32 row_pitch,
+      uint32 slice_pitch,
+      uint32 size,
+      const void* data) {
+    static_cast<ValueType*>(cmd)->Init(
+        texture_id,
+        x,
+        y,
+        z,
+        width,
+        height,
+        depth,
+        level,
+        face,
+        row_pitch,
+        slice_pitch,
+        size,
+        data);
+    return NextImmediateCmdAddress<ValueType>(cmd, size);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
+  uint32 texture_id;
+  uint32 fixme1;
+  uint32 fixme2;
+  uint32 fixme3;
+  uint32 fixme4;
+  uint32 row_pitch;
+  uint32 slice_pitch;
+  uint32 size;
 };
 
-struct GET_TEXTURE_DATA {
-  static const CommandId kCmdId = command_buffer::GET_TEXTURE_DATA;
-  static const ArgFlags kArgFlags = kAtLeastN;
+COMPILE_ASSERT(sizeof(SetTextureDataImmediate) == 36,
+               Sizeof_SetTextureDataImmediate_is_not_36);
+COMPILE_ASSERT(offsetof(SetTextureDataImmediate, header) == 0,
+               OffsetOf_SetTextureDataImmediate_header_not_0);
+COMPILE_ASSERT(offsetof(SetTextureDataImmediate, texture_id) == 4,
+               OffsetOf_SetTextureDataImmediate_texture_id_not_4);
+COMPILE_ASSERT(offsetof(SetTextureDataImmediate, fixme1) == 8,
+               OffsetOf_SetTextureDataImmediate_fixme1_not_8);
+COMPILE_ASSERT(offsetof(SetTextureDataImmediate, fixme2) == 12,
+               OffsetOf_SetTextureDataImmediate_fixme2_not_12);
+COMPILE_ASSERT(offsetof(SetTextureDataImmediate, fixme3) == 16,
+               OffsetOf_SetTextureDataImmediate_fixme3_not_16);
+COMPILE_ASSERT(offsetof(SetTextureDataImmediate, fixme4) == 20,
+               OffsetOf_SetTextureDataImmediate_fixme4_not_20);
+COMPILE_ASSERT(offsetof(SetTextureDataImmediate, row_pitch) == 24,
+               OffsetOf_SetTextureDataImmediate_row_pitch_not_24);
+COMPILE_ASSERT(offsetof(SetTextureDataImmediate, slice_pitch) == 28,
+               OffsetOf_SetTextureDataImmediate_slice_pitch_not_28);
+COMPILE_ASSERT(offsetof(SetTextureDataImmediate, size) == 32,
+               OffsetOf_SetTextureDataImmediate_size_not_32);
+
+struct GetTextureData {
+  typedef GetTextureData ValueType;
+  static const CommandId kCmdId = command_buffer::kGetTextureData;
+  static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(
+      uint32 _texture_id,
+      uint32 _x,
+      uint32 _y,
+      uint32 _z,
+      uint32 _width,
+      uint32 _height,
+      uint32 _depth,
+      uint32 _level,
+      uint32 _face,
+      uint32 _row_pitch,
+      uint32 _slice_pitch,
+      uint32 _size,
+      uint32 shared_memory_id,
+      uint32 shared_memory_offset) {
+    SetHeader();
+    texture_id = _texture_id;
+    fixme1 =
+        set_texture_data_cmd::X::MakeValue(_x) |
+        set_texture_data_cmd::Y::MakeValue(_y);
+    fixme2 =
+        set_texture_data_cmd::Width::MakeValue(_width) |
+        set_texture_data_cmd::Height::MakeValue(_height);
+    fixme3 =
+        set_texture_data_cmd::Z::MakeValue(_z) |
+        set_texture_data_cmd::Depth::MakeValue(_depth);
+    fixme4 =
+        set_texture_data_cmd::Level::MakeValue(_level) |
+        set_texture_data_cmd::Face::MakeValue(_face);
+    row_pitch = _row_pitch;
+    slice_pitch = _slice_pitch;
+    size = _size;
+    shared_memory.Init(shared_memory_id, shared_memory_offset);
+  }
+
+  static void* Set(
+      void* cmd,
+      uint32 texture_id,
+      uint32 x,
+      uint32 y,
+      uint32 z,
+      uint32 width,
+      uint32 height,
+      uint32 depth,
+      uint32 level,
+      uint32 face,
+      uint32 row_pitch,
+      uint32 slice_pitch,
+      uint32 size,
+      uint32 shared_memory_id,
+      uint32 shared_memory_offset) {
+    static_cast<ValueType*>(cmd)->Init(
+        texture_id,
+        x,
+        y,
+        z,
+        width,
+        height,
+        depth,
+        level,
+        face,
+        row_pitch,
+        slice_pitch,
+        size,
+        shared_memory_id,
+        shared_memory_offset);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
+  uint32 texture_id;
+  uint32 fixme1;
+  uint32 fixme2;
+  uint32 fixme3;
+  uint32 fixme4;
+  uint32 row_pitch;
+  uint32 slice_pitch;
+  uint32 size;
+  SharedMemory shared_memory;
 };
 
-struct CREATE_SAMPLER {
-  static const CommandId kCmdId = command_buffer::CREATE_SAMPLER;
+COMPILE_ASSERT(sizeof(GetTextureData) == 44,
+               Sizeof_GetTextureData_is_not_44);
+COMPILE_ASSERT(offsetof(GetTextureData, header) == 0,
+               OffsetOf_GetTextureData_header_not_0);
+COMPILE_ASSERT(offsetof(GetTextureData, texture_id) == 4,
+               OffsetOf_GetTextureData_texture_id_not_4);
+COMPILE_ASSERT(offsetof(GetTextureData, fixme1) == 8,
+               OffsetOf_GetTextureData_fixme1_not_8);
+COMPILE_ASSERT(offsetof(GetTextureData, fixme2) == 12,
+               OffsetOf_GetTextureData_fixme2_not_12);
+COMPILE_ASSERT(offsetof(GetTextureData, fixme3) == 16,
+               OffsetOf_GetTextureData_fixme3_not_16);
+COMPILE_ASSERT(offsetof(GetTextureData, fixme4) == 20,
+               OffsetOf_GetTextureData_fixme4_not_20);
+COMPILE_ASSERT(offsetof(GetTextureData, row_pitch) == 24,
+               OffsetOf_GetTextureData_row_pitch_not_24);
+COMPILE_ASSERT(offsetof(GetTextureData, slice_pitch) == 28,
+               OffsetOf_GetTextureData_slice_pitch_not_28);
+COMPILE_ASSERT(offsetof(GetTextureData, size) == 32,
+               OffsetOf_GetTextureData_size_not_32);
+COMPILE_ASSERT(offsetof(GetTextureData, shared_memory) == 36,
+               OffsetOf_GetTextureData_shared_memory_not_36);
+
+struct CreateSampler {
+  typedef CreateSampler ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateSampler;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct DESTROY_SAMPLER {
-  static const CommandId kCmdId = command_buffer::DESTROY_SAMPLER;
+COMPILE_ASSERT(sizeof(CreateSampler) == 8, Sizeof_CreateSampler_is_not_8);
+COMPILE_ASSERT(offsetof(CreateSampler, header) == 0,
+               OffsetOf_CreateSampler_header_not_0);
+COMPILE_ASSERT(offsetof(CreateSampler, id) == 4,
+               OffsetOf_CreateSampler_id_not_4);
+
+struct DestroySampler {
+  typedef DestroySampler ValueType;
+  static const CommandId kCmdId = command_buffer::kDestroySampler;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct SET_SAMPLER_STATES {
-  static const CommandId kCmdId = command_buffer::SET_SAMPLER_STATES;
-  static const ArgFlags kArgFlags = kAtLeastN;
+COMPILE_ASSERT(sizeof(DestroySampler) == 8, Sizeof_DestroySampler_is_not_8);
+COMPILE_ASSERT(offsetof(DestroySampler, header) == 0,
+               OffsetOf_DestroySampler_header_not_0);
+COMPILE_ASSERT(offsetof(DestroySampler, id) == 4,
+               OffsetOf_DestroySampler_id_not_4);
+
+struct SetSamplerStates {
+  typedef SetSamplerStates ValueType;
+  static const CommandId kCmdId = command_buffer::kSetSamplerStates;
+  static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(
+      uint32 _id,
+      uint32 _address_u_value,
+      uint32 _address_v_value,
+      uint32 _address_w_value,
+      uint32 _mag_filter_value,
+      uint32 _min_filter_value,
+      uint32 _mip_filter_value,
+      uint32 _max_anisotropy) {
+    SetHeader();
+    id = _id;
+    fixme1 =
+        set_sampler_states::AddressingU::MakeValue(_address_u_value) |
+        set_sampler_states::AddressingV::MakeValue(_address_v_value) |
+        set_sampler_states::AddressingW::MakeValue(_address_w_value) |
+        set_sampler_states::MagFilter::MakeValue(_mag_filter_value) |
+        set_sampler_states::MinFilter::MakeValue(_min_filter_value) |
+        set_sampler_states::MipFilter::MakeValue(_mip_filter_value) |
+        set_sampler_states::MaxAnisotropy::MakeValue(_max_anisotropy);
+  }
+
+  static void* Set(void* cmd,
+      uint32 id,
+      uint32 address_u_value,
+      uint32 address_v_value,
+      uint32 address_w_value,
+      uint32 mag_filter_value,
+      uint32 min_filter_value,
+      uint32 mip_filter_value,
+      uint32 max_anisotropy) {
+    static_cast<ValueType*>(cmd)->Init(
+        id,
+        address_u_value,
+        address_v_value,
+        address_w_value,
+        mag_filter_value,
+        min_filter_value,
+        mip_filter_value,
+        max_anisotropy);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
+  uint32 id;
+  uint32 fixme1;
 };
 
-struct SET_SAMPLER_BORDER_COLOR {
-  static const CommandId kCmdId = command_buffer::SET_SAMPLER_BORDER_COLOR;
+COMPILE_ASSERT(sizeof(SetSamplerStates) == 12,
+               Sizeof_SetSamplerStates_is_not_12);
+COMPILE_ASSERT(offsetof(SetSamplerStates, header) == 0,
+               OffsetOf_SetSamplerStates_header_not_0);
+COMPILE_ASSERT(offsetof(SetSamplerStates, id) == 4,
+               OffsetOf_SetSamplerStates_id_not_4);
+COMPILE_ASSERT(offsetof(SetSamplerStates, fixme1) == 8,
+               OffsetOf_SetSamplerStates_fixme1_not_8);
+
+struct SetSamplerBorderColor {
+  typedef SetSamplerBorderColor ValueType;
+  static const CommandId kCmdId = command_buffer::kSetSamplerBorderColor;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id,
+            float _red, float _green, float _blue, float _alpha) {
+    SetHeader();
+    id = _id;
+    red = _red;
+    green = _green;
+    blue = _blue;
+    alpha = _alpha;
+  }
+
+  static void* Set(void* cmd, uint32 id,
+                   float red, float green, float blue, float alpha) {
+    static_cast<ValueType*>(cmd)->Init(id, red, green, blue, alpha);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   float red;
   float blue;
@@ -710,127 +2567,725 @@ struct SET_SAMPLER_BORDER_COLOR {
   float alpha;
 };
 
-struct SET_SAMPLER_TEXTURE {
-  static const CommandId kCmdId = command_buffer::SET_SAMPLER_TEXTURE;
+COMPILE_ASSERT(sizeof(SetSamplerBorderColor) == 24,
+               Sizeof_SetSamplerBorderColor_is_not_24);
+COMPILE_ASSERT(offsetof(SetSamplerBorderColor, header) == 0,
+               OffsetOf_SetSamplerBorderColor_header_not_0);
+COMPILE_ASSERT(offsetof(SetSamplerBorderColor, id) == 4,
+               OffsetOf_SetSamplerBorderColor_id_not_4);
+COMPILE_ASSERT(offsetof(SetSamplerBorderColor, red) == 8,
+               OffsetOf_SetSamplerBorderColor_red_not_8);
+COMPILE_ASSERT(offsetof(SetSamplerBorderColor, blue) == 12,
+               OffsetOf_SetSamplerBorderColor_blue_not_12);
+COMPILE_ASSERT(offsetof(SetSamplerBorderColor, green) == 16,
+               OffsetOf_SetSamplerBorderColor_green_not_16);
+COMPILE_ASSERT(offsetof(SetSamplerBorderColor, alpha) == 20,
+               OffsetOf_SetSamplerBorderColor_alpha_not_20);
+
+struct SetSamplerTexture {
+  typedef SetSamplerTexture ValueType;
+  static const CommandId kCmdId = command_buffer::kSetSamplerTexture;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _texture_id) {
+    SetHeader();
+    id = _id;
+    texture_id = _texture_id;
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 texture_id) {
+    static_cast<ValueType*>(cmd)->Init(id, texture_id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
   uint32 texture_id;
 };
 
-struct SET_SCISSOR {
-  static const CommandId kCmdId = command_buffer::SET_SCISSOR;
+COMPILE_ASSERT(sizeof(SetSamplerTexture) == 12,
+               Sizeof_SetSamplerTexture_is_not_12);
+COMPILE_ASSERT(offsetof(SetSamplerTexture, header) == 0,
+               OffsetOf_SetSamplerTexture_header_not_0);
+COMPILE_ASSERT(offsetof(SetSamplerTexture, id) == 4,
+               OffsetOf_SetSamplerTexture_id_not_4);
+COMPILE_ASSERT(offsetof(SetSamplerTexture, texture_id) == 8,
+               OffsetOf_SetSamplerTexture_texture_id_not_8);
+
+struct SetScissor {
+  typedef SetScissor ValueType;
+  static const CommandId kCmdId = command_buffer::kSetScissor;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _x,
+            uint32 _y,
+            uint32 _width,
+            uint32 _height,
+            bool _enable) {
+    SetHeader();
+    fixme0 =
+        set_scissor::X::MakeValue(_x) |
+        set_scissor::Y::MakeValue(_y) |
+        set_scissor::Enable::MakeValue(_enable ? 1 : 0);
+    fixme1 =
+      set_scissor::Width::MakeValue(_width) |
+      set_scissor::Height::MakeValue(_height);
+  }
+
+  static void* Set(
+      void* cmd,
+      uint32 x,
+      uint32 y,
+      uint32 width,
+      uint32 height,
+      bool enable) {
+    static_cast<ValueType*>(cmd)->Init(
+        x,
+        y,
+        width,
+        height,
+        enable);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
   uint32 fixme0;
   uint32 fixme1;
 };
 
-struct SET_POLYGON_OFFSET {
-  static const CommandId kCmdId = command_buffer::SET_POLYGON_OFFSET;
+COMPILE_ASSERT(sizeof(SetScissor) == 12, Sizeof_SetScissor_is_not_12);
+COMPILE_ASSERT(offsetof(SetScissor, header) == 0,
+               OffsetOf_SetScissor_header_not_0);
+COMPILE_ASSERT(offsetof(SetScissor, fixme0) == 4,
+               OffsetOf_SetScissor_fixme0_not_4);
+COMPILE_ASSERT(offsetof(SetScissor, fixme1) == 8,
+               OffsetOf_SetScissor_fixme1_not_8);
+
+struct SetPolygonOffset {
+  typedef SetPolygonOffset ValueType;
+  static const CommandId kCmdId = command_buffer::kSetPolygonOffset;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(float _slope_factor, float _units) {
+    SetHeader();
+    slope_factor = _slope_factor;
+    units = _units;
+  }
+
+  static void* Set(void* cmd, float slope_factor, float units) {
+    static_cast<ValueType*>(cmd)->Init(slope_factor, units);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   float slope_factor;
   float units;
 };
 
-struct SET_POINT_LINE_RASTER {
-  static const CommandId kCmdId = command_buffer::SET_POINT_LINE_RASTER;
+COMPILE_ASSERT(sizeof(SetPolygonOffset) == 12,
+               Sizeof_SetPolygonOffset_is_not_12);
+COMPILE_ASSERT(offsetof(SetPolygonOffset, header) == 0,
+               OffsetOf_SetPolygonOffset_header_not_0);
+COMPILE_ASSERT(offsetof(SetPolygonOffset, slope_factor) == 4,
+               OffsetOf_SetPolygonOffset_slope_factor_not_4);
+COMPILE_ASSERT(offsetof(SetPolygonOffset, units) == 8,
+               OffsetOf_SetPolygonOffset_units_not_8);
+
+struct SetPointLineRaster {
+  typedef SetPointLineRaster ValueType;
+  static const CommandId kCmdId = command_buffer::kSetPointLineRaster;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(bool _line_smooth_enable, bool _point_sprite_enable,
+            float _point_size) {
+    SetHeader();
+    fixme0 =
+        set_point_line_raster::LineSmoothEnable::MakeValue(
+            _line_smooth_enable ? 1 : 0) |
+        set_point_line_raster::PointSpriteEnable::MakeValue(
+            _point_sprite_enable ? 1 : 0);
+    point_size = _point_size;
+  }
+
+  static void* Set(void* cmd, bool line_smooth_enable, bool point_sprite_enable,
+                   float point_size) {
+    static_cast<ValueType*>(cmd)->Init(line_smooth_enable, point_sprite_enable,
+                                       point_size);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
   uint32 fixme0;
   float point_size;
 };
 
-struct SET_POLYGON_RASTER {
-  static const CommandId kCmdId = command_buffer::SET_POLYGON_RASTER;
+COMPILE_ASSERT(sizeof(SetPointLineRaster) == 12,
+               Sizeof_SetPointLineRaster_is_not_12);
+COMPILE_ASSERT(offsetof(SetPointLineRaster, header) == 0,
+               OffsetOf_SetPointLineRaster_header_not_0);
+COMPILE_ASSERT(offsetof(SetPointLineRaster, fixme0) == 4,
+               OffsetOf_SetPointLineRaster_fixme0_not_4);
+COMPILE_ASSERT(offsetof(SetPointLineRaster, point_size) == 8,
+               OffsetOf_SetPointLineRaster_point_size_not_8);
+
+struct SetPolygonRaster {
+  typedef SetPolygonRaster ValueType;
+  static const CommandId kCmdId = command_buffer::kSetPolygonRaster;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _fill_mode, uint32 _cull_mode) {
+    SetHeader();
+    fixme0 =
+        set_polygon_raster::FillMode::MakeValue(_fill_mode) |
+        set_polygon_raster::CullMode::MakeValue(_cull_mode);
+  }
+
+  static void* Set(void* cmd, uint32 fill_mode, uint32 cull_mode) {
+    static_cast<ValueType*>(cmd)->Init(fill_mode, cull_mode);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
   uint32 fixme0;
 };
 
-struct SET_ALPHA_TEST {
-  static const CommandId kCmdId = command_buffer::SET_ALPHA_TEST;
+COMPILE_ASSERT(sizeof(SetPolygonRaster) == 8,
+               Sizeof_SetPolygonRaster_is_not_8);
+COMPILE_ASSERT(offsetof(SetPolygonRaster, header) == 0,
+               OffsetOf_SetPolygonRaster_header_not_0);
+COMPILE_ASSERT(offsetof(SetPolygonRaster, fixme0) == 4,
+               OffsetOf_SetPolygonRaster_fixme0_not_4);
+
+struct SetAlphaTest {
+  typedef SetAlphaTest ValueType;
+  static const CommandId kCmdId = command_buffer::kSetAlphaTest;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _func, bool _enable, float _value) {
+    SetHeader();
+    fixme0 =
+        set_alpha_test::Func::MakeValue(_func) |
+        set_alpha_test::Enable::MakeValue(_enable ? 1 : 0);
+    value = _value;
+  }
+
+  static void* Set(void* cmd, uint32 func, bool enable, float value) {
+    static_cast<ValueType*>(cmd)->Init(func, enable, value);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
   uint32 fixme0;
   float value;
 };
 
-struct SET_DEPTH_TEST {
-  static const CommandId kCmdId = command_buffer::SET_DEPTH_TEST;
+COMPILE_ASSERT(sizeof(SetAlphaTest) == 12, Sizeof_SetAlphaTest_is_not_12);
+COMPILE_ASSERT(offsetof(SetAlphaTest, header) == 0,
+               OffsetOf_SetAlphaTest_header_not_0);
+COMPILE_ASSERT(offsetof(SetAlphaTest, fixme0) == 4,
+               OffsetOf_SetAlphaTest_fixme0_not_4);
+COMPILE_ASSERT(offsetof(SetAlphaTest, value) == 8,
+               OffsetOf_SetAlphaTest_value_not_8);
+
+struct SetDepthTest {
+  typedef SetDepthTest ValueType;
+  static const CommandId kCmdId = command_buffer::kSetDepthTest;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _func, bool _write_enable, bool _enable) {
+    SetHeader();
+    fixme0 =
+        set_depth_test::Func::MakeValue(_func) |
+        set_depth_test::WriteEnable::MakeValue(_write_enable ? 1 : 0) |
+        set_depth_test::Enable::MakeValue(_enable ? 1 : 0);
+  }
+
+  static void* Set(void* cmd, uint32 func, bool write_enable, bool enable) {
+    static_cast<ValueType*>(cmd)->Init(func, write_enable, enable);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
   uint32 fixme0;
 };
 
-struct SET_STENCIL_TEST {
-  static const CommandId kCmdId = command_buffer::SET_STENCIL_TEST;
-  static const ArgFlags kArgFlags = kAtLeastN;
+COMPILE_ASSERT(sizeof(SetDepthTest) == 8, Sizeof_SetDepthTest_is_not_8);
+COMPILE_ASSERT(offsetof(SetDepthTest, header) == 0,
+               OffsetOf_SetDepthTest_header_not_0);
+COMPILE_ASSERT(offsetof(SetDepthTest, fixme0) == 4,
+               OffsetOf_SetDepthTest_fixme0_not_4);
+
+struct SetStencilTest {
+  typedef SetStencilTest ValueType;
+  static const CommandId kCmdId = command_buffer::kSetStencilTest;
+  static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint8 _write_mask,
+            uint8 _compare_mask,
+            uint8 _reference_value,
+            bool _separate_ccw,
+            bool _enable,
+            uint8 _cw_func,
+            uint8 _cw_pass_op,
+            uint8 _cw_fail_op,
+            uint8 _cw_z_fail_op,
+            uint8 _ccw_func,
+            uint8 _ccw_pass_op,
+            uint8 _ccw_fail_op,
+            uint8 _ccw_z_fail_op) {
+    SetHeader();
+    fixme0 =
+        set_stencil_test::WriteMask::MakeValue(_write_mask) |
+        set_stencil_test::CompareMask::MakeValue(_compare_mask) |
+        set_stencil_test::ReferenceValue::MakeValue(_reference_value) |
+        set_stencil_test::SeparateCCW::MakeValue(_separate_ccw ? 1 : 0) |
+        set_stencil_test::Enable::MakeValue(_enable ? 1 : 0);
+    fixme1 =
+        set_stencil_test::CWFunc::MakeValue(_cw_func) |
+        set_stencil_test::CWPassOp::MakeValue(_cw_pass_op) |
+        set_stencil_test::CWFailOp::MakeValue(_cw_fail_op) |
+        set_stencil_test::CWZFailOp::MakeValue(_cw_z_fail_op) |
+        set_stencil_test::CCWFunc::MakeValue(_ccw_func) |
+        set_stencil_test::CCWPassOp::MakeValue(_ccw_pass_op) |
+        set_stencil_test::CCWFailOp::MakeValue(_ccw_fail_op) |
+        set_stencil_test::CCWZFailOp::MakeValue(_ccw_z_fail_op);
+  }
+
+  static void* Set(
+      void* cmd,
+      uint8 write_mask,
+      uint8 compare_mask,
+      uint8 reference_value,
+      bool separate_ccw,
+      bool enable,
+      uint8 cw_func,
+      uint8 cw_pass_op,
+      uint8 cw_fail_op,
+      uint8 cw_z_fail_op,
+      uint8 ccw_func,
+      uint8 ccw_pass_op,
+      uint8 ccw_fail_op,
+      uint8 ccw_z_fail_op) {
+    static_cast<ValueType*>(cmd)->Init(
+        write_mask,
+        compare_mask,
+        reference_value,
+        separate_ccw,
+        enable,
+        cw_func,
+        cw_pass_op,
+        cw_fail_op,
+        cw_z_fail_op,
+        ccw_func,
+        ccw_pass_op,
+        ccw_fail_op,
+        ccw_z_fail_op);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
+  uint32 fixme0;
+  uint32 fixme1;
 };
 
-struct SET_COLOR_WRITE {
-  static const CommandId kCmdId = command_buffer::SET_COLOR_WRITE;
+COMPILE_ASSERT(sizeof(SetStencilTest) == 12,
+               Sizeof_SetStencilTest_is_not_12);
+COMPILE_ASSERT(offsetof(SetStencilTest, header) == 0,
+               OffsetOf_SetStencilTest_header_not_0);
+COMPILE_ASSERT(offsetof(SetStencilTest, fixme0) == 4,
+               OffsetOf_SetStencilTest_fixme0_not_4);
+COMPILE_ASSERT(offsetof(SetStencilTest, fixme1) == 8,
+               OffsetOf_SetStencilTest_fixme1_not_8);
+
+struct SetColorWrite {
+  typedef SetColorWrite ValueType;
+  static const CommandId kCmdId = command_buffer::kSetColorWrite;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint8 _mask, bool _dither_enable) {
+    SetHeader();
+    flags =
+        set_color_write::RedMask::MakeValue((_mask | 0x01) != 0 ? 1 : 0) |
+        set_color_write::GreenMask::MakeValue((_mask | 0x02) != 0 ? 1 : 0) |
+        set_color_write::BlueMask::MakeValue((_mask | 0x02) != 0 ? 1 : 0) |
+        set_color_write::AlphaMask::MakeValue((_mask | 0x02) != 0 ? 1 : 0) |
+        set_color_write::DitherEnable::MakeValue(_dither_enable ? 1 : 0);
+  }
+
+  static void* Set(void* cmd, uint8 mask, bool dither_enable) {
+    static_cast<ValueType*>(cmd)->Init(mask, dither_enable);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 flags;
 };
 
-struct SET_BLENDING {
-  static const CommandId kCmdId = command_buffer::SET_BLENDING;
-  static const ArgFlags kArgFlags = kAtLeastN;
+COMPILE_ASSERT(sizeof(SetColorWrite) == 8, Sizeof_SetColorWrite_is_not_8);
+COMPILE_ASSERT(offsetof(SetColorWrite, header) == 0,
+               OffsetOf_SetColorWrite_header_not_0);
+COMPILE_ASSERT(offsetof(SetColorWrite, flags) == 4,
+               OffsetOf_SetColorWrite_flags_not_4);
+
+struct SetBlending {
+  typedef SetBlending ValueType;
+  static const CommandId kCmdId = command_buffer::kSetBlending;
+  static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(
+      uint8 _color_src_func,
+      uint8 _color_dst_func,
+      uint8 _color_eq,
+      uint8 _alpha_src_func,
+      uint8 _alpha_dst_func,
+      uint8 _alpha_eq,
+      bool _separate_alpha,
+      bool _enable) {
+    SetHeader();
+    fixme0 =
+        set_blending::ColorSrcFunc::MakeValue(_color_src_func) |
+        set_blending::ColorDstFunc::MakeValue(_color_dst_func) |
+        set_blending::ColorEq::MakeValue(_color_eq) |
+        set_blending::AlphaSrcFunc::MakeValue(_alpha_src_func) |
+        set_blending::AlphaDstFunc::MakeValue(_alpha_dst_func) |
+        set_blending::AlphaEq::MakeValue(_alpha_eq) |
+        set_blending::SeparateAlpha::MakeValue(_separate_alpha ? 1 : 0) |
+        set_blending::Enable::MakeValue(_enable ? 1 : 0);
+  }
+
+  static void* Set(
+      void* cmd,
+      uint8 color_src_func,
+      uint8 color_dst_func,
+      uint8 color_eq,
+      uint8 alpha_src_func,
+      uint8 alpha_dst_func,
+      uint8 alpha_eq,
+      bool separate_alpha,
+      bool enable) {
+    static_cast<ValueType*>(cmd)->Init(
+        color_src_func,
+        color_dst_func,
+        color_eq,
+        alpha_src_func,
+        alpha_dst_func,
+        alpha_eq,
+        separate_alpha,
+        enable);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
+  uint32 fixme0;
 };
 
-struct SET_BLENDING_COLOR {
-  static const CommandId kCmdId = command_buffer::SET_BLENDING_COLOR;
+COMPILE_ASSERT(sizeof(SetBlending) == 8, Sizeof_SetBlending_is_not_8);
+COMPILE_ASSERT(offsetof(SetBlending, header) == 0,
+               OffsetOf_SetBlending_header_not_0);
+COMPILE_ASSERT(offsetof(SetBlending, fixme0) == 4,
+               OffsetOf_SetBlending_fixme0_not_4);
+
+struct SetBlendingColor {
+  typedef SetBlendingColor ValueType;
+  static const CommandId kCmdId = command_buffer::kSetBlendingColor;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(float _red, float _green, float _blue, float _alpha) {
+    SetHeader();
+    red = _red;
+    green = _green;
+    blue = _blue;
+    alpha = _alpha;
+  }
+
+  static void* Set(void* cmd,
+                   float red, float green, float blue, float alpha) {
+    static_cast<ValueType*>(cmd)->Init(red, green, blue, alpha);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   float red;
   float blue;
   float green;
   float alpha;
 };
 
-struct CREATE_RENDER_SURFACE {
-  static const CommandId kCmdId = command_buffer::CREATE_RENDER_SURFACE;
+COMPILE_ASSERT(sizeof(SetBlendingColor) == 20,
+               Sizeof_SetBlendingColor_is_not_20);
+COMPILE_ASSERT(offsetof(SetBlendingColor, header) == 0,
+               OffsetOf_SetBlendingColor_header_not_0);
+COMPILE_ASSERT(offsetof(SetBlendingColor, red) == 4,
+               OffsetOf_SetBlendingColor_red_not_4);
+COMPILE_ASSERT(offsetof(SetBlendingColor, blue) == 8,
+               OffsetOf_SetBlendingColor_blue_not_8);
+COMPILE_ASSERT(offsetof(SetBlendingColor, green) == 12,
+               OffsetOf_SetBlendingColor_green_not_12);
+COMPILE_ASSERT(offsetof(SetBlendingColor, alpha) == 16,
+               OffsetOf_SetBlendingColor_alpha_not_16);
+
+struct CreateRenderSurface {
+  typedef CreateRenderSurface ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateRenderSurface;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _texture_id, uint32 _width, uint32 _height,
+            uint32 _level, uint32 _side) {
+    SetHeader();
+    id = _id;
+    // TODO(gman): Why does this need a width and height. It's inherited from
+    // the texture isn't it?
+    fixme1 =
+        create_render_surface_cmd::Width::MakeValue(_width) |
+        create_render_surface_cmd::Height::MakeValue(_height);
+    fixme2 =
+        create_render_surface_cmd::Levels::MakeValue(_level) |
+        create_render_surface_cmd::Side::MakeValue(_side);
+    texture_id = _texture_id;
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 texture_id,
+                   uint32 width, uint32 height,
+                   uint32 level, uint32 side) {
+    static_cast<ValueType*>(cmd)->Init(id, texture_id, width, height,
+                                       level, side);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
   uint32 id;
   uint32 fixme1;
   uint32 fixme2;
   uint32 texture_id;
 };
 
-struct DESTROY_RENDER_SURFACE {
-  static const CommandId kCmdId = command_buffer::DESTROY_RENDER_SURFACE;
+COMPILE_ASSERT(sizeof(CreateRenderSurface) == 20,
+               Sizeof_CreateRenderSurface_is_not_20);
+COMPILE_ASSERT(offsetof(CreateRenderSurface, header) == 0,
+               OffsetOf_CreateRenderSurface_header_not_0);
+COMPILE_ASSERT(offsetof(CreateRenderSurface, id) == 4,
+               OffsetOf_CreateRenderSurface_id_not_4);
+COMPILE_ASSERT(offsetof(CreateRenderSurface, fixme1) == 8,
+               OffsetOf_CreateRenderSurface_fixme1_not_8);
+COMPILE_ASSERT(offsetof(CreateRenderSurface, fixme2) == 12,
+               OffsetOf_CreateRenderSurface_fixme2_not_12);
+COMPILE_ASSERT(offsetof(CreateRenderSurface, texture_id) == 16,
+               OffsetOf_CreateRenderSurface_texture_id_not_16);
+
+struct DestroyRenderSurface {
+  typedef DestroyRenderSurface ValueType;
+  static const CommandId kCmdId = command_buffer::kDestroyRenderSurface;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct CREATE_DEPTH_SURFACE {
-  static const CommandId kCmdId = command_buffer::CREATE_DEPTH_SURFACE;
+COMPILE_ASSERT(sizeof(DestroyRenderSurface) == 8,
+               Sizeof_DestroyRenderSurface_is_not_8);
+COMPILE_ASSERT(offsetof(DestroyRenderSurface, header) == 0,
+               OffsetOf_DestroyRenderSurface_header_not_0);
+COMPILE_ASSERT(offsetof(DestroyRenderSurface, id) == 4,
+               OffsetOf_DestroyRenderSurface_id_not_4);
+
+struct CreateDepthSurface {
+  typedef CreateDepthSurface ValueType;
+  static const CommandId kCmdId = command_buffer::kCreateDepthSurface;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id, uint32 _width, uint32 _height) {
+    SetHeader();
+    id = _id;
+    fixme1 =
+        create_depth_surface_cmd::Width::MakeValue(_width) |
+        create_depth_surface_cmd::Height::MakeValue(_height);
+  }
+
+  static void* Set(void* cmd, uint32 id, uint32 width, uint32 height) {
+    static_cast<ValueType*>(cmd)->Init(id, width, height);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
   // TODO(gman): fix this to not use obfusticated fields.
+  CommandHeader header;
   uint32 id;
   uint32 fixme1;
 };
 
-struct DESTROY_DEPTH_SURFACE {
-  static const CommandId kCmdId = command_buffer::DESTROY_DEPTH_SURFACE;
+COMPILE_ASSERT(sizeof(CreateDepthSurface) == 12,
+               Sizeof_CreateDepthSurface_is_not_12);
+COMPILE_ASSERT(offsetof(CreateDepthSurface, header) == 0,
+               OffsetOf_CreateDepthSurface_header_not_0);
+COMPILE_ASSERT(offsetof(CreateDepthSurface, id) == 4,
+               OffsetOf_CreateDepthSurface_id_not_4);
+COMPILE_ASSERT(offsetof(CreateDepthSurface, fixme1) == 8,
+               OffsetOf_CreateDepthSurface_fixme1_not_8);
+
+struct DestroyDepthSurface {
+  typedef DestroyDepthSurface ValueType;
+  static const CommandId kCmdId = command_buffer::kDestroyDepthSurface;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _id) {
+    SetHeader();
+    id = _id;
+  }
+
+  static void* Set(void* cmd, uint32 id) {
+    static_cast<ValueType*>(cmd)->Init(id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 id;
 };
 
-struct SET_RENDER_SURFACE {
-  static const CommandId kCmdId = command_buffer::SET_RENDER_SURFACE;
+COMPILE_ASSERT(sizeof(DestroyDepthSurface) == 8,
+               Sizeof_DestroyDepthSurface_is_not_8);
+COMPILE_ASSERT(offsetof(DestroyDepthSurface, header) == 0,
+               OffsetOf_DestroyDepthSurface_header_not_0);
+COMPILE_ASSERT(offsetof(DestroyDepthSurface, id) == 4,
+               OffsetOf_DestroyDepthSurface_id_not_4);
+
+struct SetRenderSurface {
+  typedef SetRenderSurface ValueType;
+  static const CommandId kCmdId = command_buffer::kSetRenderSurface;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init(uint32 _render_surface_id, uint32 _depth_surface_id) {
+    SetHeader();
+    render_surface_id = _render_surface_id;
+    depth_surface_id = _depth_surface_id;
+  }
+
+  static void* Set(void* cmd,
+                   uint32 render_surface_id, uint32 depth_surface_id) {
+    static_cast<ValueType*>(cmd)->Init(render_surface_id, depth_surface_id);
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
   uint32 render_surface_id;
   uint32 depth_surface_id;
 };
 
-struct SET_BACK_SURFACES {
-  static const CommandId kCmdId = command_buffer::SET_BACK_SURFACES;
+COMPILE_ASSERT(sizeof(SetRenderSurface) == 12,
+               Sizeof_SetRenderSurface_is_not_12);
+COMPILE_ASSERT(offsetof(SetRenderSurface, header) == 0,
+               OffsetOf_SetRenderSurface_header_not_0);
+COMPILE_ASSERT(offsetof(SetRenderSurface, render_surface_id) == 4,
+               OffsetOf_SetRenderSurface_render_surface_id_not_4);
+COMPILE_ASSERT(offsetof(SetRenderSurface, depth_surface_id) == 8,
+               OffsetOf_SetRenderSurface_depth_surface_id_not_8);
+
+struct SetBackSurfaces {
+  typedef SetBackSurfaces ValueType;
+  static const CommandId kCmdId = command_buffer::kSetBackSurfaces;
   static const ArgFlags kArgFlags = kFixed;
+
+  void SetHeader() {
+    header.SetCmd<ValueType>();
+  }
+
+  void Init() {
+    SetHeader();
+  }
+
+  static void* Set(void* cmd) {
+    static_cast<ValueType*>(cmd)->Init();
+    return NextCmdAddress<ValueType>(cmd);
+  }
+
+  CommandHeader header;
 };
 
+COMPILE_ASSERT(sizeof(SetBackSurfaces) == 4,
+               Sizeof_SetBackSurfaces_is_not_4);
+COMPILE_ASSERT(offsetof(SetBackSurfaces, header) == 0,
+               OffsetOf_SetBackSurfaces_header_not_0);
+
 O3D_POP_STRUCTURE_PACKING;
 
 }  // namespace cmd
diff --git a/o3d/command_buffer/common/cross/gapi_interface.h b/o3d/command_buffer/common/cross/gapi_interface.h
index fdf4b5e..1766428 100644
--- a/o3d/command_buffer/common/cross/gapi_interface.h
+++ b/o3d/command_buffer/common/cross/gapi_interface.h
@@ -180,8 +180,8 @@ class GAPIInterface {
   //   size: the size of the vertex buffer, in bytes.
   //   flags: the vertex buffer flags, as a combination of vertex_buffer::Flags
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateVertexBuffer(ResourceID id,
                                         unsigned int size,
                                         unsigned int flags) = 0;
@@ -190,8 +190,8 @@ class GAPIInterface {
   // Parameters:
   //   id: the resource ID of the vertex buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid vertex buffer
-  //   ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid vertex buffer
+  //   ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyVertexBuffer(ResourceID id) = 0;
 
   // Sets data into a vertex buffer.
@@ -201,9 +201,9 @@ class GAPIInterface {
   //   size: the size of the data.
   //   data: the source data.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments were
   //   passed: invalid resource ID, or offset or size out of range.
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetVertexBufferData(ResourceID id,
                                          unsigned int offset,
                                          unsigned int size,
@@ -216,9 +216,9 @@ class GAPIInterface {
   //   size: the size of the data.
   //   data: the destination buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments were
   //   passed: invalid resource ID, or offset or size out of range.
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError GetVertexBufferData(ResourceID id,
                                          unsigned int offset,
                                          unsigned int size,
@@ -232,8 +232,8 @@ class GAPIInterface {
   //          Note that indices are 16 bits unless the index_buffer::INDEX_32BIT
   //          flag is specified.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateIndexBuffer(ResourceID id,
                                        unsigned int size,
                                        unsigned int flags) = 0;
@@ -242,8 +242,8 @@ class GAPIInterface {
   // Parameters:
   //   id: the resource ID of the index buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid index buffer
-  //   ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid index buffer
+  //   ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyIndexBuffer(ResourceID id) = 0;
 
   // Sets data into an index buffer.
@@ -253,9 +253,9 @@ class GAPIInterface {
   //   size: the size of the data.
   //   data: the source data.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments were
   //   passed: invalid resource ID, or offset or size out of range.
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetIndexBufferData(ResourceID id,
                                         unsigned int offset,
                                         unsigned int size,
@@ -268,9 +268,9 @@ class GAPIInterface {
   //   size: the size of the data.
   //   data: the destination buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments were
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments were
   //   passed: invalid resource ID, or offset or size out of range.
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError GetIndexBufferData(ResourceID id,
                                         unsigned int offset,
                                         unsigned int size,
@@ -282,8 +282,8 @@ class GAPIInterface {
   //   id: the resource ID of the vertex struct.
   //   input_count: the number of input vertex attributes.
   // returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateVertexStruct(ResourceID id,
                                         unsigned int input_count) = 0;
 
@@ -291,8 +291,8 @@ class GAPIInterface {
   // Parameters:
   //   id: the resource ID of the vertex struct.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid vertex struct
-  //   ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid vertex struct
+  //   ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyVertexStruct(ResourceID id) = 0;
 
   // Sets an input into a vertex struct.
@@ -307,8 +307,8 @@ class GAPIInterface {
   //   semantic: the semantic of the input.
   //   semantic_index: the semantic index of the input.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetVertexInput(ResourceID vertex_struct_id,
                                     unsigned int input_index,
                                     ResourceID vertex_buffer_id,
@@ -322,8 +322,8 @@ class GAPIInterface {
   // Parameters:
   //   id: the resource ID of the vertex struct.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed (invalid vertex struct), BufferSyncInterface::PARSE_NO_ERROR
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed (invalid vertex struct), BufferSyncInterface::kParseNoError
   //   otherwise.
   virtual ParseError SetVertexStruct(ResourceID id) = 0;
 
@@ -333,8 +333,8 @@ class GAPIInterface {
   //   first: the index of the first vertex.
   //   count: the number of primitives to draw.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError Draw(PrimitiveType primitive_type,
                           unsigned int first,
                           unsigned int count) = 0;
@@ -349,8 +349,8 @@ class GAPIInterface {
   //   min_index: the lowest index being drawn.
   //   max_index: the highest index being drawn.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DrawIndexed(PrimitiveType primitive_type,
                                  ResourceID index_buffer_id,
                                  unsigned int first,
@@ -364,9 +364,9 @@ class GAPIInterface {
   //   size: the size of data.
   //   data: the source code for the effect.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed or the effect failed to compile,
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateEffect(ResourceID id,
                                   unsigned int size,
                                   const void *data) = 0;
@@ -375,16 +375,16 @@ class GAPIInterface {
   // Parameters:
   //   id: the resource ID of the effect.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid effect ID
-  //   was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid effect ID
+  //   was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyEffect(ResourceID id) = 0;
 
   // Sets the active effect for drawing.
   // Parameters:
   //   id: the resource ID of the effect.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetEffect(ResourceID id) = 0;
 
   // Gets the number of parameters in an effect, returning it in a memory
@@ -395,8 +395,8 @@ class GAPIInterface {
   //   Uint32).
   //   data: the buffer receiving the data.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError GetParamCount(ResourceID id,
                                    unsigned int size,
                                    void *data) = 0;
@@ -409,9 +409,9 @@ class GAPIInterface {
   //     the effect source.
   //   index: the index of the parameter.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, such as invalid effect ID, unmatching data type or invalid
-  //   index, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   index, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateParam(ResourceID param_id,
                                  ResourceID effect_id,
                                  unsigned int index) = 0;
@@ -426,9 +426,9 @@ class GAPIInterface {
   //   name: the parameter name, as an array of char. Doesn't have to be
   //     nul-terminated (though nul will terminate the string).
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, such as invalid effect ID, unmatching data type or no parameter
-  //   was found with this name, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   was found with this name, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateParamByName(ResourceID param_id,
                                        ResourceID effect_id,
                                        unsigned int size,
@@ -438,8 +438,8 @@ class GAPIInterface {
   // Parameters:
   //   id: the resource ID of the parameter.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid parameter ID
-  //   was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid parameter ID
+  //   was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyParam(ResourceID id) = 0;
 
   // Sets the effect parameter data.
@@ -448,9 +448,9 @@ class GAPIInterface {
   //   size: the size of the data. Must be at least the size of the parameter
   //     as described by its type.
   //   data: the parameter data.
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, such as invalid parameter ID, or unmatching data size,
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetParamData(ResourceID id,
                                   unsigned int size,
                                   const void *data) = 0;
@@ -470,10 +470,10 @@ class GAPIInterface {
   //     description. Must be at least sizeof(effect_param::Desc).
   //   data: the memory buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, such as invalid parameter ID, or unsufficient data size,
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise. Note that
-  //   BufferSyncInterface::PARSE_NO_ERROR will be returned if the structure
+  //   BufferSyncInterface::kParseNoError otherwise. Note that
+  //   BufferSyncInterface::kParseNoError will be returned if the structure
   //   itself fits, not necessarily the names. To make sure all the information
   //   is available, the caller should compare the returned size member of the
   //   effect_param::Desc structure to the size parameter passed in.
@@ -489,8 +489,8 @@ class GAPIInterface {
   //   Uint32).
   //   data: the buffer receiving the data.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError GetStreamCount(ResourceID id,
                                     unsigned int size,
                                     void *data) = 0;
@@ -520,8 +520,8 @@ class GAPIInterface {
   //   flags: the texture flags, as a combination of texture::Flags.
   //   enable_render_surfaces: bool for whether to enable render surfaces
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateTexture2D(ResourceID id,
                                      unsigned int width,
                                      unsigned int height,
@@ -542,8 +542,8 @@ class GAPIInterface {
   //   flags: the texture flags, as a combination of texture::Flags.
   //   enable_render_surfaces: bool for whether to enable render surfaces
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateTexture3D(ResourceID id,
                                      unsigned int width,
                                      unsigned int height,
@@ -563,8 +563,8 @@ class GAPIInterface {
   //   flags: the texture flags, as a combination of texture::Flags.
   //   enable_render_surfaces: bool for whether to enable render surfaces
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateTextureCube(ResourceID id,
                                        unsigned int side,
                                        unsigned int levels,
@@ -599,9 +599,9 @@ class GAPIInterface {
   //   size: the size of the data.
   //   data: the texel data.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, for example invalid size, or out-of-bounds rectangle/volume,
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetTextureData(ResourceID id,
                                     unsigned int x,
                                     unsigned int y,
@@ -643,9 +643,9 @@ class GAPIInterface {
   //   size: the size of the data.
   //   data: the destination buffer.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
   //   passed, for example invalid size, or out-of-bounds rectangle/volume,
-  //   BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError GetTextureData(ResourceID id,
                                     unsigned int x,
                                     unsigned int y,
@@ -664,23 +664,23 @@ class GAPIInterface {
   // Parameters:
   //   id: the resource ID of the texture.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid texture
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid texture
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyTexture(ResourceID id) = 0;
 
   // Creates a sampler resource.
   // Parameters:
   //   id: the resource ID of the sampler.
   // Returns:
-  //   BufferSyncInterface::PARSE_NO_ERROR.
+  //   BufferSyncInterface::kParseNoError.
   virtual ParseError CreateSampler(ResourceID id) = 0;
 
   // Destroys a sampler resource.
   // Parameters:
   //   id: the resource ID of the sampler.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid sampler
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroySampler(ResourceID id) = 0;
 
   // Sets the states in a sampler resource.
@@ -694,8 +694,8 @@ class GAPIInterface {
   //   mip_filter: the filtering mode for mip-map interpolation textures.
   //   max_anisotropy: the maximum anisotropy.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid sampler
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetSamplerStates(ResourceID id,
                                       sampler::AddressingMode addressing_u,
                                       sampler::AddressingMode addressing_v,
@@ -710,8 +710,8 @@ class GAPIInterface {
   //   id: the resource ID of the sampler.
   //   color: the border color.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid sampler
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetSamplerBorderColor(ResourceID id,
                                            const RGBA &color) = 0;
 
@@ -720,8 +720,8 @@ class GAPIInterface {
   //   id: the resource ID of the sampler.
   //   texture_id: the resource id of the texture.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid sampler
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid sampler
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetSamplerTexture(ResourceID id,
                                        ResourceID texture_id) = 0;
 
@@ -860,8 +860,8 @@ class GAPIInterface {
   //   height: the texture height. Must be positive.
   //   texture_id: the resource id of the texture.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateRenderSurface(ResourceID id,
                                          unsigned int width,
                                          unsigned int height,

@@ -873,9 +873,9 @@ class GAPIInterface {
   // Parameters:
   //   id: the resource ID of the render surface.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid render
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid render
   //     surface
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyRenderSurface(ResourceID id) = 0;
 
   // Creates a depth stencil surface resource.
@@ -884,8 +884,8 @@ class GAPIInterface {
   //   width: the texture width. Must be positive.
   //   height: the texture height. Must be positive.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError CreateDepthSurface(ResourceID id,
                                         unsigned int width,
                                         unsigned int height) = 0;
@@ -894,9 +894,9 @@ class GAPIInterface {
   // Parameters:
   //   id: the resource ID of the depth stencil surface.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if an invalid render
+  //   BufferSyncInterface::kParseInvalidArguments if an invalid render
   //     surface
-  //   resource ID was passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   resource ID was passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError DestroyDepthSurface(ResourceID id) = 0;
 
   // Switches the render surface and depth stencil surface to those
@@ -905,8 +905,8 @@ class GAPIInterface {
   //   render_surface_id: the resource ID of the render surface.
   //   depth_stencil_id: the resource ID of the render depth stencil surface.
   // Returns:
-  //   BufferSyncInterface::PARSE_INVALID_ARGUMENTS if invalid arguments are
-  //   passed, BufferSyncInterface::PARSE_NO_ERROR otherwise.
+  //   BufferSyncInterface::kParseInvalidArguments if invalid arguments are
+  //   passed, BufferSyncInterface::kParseNoError otherwise.
   virtual ParseError SetRenderSurface(ResourceID render_surface_id,
                                       ResourceID depth_stencil_id) = 0;
 
diff --git a/o3d/command_buffer/common/cross/resource.h b/o3d/command_buffer/common/cross/resource.h
index 5557d67..408f8ea 100644
--- a/o3d/command_buffer/common/cross/resource.h
+++ b/o3d/command_buffer/common/cross/resource.h
@@ -46,6 +46,7 @@ namespace o3d {
 namespace command_buffer {
 
 // A resource ID, key to the resource maps.
+// TODO(gman): Shouldn't this be a uint32?
 typedef unsigned int ResourceID;
 // Invalid resource ID.
 static const ResourceID kInvalidResource = 0xffffffffU;
diff --git a/o3d/command_buffer/samples/bubble/bubble_module.cc b/o3d/command_buffer/samples/bubble/bubble_module.cc
index 42eae04..b24a3d1 100644
--- a/o3d/command_buffer/samples/bubble/bubble_module.cc
+++ b/o3d/command_buffer/samples/bubble/bubble_module.cc
@@ -38,7 +38,7 @@
 #ifdef __native_demo__
 #include <sys/nacl_syscalls.h>
 #else
-#include "native_client/service_runtime/nrd_xfer_lib/nrd_all_modules.h"
+#include "native_client/src/shared/imc/nacl_imc.h"
 #endif
 #include "command_buffer/common/cross/gapi_interface.h"
 #include "command_buffer/common/cross/rpc_imc.h"
@@ -50,8 +50,7 @@
 #include "command_buffer/samples/bubble/perlin_noise.h"
 #include "third_party/vectormath/files/vectormathlibrary/include/vectormath/scalar/cpp/vectormath_aos.h"  // NOLINT
 
-#include "native_client/intermodule_comm/nacl_imc.h"
-#include "native_client/tools/npapi_runtime/nacl_npapi.h"
+#include "native_client/src/shared/npruntime/nacl_npapi.h"
 
 // Cube map data is hard-coded in cubemap.cc as a byte array.
 // Format is 64x64xBRGA, D3D face ordering (+X, -X, +Y, -Y, +Z, -Z).
@@ -68,7 +67,7 @@ const unsigned int kCubeMapFaceSize = kCubeMapWidth * kCubeMapHeight * 4;
     HELPER->Finish();                                                   \
     BufferSyncInterface::ParseError error =                             \
         HELPER->interface()->GetParseError();                           \
-    if (error != BufferSyncInterface::PARSE_NO_ERROR) {                 \
+    if (error != BufferSyncInterface::kParseNoError) {                 \
       printf("CMD error %d at %s:%d\n", error, __FILE__, __LINE__);     \
     }                                                                   \
   } while (false)
@@ -114,15 +113,8 @@ void ClearCmd(CommandBufferHelper *cmd_buffer,
               const RGBA &color,
               float depth,
               unsigned int stencil) {
-  CommandBufferEntry args[7];
-  args[0].value_uint32 = buffers;
-  args[1].value_float = color.red;
-  args[2].value_float = color.green;
-  args[3].value_float = color.blue;
-  args[4].value_float = color.alpha;
-  args[5].value_float = depth;
-  args[6].value_uint32 = stencil;
-  cmd_buffer->AddCommand(command_buffer::CLEAR, 7, args);
+  cmd_buffer->Clear(buffers, color.red, color.green, color.blue, color.alpha,
+                    depth, stencil);
   CHECK_ERROR(cmd_buffer);
 }
 
@@ -138,14 +130,7 @@ void SetViewportCmd(CommandBufferHelper *cmd_buffer,
                     unsigned int height,
                     float z_near,
                     float z_far) {
-  CommandBufferEntry args[6];
-  args[0].value_uint32 = x;
-  args[1].value_uint32 = y;
-  args[2].value_uint32 = width;
-  args[3].value_uint32 = height;
-  args[4].value_float = z_near;
-  args[5].value_float = z_far;
-  cmd_buffer->AddCommand(command_buffer::SET_VIEWPORT, 6, args);
+  cmd_buffer->SetViewport(x, y, width, height, z_near, z_far);
   CHECK_ERROR(cmd_buffer);
 }
 
@@ -311,9 +296,10 @@ void MakeNoiseTexture(unsigned int width,
 
 // Gets current time in microseconds.
 uint64_t GetTimeUsec() {
-  struct timeval tv;
-  gettimeofday(&tv, NULL);
-  return tv.tv_sec * 1000000ULL + tv.tv_usec;
+  return 0ULL;
+//  struct timeval tv;
+//  gettimeofday(&tv, NULL);
+//  return tv.tv_sec * 1000000ULL + tv.tv_usec;
 }
 
 class BubbleDemo {
@@ -483,16 +469,11 @@ void BubbleDemo::Initialize() {
   ClearCmd(helper_.get(), GAPIInterface::COLOR | GAPIInterface::DEPTH, color,
            1.f, 0);
 
-  // AddCommand copies the args, so it is safe to re-use args across various
-  // calls.
-  // 20 is the largest command we use (SET_PARAM_DATA_IMMEDIATE for matrices).
-  CommandBufferEntry args[20];
-
   // Create geometry arrays and structures
   args[0].value_uint32 = vertex_buffer_id_;
   args[1].value_uint32 = kVertexBufferSize;  // size
   args[2].value_uint32 = 0;  // flags
-  helper_->AddCommand(CREATE_VERTEX_BUFFER, 3, args);
+  helper_->AddCommand(CreateVertexBuffer, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = vertex_buffer_id_;
@@ -500,13 +481,13 @@ void BubbleDemo::Initialize() {
   args[2].value_uint32 = kVertexBufferSize;  // size
   args[3].value_uint32 = shm_id_;  // shm
   args[4].value_uint32 = allocator_->GetOffset(vertices_);  // offset in shm
-  helper_->AddCommand(SET_VERTEX_BUFFER_DATA, 5, args);
+  helper_->AddCommand(SetVertexBufferData, 5, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = index_buffer_id_;
   args[1].value_uint32 = kIndexBufferSize;  // size
   args[2].value_uint32 = index_buffer::INDEX_32BIT;  // flags
-  helper_->AddCommand(CREATE_INDEX_BUFFER, 3, args);
+  helper_->AddCommand(CreateIndexBuffer, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = index_buffer_id_;
@@ -514,12 +495,12 @@ void BubbleDemo::Initialize() {
   args[2].value_uint32 = kIndexBufferSize;  // size
   args[3].value_uint32 = shm_id_;  // shm
   args[4].value_uint32 = allocator_->GetOffset(indices_);  // offset in shm
-  helper_->AddCommand(SET_INDEX_BUFFER_DATA, 5, args);
+  helper_->AddCommand(SetIndexBufferData, 5, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = vertex_struct_id_;
   args[1].value_uint32 = 3;  // input count
-  helper_->AddCommand(CREATE_VERTEX_STRUCT, 2, args);
+  helper_->AddCommand(CreateVertexStruct, 2, args);
   CHECK_ERROR(helper_);
 
   // Set POSITION input stream
@@ -532,7 +513,7 @@ void BubbleDemo::Initialize() {
       set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT3) |
       set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::POSITION) |
       set_vertex_input_cmd::SemanticIndex::MakeValue(0);
-  helper_->AddCommand(SET_VERTEX_INPUT, 5, args);
+  helper_->AddCommand(SetVertexInput, 5, args);
   CHECK_ERROR(helper_);
 
   // Set NORMAL input stream
@@ -543,7 +524,7 @@ void BubbleDemo::Initialize() {
       set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT3) |
       set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::NORMAL) |
       set_vertex_input_cmd::SemanticIndex::MakeValue(0);
-  helper_->AddCommand(SET_VERTEX_INPUT, 5, args);
+  helper_->AddCommand(SetVertexInput, 5, args);
   CHECK_ERROR(helper_);
 
   // Set TEXCOORD0 input stream
@@ -554,7 +535,7 @@ void BubbleDemo::Initialize() {
       set_vertex_input_cmd::Type::MakeValue(vertex_struct::FLOAT2) |
       set_vertex_input_cmd::Semantic::MakeValue(vertex_struct::TEX_COORD) |
       set_vertex_input_cmd::SemanticIndex::MakeValue(0);
-  helper_->AddCommand(SET_VERTEX_INPUT, 5, args);
+  helper_->AddCommand(SetVertexInput, 5, args);
   CHECK_ERROR(helper_);
 
   // Create a 2D texture.
@@ -566,7 +547,7 @@ void BubbleDemo::Initialize() {
       create_texture_2d_cmd::Levels::MakeValue(0) |
       create_texture_2d_cmd::Format::MakeValue(texture::ARGB8) |
       create_texture_2d_cmd::Flags::MakeValue(0);
-  helper_->AddCommand(CREATE_TEXTURE_2D, 3, args);
+  helper_->AddCommand(CreateTexture2d, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = noise_texture_id_;
@@ -585,16 +566,16 @@ void BubbleDemo::Initialize() {
   args[7].value_uint32 = kTexSize;  // size
   args[8].value_uint32 = shm_id_;
   args[9].value_uint32 = allocator_->GetOffset(noise_texture_);
-  helper_->AddCommand(SET_TEXTURE_DATA, 10, args);
+  helper_->AddCommand(SetTextureData, 10, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = noise_sampler_id_;
-  helper_->AddCommand(CREATE_SAMPLER, 1, args);
+  helper_->AddCommand(CreateSampler, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = noise_sampler_id_;
   args[1].value_uint32 = noise_texture_id_;
-  helper_->AddCommand(SET_SAMPLER_TEXTURE, 2, args);
+  helper_->AddCommand(SetSamplerTexture, 2, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = noise_sampler_id_;
@@ -606,7 +587,7 @@ void BubbleDemo::Initialize() {
       set_sampler_states::MinFilter::MakeValue(sampler::LINEAR) |
       set_sampler_states::MipFilter::MakeValue(sampler::NONE) |
       set_sampler_states::MaxAnisotropy::MakeValue(1);
-  helper_->AddCommand(SET_SAMPLER_STATES, 2, args);
+  helper_->AddCommand(SetSamplerStates, 2, args);
   CHECK_ERROR(helper_);
 
   // Create a 2D texture.
@@ -618,7 +599,7 @@ void BubbleDemo::Initialize() {
       create_texture_2d_cmd::Levels::MakeValue(0) |
       create_texture_2d_cmd::Format::MakeValue(texture::ARGB8) |
       create_texture_2d_cmd::Flags::MakeValue(0);
-  helper_->AddCommand(CREATE_TEXTURE_2D, 3, args);
+  helper_->AddCommand(CreateTexture2d, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = iridescence_texture_id_;
@@ -637,16 +618,16 @@ void BubbleDemo::Initialize() {
   args[7].value_uint32 = kTexSize;  // size
   args[8].value_uint32 = shm_id_;
   args[9].value_uint32 = allocator_->GetOffset(iridescence_texture_);
-  helper_->AddCommand(SET_TEXTURE_DATA, 10, args);
+  helper_->AddCommand(SetTextureData, 10, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = iridescence_sampler_id_;
-  helper_->AddCommand(CREATE_SAMPLER, 1, args);
+  helper_->AddCommand(CreateSampler, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = iridescence_sampler_id_;
   args[1].value_uint32 = iridescence_texture_id_;
-  helper_->AddCommand(SET_SAMPLER_TEXTURE, 2, args);
+  helper_->AddCommand(SetSamplerTexture, 2, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = iridescence_sampler_id_;
@@ -658,7 +639,7 @@ void BubbleDemo::Initialize() {
       set_sampler_states::MinFilter::MakeValue(sampler::LINEAR) |
       set_sampler_states::MipFilter::MakeValue(sampler::NONE) |
       set_sampler_states::MaxAnisotropy::MakeValue(1);
-  helper_->AddCommand(SET_SAMPLER_STATES, 2, args);
+  helper_->AddCommand(SetSamplerStates, 2, args);
   CHECK_ERROR(helper_);
 
   // Create a Cubemap texture.
@@ -669,7 +650,7 @@ void BubbleDemo::Initialize() {
       create_texture_cube_cmd::Levels::MakeValue(0) |
       create_texture_cube_cmd::Format::MakeValue(texture::ARGB8) |
       create_texture_cube_cmd::Flags::MakeValue(0);
-  helper_->AddCommand(CREATE_TEXTURE_CUBE, 3, args);
+  helper_->AddCommand(CreateTextureCube, 3, args);
   CHECK_ERROR(helper_);
 
   for (unsigned int face = 0; face < 6; ++face) {
@@ -693,18 +674,18 @@ void BubbleDemo::Initialize() {
     args[7].value_uint32 = kCubeMapFaceSize;  // size
     args[8].value_uint32 = shm_id_;
     args[9].value_uint32 = allocator_->GetOffset(data);
-    helper_->AddCommand(SET_TEXTURE_DATA, 10, args);
+    helper_->AddCommand(SetTextureData, 10, args);
     CHECK_ERROR(helper_);
     allocator_->FreePendingToken(data, helper_->InsertToken());
   }
 
   args[0].value_uint32 = cubemap_sampler_id_;
-  helper_->AddCommand(CREATE_SAMPLER, 1, args);
+  helper_->AddCommand(CreateSampler, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = cubemap_sampler_id_;
   args[1].value_uint32 = cubemap_id_;
-  helper_->AddCommand(SET_SAMPLER_TEXTURE, 2, args);
+  helper_->AddCommand(SetSamplerTexture, 2, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = cubemap_sampler_id_;
@@ -716,7 +697,7 @@ void BubbleDemo::Initialize() {
       set_sampler_states::MinFilter::MakeValue(sampler::LINEAR) |
       set_sampler_states::MipFilter::MakeValue(sampler::NONE) |
       set_sampler_states::MaxAnisotropy::MakeValue(1);
-  helper_->AddCommand(SET_SAMPLER_STATES, 2, args);
+  helper_->AddCommand(SetSamplerStates, 2, args);
   CHECK_ERROR(helper_);
 
   // Create the effect, and parameters.
@@ -726,7 +707,7 @@ void BubbleDemo::Initialize() {
   args[1].value_uint32 = sizeof(effect_data);  // size
   args[2].value_uint32 = shm_id_;  // shm
   args[3].value_uint32 = allocator_->GetOffset(data);  // offset in shm
-  helper_->AddCommand(CREATE_EFFECT, 4, args);
+  helper_->AddCommand(CreateEffect, 4, args);
   CHECK_ERROR(helper_);
   allocator_->FreePendingToken(data, helper_->InsertToken());
 
@@ -737,7 +718,7 @@ void BubbleDemo::Initialize() {
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
@@ -748,7 +729,7 @@ void BubbleDemo::Initialize() {
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
@@ -759,7 +740,7 @@ void BubbleDemo::Initialize() {
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
@@ -770,7 +751,7 @@ void BubbleDemo::Initialize() {
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
@@ -781,7 +762,7 @@ void BubbleDemo::Initialize() {
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
@@ -792,7 +773,7 @@ void BubbleDemo::Initialize() {
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
@@ -803,7 +784,7 @@ void BubbleDemo::Initialize() {
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
@@ -814,7 +795,7 @@ void BubbleDemo::Initialize() {
     args[2].value_uint32 = sizeof(param_name);
     unsigned int arg_count = CopyToArgs(args + 3, param_name,
                                         sizeof(param_name));
-    helper_->AddCommand(CREATE_PARAM_BY_NAME_IMMEDIATE, 3 + arg_count, args);
+    helper_->AddCommand(CreateParamByNameImmediate, 3 + arg_count, args);
     CHECK_ERROR(helper_);
   }
 
@@ -822,19 +803,19 @@ void BubbleDemo::Initialize() {
   args[0].value_uint32 = noise_sampler_param_id_;
   args[1].value_uint32 = sizeof(Uint32);  // NOLINT
   args[2].value_uint32 = noise_sampler_id_;
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 3, args);
+  helper_->AddCommand(SetParamDataImmediate, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = iridescence_sampler_param_id_;
   args[1].value_uint32 = sizeof(Uint32);  // NOLINT
   args[2].value_uint32 = iridescence_sampler_id_;
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 3, args);
+  helper_->AddCommand(SetParamDataImmediate, 3, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = cubemap_sampler_param_id_;
   args[1].value_uint32 = sizeof(Uint32);  // NOLINT
   args[2].value_uint32 = cubemap_sampler_id_;
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 3, args);
+  helper_->AddCommand(SetParamDataImmediate, 3, args);
   CHECK_ERROR(helper_);
 
   // Create our random bubbles.
@@ -900,35 +881,35 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view,
 
   // AddCommand copies the args, so it is safe to re-use args across various
   // calls.
-  // 20 is the largest command we use (SET_PARAM_DATA_IMMEDIATE for matrices).
+  // 20 is the largest command we use (SetParamDataImmediate for matrices).
   CommandBufferEntry args[20];
 
   args[0].value_uint32 = vertex_struct_id_;
-  helper_->AddCommand(SET_VERTEX_STRUCT, 1, args);
+  helper_->AddCommand(SetVertexStruct, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = mvp_param_id_;
   args[1].value_uint32 = sizeof(mvp);
   unsigned int arg_count = CopyToArgs(args + 2, &mvp, sizeof(mvp));
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args);
+  helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = world_param_id_;
   args[1].value_uint32 = sizeof(model);
   arg_count = CopyToArgs(args + 2, &model, sizeof(model));
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args);
+  helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = worldIT_param_id_;
   args[1].value_uint32 = sizeof(modelIT);
   arg_count = CopyToArgs(args + 2, &modelIT, sizeof(modelIT));
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args);
+  helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = eye_param_id_;
   args[1].value_uint32 = sizeof(eye);
   arg_count = CopyToArgs(args + 2, &eye, sizeof(eye));
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 2 + arg_count, args);
+  helper_->AddCommand(SetParamDataImmediate, 2 + arg_count, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 =
@@ -938,11 +919,11 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view,
       set_blending::ColorEq::MakeValue(GAPIInterface::BLEND_EQ_ADD) |
       set_blending::SeparateAlpha::MakeValue(0) |
       set_blending::Enable::MakeValue(1);
-  helper_->AddCommand(SET_BLENDING, 1, args);
+  helper_->AddCommand(SetBlending, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = effect_id_;
-  helper_->AddCommand(SET_EFFECT, 1, args);
+  helper_->AddCommand(SetEffect, 1, args);
   CHECK_ERROR(helper_);
 
   // Draw back faces first.
@@ -950,7 +931,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view,
       set_polygon_raster::FillMode::MakeValue(
           GAPIInterface::POLYGON_MODE_FILL) |
       set_polygon_raster::CullMode::MakeValue(GAPIInterface::CULL_CCW);
-  helper_->AddCommand(SET_POLYGON_RASTER, 1, args);
+  helper_->AddCommand(SetPolygonRaster, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = thickness_param_id_;
@@ -959,7 +940,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view,
   args[3].value_float = bubble.base_thickness;
   args[4].value_float = bubble.noise_ratio;
   args[5].value_float = .5f;  // back face attenuation
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 6, args);
+  helper_->AddCommand(SetParamDataImmediate, 6, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = GAPIInterface::TRIANGLES;
@@ -968,7 +949,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view,
   args[3].value_uint32 = kIndexCount/3;  // primitive count
   args[4].value_uint32 = 0;  // min index
   args[5].value_uint32 = kVertexCount-1;  // max index
-  helper_->AddCommand(DRAW_INDEXED, 6, args);
+  helper_->AddCommand(DrawIndexed, 6, args);
   CHECK_ERROR(helper_);
 
   // Then front faces.
@@ -976,7 +957,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view,
       set_polygon_raster::FillMode::MakeValue(
           GAPIInterface::POLYGON_MODE_FILL) |
       set_polygon_raster::CullMode::MakeValue(GAPIInterface::CULL_CW);
-  helper_->AddCommand(SET_POLYGON_RASTER, 1, args);
+  helper_->AddCommand(SetPolygonRaster, 1, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = thickness_param_id_;
@@ -985,7 +966,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view,
   args[3].value_float = bubble.base_thickness;
   args[4].value_float = bubble.noise_ratio;
   args[5].value_float = 1.f;
-  helper_->AddCommand(SET_PARAM_DATA_IMMEDIATE, 6, args);
+  helper_->AddCommand(SetParamDataImmediate, 6, args);
   CHECK_ERROR(helper_);
 
   args[0].value_uint32 = GAPIInterface::TRIANGLES;
@@ -994,7 +975,7 @@ void BubbleDemo::DrawBubble(const math::Matrix4& view,
   args[3].value_uint32 = kIndexCount/3;  // primitive count
   args[4].value_uint32 = 0;  // min index
   args[5].value_uint32 = kVertexCount-1;  // max index
-  helper_->AddCommand(DRAW_INDEXED, 6, args);
+  helper_->AddCommand(DrawIndexed, 6, args);
   CHECK_ERROR(helper_);
 }
 
@@ -1012,7 +993,7 @@ void BubbleDemo::Render() {
       math::CreatePerspectiveMatrix(kPi / 4.f, 1.f, .1f, 10000.f);
   math::Matrix4 view = math::Matrix4::lookAt(eye, target, up);
 
-  helper_->AddCommand(BEGIN_FRAME, 0 , NULL);
+  helper_->AddCommand(BeginFrame, 0 , NULL);
   CHECK_ERROR(helper_);
   RGBA color = {0.2f, 0.2f, 0.2f, 1.f};
   ClearCmd(helper_.get(), GAPIInterface::COLOR | GAPIInterface::DEPTH, color,
@@ -1026,7 +1007,7 @@ void BubbleDemo::Render() {
     DrawBubble(view, proj, bubble, time_ * 2.f * kPi * bubble.rotation_speed);
   }
 
-  helper_->AddCommand(END_FRAME, 0 , NULL);
+  helper_->AddCommand(EndFrame, 0 , NULL);
   CHECK_ERROR(helper_);
   helper_->Flush();
 }
@@ -1034,6 +1015,7 @@ void BubbleDemo::Render() {
 }  // namespace command_buffer
 }  // namespace o3d
 
+#if 0
 // Scriptable object for the plug-in, provides the glue with the browser.
 // Creates a BubbleDemo object and delegates calls to it.
 class Plugin : public NPObject {
@@ -1264,3 +1246,60 @@ int main(int argc, char **argv) {
   NaClNP_MainLoop(0);
   return 0;
 }
+#endif
+
+nacl::HtpHandle InitConnection(int argc, char **argv) {
+  nacl::Handle handle = nacl::kInvalidHandle;
+#ifndef __native_client__
+  NaClNrdAllModulesInit();
+
+  static nacl::SocketAddress g_address = { "command-buffer" };
+  static nacl::SocketAddress g_local_address = { "cb-client" };
+
+  nacl::Handle sockets[2];
+  nacl::SocketPair(sockets);
+
+  nacl::MessageHeader msg;
+  msg.iov = NULL;
+  msg.iov_length = 0;
+  msg.handles = &sockets[1];
+  msg.handle_count = 1;
+  nacl::Handle local_socket = nacl::BoundSocket(&g_local_address);
+  nacl::SendDatagramTo(local_socket, &msg, 0, &g_address);
+  nacl::Close(local_socket);
+  nacl::Close(sockets[1]);
+  handle = sockets[0];
+#else
+  if (argc < 3 || strcmp(argv[1], "-fd") != 0) {
+    fprintf(stderr, "Usage: %s -fd file_descriptor\n", argv[0]);
+    return nacl::kInvalidHtpHandle;
+  }
+  int fd = atoi(argv[2]);
+  handle = imc_connect(fd);
+  if (handle < 0) {
+    fprintf(stderr, "Could not connect to file descriptor %d.\n"
+            "Did you use the -a and -X options to sel_ldr ?\n", fd);
+    return nacl::kInvalidHtpHandle;
+  }
+#endif
+  return nacl::CreateImcDesc(handle);
+}
+
+void CloseConnection(nacl::HtpHandle handle) {
+  nacl::Close(handle);
+#ifndef __native_client__
+  NaClNrdAllModulesFini();
+#endif
+}
+
+int main(int argc, char **argv) {
+  nacl::HtpHandle htp_handle = InitConnection(argc, argv);
+  if (htp_handle == nacl::kInvalidHtpHandle) {
+    return 1;
+  }
+
+  o3d::command_buffer::BubbleDemo(htp_handle);
+  CloseConnection(htp_handle);
+  return 0;
+}
+
diff --git a/o3d/command_buffer/service/cross/buffer_rpc_test.cc b/o3d/command_buffer/service/cross/buffer_rpc_test.cc
index 42122b9..a0afd7b 100644
--- a/o3d/command_buffer/service/cross/buffer_rpc_test.cc
+++ b/o3d/command_buffer/service/cross/buffer_rpc_test.cc
@@ -151,8 +151,8 @@ TEST_F(BufferRPCImplTest, TestSignalGetChanges) {
 // is properly forwarded.
 TEST_F(BufferRPCImplTest, TestGetStatus) {
   EXPECT_CALL(buffer_sync_mock(), GetStatus())
-      .WillOnce(Return(BufferSyncInterface::PARSE_ERROR));
-  EXPECT_EQ(BufferSyncInterface::PARSE_ERROR,
+      .WillOnce(Return(BufferSyncInterface::kParseError));
+  EXPECT_EQ(BufferSyncInterface::kParseError,
             buffer_rpc_impl()->DoCall(BufferRPCImpl::GET_STATUS, NULL, 0, NULL,
                                       0));
 }
@@ -161,8 +161,8 @@ TEST_F(BufferRPCImplTest, TestGetStatus) {
 // is properly forwarded.
 TEST_F(BufferRPCImplTest, TestGetParseError) {
   EXPECT_CALL(buffer_sync_mock(), GetParseError())
-      .WillOnce(Return(BufferSyncInterface::PARSE_OUT_OF_BOUNDS));
-  EXPECT_EQ(BufferSyncInterface::PARSE_OUT_OF_BOUNDS,
+      .WillOnce(Return(BufferSyncInterface::kParseOutOfBounds));
+  EXPECT_EQ(BufferSyncInterface::kParseOutOfBounds,
             buffer_rpc_impl()->DoCall(BufferRPCImpl::GET_PARSE_ERROR, NULL, 0,
                                       NULL, 0));
 }
diff --git a/o3d/command_buffer/service/cross/cmd_buffer_engine.cc b/o3d/command_buffer/service/cross/cmd_buffer_engine.cc
index d96c63d..b39f993 100644
--- a/o3d/command_buffer/service/cross/cmd_buffer_engine.cc
+++ b/o3d/command_buffer/service/cross/cmd_buffer_engine.cc
@@ -47,10 +47,10 @@ CommandBufferEngine::CommandBufferEngine(AsyncAPIInterface *handler)
       handler_(handler),
       client_rpc_(NULL),
       token_(0),
-      status_(NOT_CONNECTED),
+      status_(kNotConnected),
       signal_change_(false),
       signal_rpc_message_id_(0),
-      parse_error_(PARSE_NO_ERROR) {
+      parse_error_(kParseNoError) {
   buffer_rpc_impl_.reset(new BufferRPCImpl(this));
 }
 
@@ -58,13 +58,13 @@ CommandBufferEngine::~CommandBufferEngine() {}
 
 // Inits the connection. Registers the client RPC service.
 void CommandBufferEngine::InitConnection() {
-  status_ = NO_BUFFER;
+  status_ = kNoBuffer;
 }
 
 // Closes the connection. Executes all remaining commands.
 void CommandBufferEngine::CloseConnection() {
   FinishParsing();
-  status_ = NOT_CONNECTED;
+  status_ = kNotConnected;
   parser_.reset(NULL);
 }
 
@@ -113,13 +113,13 @@ void CommandBufferEngine::SetCommandBuffer(unsigned int shm_id,
                << "shared memory";
     return;
   }
-  if (status_ == NOT_CONNECTED) return;
+  if (status_ == kNotConnected) return;
   FinishParsing();
   parser_.reset(new CommandParser(shared_memory_buffers_[shm_id].address,
                                   shared_memory_buffers_[shm_id].size, offset,
                                   size, start_get, handler_));
-  status_ = PARSING;
-  parse_error_ = PARSE_NO_ERROR;
+  status_ = kParsing;
+  parse_error_ = kParseNoError;
 }
 
 // Changes the put value.
@@ -145,12 +145,12 @@ unsigned int CommandBufferEngine::GetToken() {
 
 // Executes commands until get is different from the value passed in. It will
 // return immediately if the get value is already different, or if the engine
-// is not in the PARSING status, or if the buffer is empty. It will return -1
+// is not in the kParsing status, or if the buffer is empty. It will return -1
 // if there is no current buffer.
 CommandBufferOffset CommandBufferEngine::WaitGetChanges(
     CommandBufferOffset current_value) {
   if (parser_.get()) {
-    while (status_ == PARSING &&
+    while (status_ == kParsing &&
            parser_->get() == current_value &&
            !parser_->IsEmpty()) {
       ProcessOneCommand();
@@ -162,12 +162,12 @@ CommandBufferOffset CommandBufferEngine::WaitGetChanges(
 }
 
 // Signals the client when get gets different from the value passed in. If get
-// is already different, or if the engine is not in the PARSING status, that
+// is already different, or if the engine is not in the kParsing status, that
 // will happen immediately, otherwise it will happen when commands get
 // executed, moving the get pointer.
 void CommandBufferEngine::SignalGetChanges(CommandBufferOffset current_value,
                                            int rpc_message_id) {
-  if (status_ != PARSING || parser_->get() != current_value) {
+  if (status_ != kParsing || parser_->get() != current_value) {
     DoSignalChangedGet(rpc_message_id);
   } else {
     signal_change_ = true;
@@ -200,10 +200,10 @@ BufferSyncInterface::ParserStatus CommandBufferEngine::GetStatus() {
   return status_;
 }
 
-// Gets the current parse error, reset it to PARSE_NO_ERROR.
+// Gets the current parse error, reset it to kParseNoError.
 BufferSyncInterface::ParseError CommandBufferEngine::GetParseError() {
   ParseError error = parse_error_;
-  parse_error_ = PARSE_NO_ERROR;
+  parse_error_ = kParseNoError;
   return error;
 }
 
@@ -211,32 +211,32 @@ BufferSyncInterface::ParseError CommandBufferEngine::GetParseError() {
 // parsing error occurs.
 void CommandBufferEngine::FinishParsing() {
   // terminates current parsing, that is, execute all the commands
-  // NOTE: status_ == PARSING implies parser_ != NULL
-  while (status_ == PARSING && !parser_->IsEmpty()) {
+  // NOTE: status_ == kParsing implies parser_ != NULL
+  while (status_ == kParsing && !parser_->IsEmpty()) {
     ProcessOneCommand();
   }
 }
 
 // Processes one command from the command buffer. This must only be called when
-// in the PARSING status.
+// in the kParsing status.
 // This will update the status_ and the parse_error_ fields if an error occurs.
 void CommandBufferEngine::ProcessOneCommand() {
-  DCHECK_EQ(PARSING, status_);
+  DCHECK_EQ(kParsing, status_);
   DCHECK(parser_.get());
   ParseError result = parser_->ProcessCommand();
   switch (result) {
-    case PARSE_NO_ERROR:
+    case kParseNoError:
       break;
-    case PARSE_OUT_OF_BOUNDS:
-    case PARSE_INVALID_SIZE:
-      status_ = PARSE_ERROR;
+    case kParseOutOfBounds:
+    case kParseInvalidSize:
+      status_ = kParseError;
       // Always override the error, to properly signal the stopping condition.
       parse_error_ = result;
       break;
-    case PARSE_INVALID_ARGUMENTS:
-    case PARSE_UNKNOWN_COMMAND:
+    case kParseInvalidArguments:
+    case kParseUnknownCommand:
       // Only set the error if it is not set already.
-      if (parse_error_ == PARSE_NO_ERROR) {
+      if (parse_error_ == kParseNoError) {
         parse_error_ = result;
       }
       break;
@@ -255,16 +255,16 @@ void CommandBufferEngine::DoMainLoop() {
   while (DoWork()) { }
   // Clean up if needed: execute all pending commands, then close the
   // connection.
-  if (status_ != NOT_CONNECTED) CloseConnection();
+  if (status_ != kNotConnected) CloseConnection();
 }
 
 bool CommandBufferEngine::HasWork() {
-  return (status_ == PARSING && !parser_->IsEmpty()) ||
+  return (status_ == kParsing && !parser_->IsEmpty()) ||
       process_interface_->HasMessage();
 }
 
 bool CommandBufferEngine::DoWork() {
-  if (status_ == PARSING && !parser_->IsEmpty()) {
+  if (status_ == kParsing && !parser_->IsEmpty()) {
     bool running = true;
     // process as many messages as available but do not block.
     while (process_interface_->HasMessage()) {
diff --git a/o3d/command_buffer/service/cross/cmd_buffer_engine.h b/o3d/command_buffer/service/cross/cmd_buffer_engine.h
index 824f4f6..572d98f 100644
--- a/o3d/command_buffer/service/cross/cmd_buffer_engine.h
+++ b/o3d/command_buffer/service/cross/cmd_buffer_engine.h
@@ -131,8 +131,8 @@ class CommandBufferEngine : public BufferSyncInterface {
 
   // Gets the current parse error. The current parse error is set when the
   // service is in the PARSE_ERROR status. It may also be set while in the
-  // PARSING state, if a recoverable error (like PARSE_UNKNOWN_METHOD) was
-  // encountered. Getting the error resets it to PARSE_NO_ERROR.
+  // kParsing state, if a recoverable error (like PARSE_UNKNOWN_METHOD) was
+  // encountered. Getting the error resets it to kParseNoError.
   // Returns:
   //   The current parse error.
   virtual ParseError GetParseError();
diff --git a/o3d/command_buffer/service/cross/cmd_buffer_engine_test.cc b/o3d/command_buffer/service/cross/cmd_buffer_engine_test.cc
index 14f56ec..c217e4c 100644
--- a/o3d/command_buffer/service/cross/cmd_buffer_engine_test.cc
+++ b/o3d/command_buffer/service/cross/cmd_buffer_engine_test.cc
@@ -133,21 +133,21 @@ TEST_F(CommandBufferEngineTest, TestInitialization) {
   // Check initial state
   EXPECT_TRUE(engine()->rpc_impl() != NULL);
   EXPECT_TRUE(engine()->parser() == NULL);
-  EXPECT_EQ(BufferSyncInterface::NOT_CONNECTED, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kNotConnected, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   EXPECT_EQ(-1, engine()->Get());
   EXPECT_EQ(0, engine()->GetToken());
 
   engine()->InitConnection();
-  EXPECT_EQ(BufferSyncInterface::NO_BUFFER, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kNoBuffer, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   EXPECT_EQ(-1, engine()->Get());
 
   CommandBufferEntry *entries = InitCommandBuffer(25, 5);
   ASSERT_TRUE(entries != NULL);
 
-  EXPECT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   EXPECT_EQ(5, engine()->Get());
   EXPECT_TRUE(engine()->parser() != NULL);
 
@@ -157,8 +157,8 @@ TEST_F(CommandBufferEngineTest, TestInitialization) {
   engine()->CloseConnection();
   DestroyCommandBuffer();
 
-  EXPECT_EQ(BufferSyncInterface::NOT_CONNECTED, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kNotConnected, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   EXPECT_EQ(-1, engine()->Get());
   EXPECT_TRUE(engine()->parser() == NULL);
 }
@@ -231,7 +231,7 @@ TEST_F(CommandBufferEngineTest, TestCommandProcessing) {
 
   // Create a command buffer with 3 commands
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
@@ -240,7 +240,7 @@ TEST_F(CommandBufferEngineTest, TestCommandProcessing) {
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
@@ -249,7 +249,7 @@ TEST_F(CommandBufferEngineTest, TestCommandProcessing) {
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               2,
                               2,
                               args2);
@@ -259,8 +259,8 @@ TEST_F(CommandBufferEngineTest, TestCommandProcessing) {
     // Check that the parsing progresses, and that no error occurs.
     CommandBufferOffset new_get = engine()->WaitGetChanges(get);
     EXPECT_NE(get, new_get);
-    ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-    EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+    ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+    EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
     EXPECT_EQ(new_get, engine()->Get());
     get = new_get;
   }
@@ -283,7 +283,7 @@ TEST_F(CommandBufferEngineTest, TestCommandWrapping) {
 
   // Create a command buffer with 3 commands
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
@@ -292,7 +292,7 @@ TEST_F(CommandBufferEngineTest, TestCommandWrapping) {
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
@@ -303,7 +303,7 @@ TEST_F(CommandBufferEngineTest, TestCommandWrapping) {
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               2,
                               2,
                               args2);
@@ -313,8 +313,8 @@ TEST_F(CommandBufferEngineTest, TestCommandWrapping) {
     // Check that the parsing progresses, and that no error occurs.
     CommandBufferOffset new_get = engine()->WaitGetChanges(get);
     EXPECT_NE(get, new_get);
-    ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-    EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+    ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+    EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
     EXPECT_EQ(new_get, engine()->Get());
     get = new_get;
   }
@@ -337,7 +337,7 @@ TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) {
 
   // Create a command buffer with 3 commands
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
@@ -346,7 +346,7 @@ TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) {
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
@@ -355,7 +355,7 @@ TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) {
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               2,
                               2,
                               args2);
@@ -371,8 +371,8 @@ TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) {
   CommandBufferEntry *entries2 = static_cast<CommandBufferEntry *>(
       engine()->GetSharedMemoryAddress(shm_id));
   engine()->SetCommandBuffer(shm_id, 0, kShmSize, 0);
-  EXPECT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   EXPECT_EQ(0, engine()->Get());
 
   // Destroy the old command buffer.
@@ -381,7 +381,7 @@ TEST_F(CommandBufferEngineTest, TestSetBufferAndClose) {
   get = engine()->Get();
   put = get;
   put += AddCommandWithExpect(entries2 + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
@@ -409,7 +409,7 @@ TEST_F(CommandBufferEngineTest, TestRecoverableError) {
 
   // Create a command buffer with 3 commands, 2 of them generating errors
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
@@ -418,7 +418,7 @@ TEST_F(CommandBufferEngineTest, TestRecoverableError) {
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_INVALID_ARGUMENTS,
+                              BufferSyncInterface::kParseInvalidArguments,
                               1,
                               2,
                               args1);
@@ -427,7 +427,7 @@ TEST_F(CommandBufferEngineTest, TestRecoverableError) {
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_UNKNOWN_COMMAND,
+                              BufferSyncInterface::kParseUnknownCommand,
                               2,
                               2,
                               args2);
@@ -437,7 +437,7 @@ TEST_F(CommandBufferEngineTest, TestRecoverableError) {
     // Check that the parsing progresses, and that no error occurs.
     CommandBufferOffset new_get = engine()->WaitGetChanges(get);
     EXPECT_NE(get, new_get);
-    ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
+    ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
     EXPECT_EQ(new_get, engine()->Get());
     get = new_get;
   }
@@ -445,10 +445,10 @@ TEST_F(CommandBufferEngineTest, TestRecoverableError) {
   Mock::VerifyAndClearExpectations(api_mock());
 
   // Check that the error status was set to the first error.
-  EXPECT_EQ(BufferSyncInterface::PARSE_INVALID_ARGUMENTS,
+  EXPECT_EQ(BufferSyncInterface::kParseInvalidArguments,
             engine()->GetParseError());
   // Check that the error status was reset after the query.
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 
   engine()->CloseConnection();
   DestroyCommandBuffer();
@@ -477,7 +477,7 @@ TEST_F(CommandBufferEngineTest, TestNonRecoverableError) {
   // Create a command buffer with 3 commands, the last one overlapping the end
   // of the buffer.
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
@@ -486,7 +486,7 @@ TEST_F(CommandBufferEngineTest, TestNonRecoverableError) {
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
@@ -514,12 +514,12 @@ TEST_F(CommandBufferEngineTest, TestNonRecoverableError) {
     get = new_get;
   }
   // We should be in an error case now.
-  EXPECT_EQ(BufferSyncInterface::PARSE_ERROR, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseError, engine()->GetStatus());
   // Check that the error status was set to the first error.
-  EXPECT_EQ(BufferSyncInterface::PARSE_OUT_OF_BOUNDS,
+  EXPECT_EQ(BufferSyncInterface::kParseOutOfBounds,
             engine()->GetParseError());
   // Check that the error status was reset after the query.
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
 
   // Check that the valid commands did happen.
   Mock::VerifyAndClearExpectations(api_mock());
@@ -568,7 +568,7 @@ TEST_F(CommandBufferEngineTest, TestDoWork) {
   process_mock()->Reset();
   EXPECT_CALL(*process_mock(), HasMessage()).Times(AnyNumber());
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               0,
                               0,
                               NULL);
@@ -577,7 +577,7 @@ TEST_F(CommandBufferEngineTest, TestDoWork) {
   args1[0].value_uint32 = 3;
   args1[1].value_float = 4.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               1,
                               2,
                               args1);
@@ -586,7 +586,7 @@ TEST_F(CommandBufferEngineTest, TestDoWork) {
   args2[0].value_uint32 = 5;
   args2[1].value_float = 6.f;
   put += AddCommandWithExpect(entries + put,
-                              BufferSyncInterface::PARSE_NO_ERROR,
+                              BufferSyncInterface::kParseNoError,
                               2,
                               2,
                               args2);
@@ -603,8 +603,8 @@ TEST_F(CommandBufferEngineTest, TestDoWork) {
   EXPECT_FALSE(process_mock()->would_have_blocked());
   get = engine()->Get();
   EXPECT_EQ(put, get);  // once we're done, we should have executed everything.
-  ASSERT_EQ(BufferSyncInterface::PARSING, engine()->GetStatus());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, engine()->GetParseError());
+  ASSERT_EQ(BufferSyncInterface::kParsing, engine()->GetStatus());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, engine()->GetParseError());
   Mock::VerifyAndClearExpectations(process_mock());
   Mock::VerifyAndClearExpectations(api_mock());
 
diff --git a/o3d/command_buffer/service/cross/cmd_parser.cc b/o3d/command_buffer/service/cross/cmd_parser.cc
index a640d3d..843d0b8 100644
--- a/o3d/command_buffer/service/cross/cmd_parser.cc
+++ b/o3d/command_buffer/service/cross/cmd_parser.cc
@@ -66,14 +66,14 @@ CommandParser::CommandParser(void *shm_address,
 // - get_ is modified *after* the command has been executed.
 BufferSyncInterface::ParseError CommandParser::ProcessCommand() {
   CommandBufferOffset get = get_;
-  if (get == put_) return BufferSyncInterface::PARSE_NO_ERROR;
+  if (get == put_) return BufferSyncInterface::kParseNoError;
 
   CommandHeader header = buffer_[get].value_header;
-  if (header.size == 0) return BufferSyncInterface::PARSE_INVALID_SIZE;
+  if (header.size == 0) return BufferSyncInterface::kParseInvalidSize;
   if (header.size + get > entry_count_)
-    return BufferSyncInterface::PARSE_OUT_OF_BOUNDS;
+    return BufferSyncInterface::kParseOutOfBounds;
   BufferSyncInterface::ParseError result = handler_->DoCommand(
-      header.command, header.size - 1, buffer_ + get + 1);
+      header.command, header.size - 1, buffer_ + get);
   get_ = (get + header.size) % entry_count_;
   return result;
 }
@@ -85,7 +85,7 @@ BufferSyncInterface::ParseError CommandParser::ProcessAllCommands() {
     BufferSyncInterface::ParseError error = ProcessCommand();
     if (error) return error;
   }
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 }  // namespace command_buffer
diff --git a/o3d/command_buffer/service/cross/cmd_parser.h b/o3d/command_buffer/service/cross/cmd_parser.h
index 9c3a145..425e8d9 100644
--- a/o3d/command_buffer/service/cross/cmd_parser.h
+++ b/o3d/command_buffer/service/cross/cmd_parser.h
@@ -97,14 +97,14 @@ class AsyncAPIInterface {
   // Parameters:
   //    command: the command index.
   //    arg_count: the number of CommandBufferEntry arguments.
-  //    args: the arguments.
+  //    cmd_data: the command data.
   // Returns:
   //   BufferSyncInterface::NO_ERROR if no error was found, one of
   //   BufferSyncInterface::ParseError otherwise.
   virtual BufferSyncInterface::ParseError DoCommand(
       unsigned int command,
       unsigned int arg_count,
-      const void* args) = 0;
+      const void* cmd_data) = 0;
 };
 
 }  // namespace command_buffer
diff --git a/o3d/command_buffer/service/cross/cmd_parser_test.cc b/o3d/command_buffer/service/cross/cmd_parser_test.cc
index a63489c..3d50d8a 100644
--- a/o3d/command_buffer/service/cross/cmd_parser_test.cc
+++ b/o3d/command_buffer/service/cross/cmd_parser_test.cc
@@ -115,8 +115,8 @@ TEST_F(CommandParserTest, TestSimple) {
   parser->set_put(put);
   EXPECT_EQ(put, parser->put());
 
-  AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 123, 0, NULL);
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessCommand());
+  AddDoCommandExpect(BufferSyncInterface::kParseNoError, 123, 0, NULL);
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessCommand());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 
@@ -133,8 +133,8 @@ TEST_F(CommandParserTest, TestSimple) {
   CommandBufferEntry param_array[2];
   param_array[0].value_int32 = 2134;
   param_array[1].value_float = 1.f;
-  AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 456, 2, param_array);
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessCommand());
+  AddDoCommandExpect(BufferSyncInterface::kParseNoError, 456, 2, param_array);
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessCommand());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 }
@@ -162,14 +162,14 @@ TEST_F(CommandParserTest, TestMultipleCommands) {
 
   CommandBufferEntry param_array[2];
   param_array[0].value_int32 = 5151;
-  AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 789, 1, param_array);
+  AddDoCommandExpect(BufferSyncInterface::kParseNoError, 789, 1, param_array);
   param_array[1].value_int32 = 3434;
-  AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 2121, 1,
+  AddDoCommandExpect(BufferSyncInterface::kParseNoError, 2121, 1,
                      param_array+1);
 
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessCommand());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessCommand());
   EXPECT_EQ(put_cmd2, parser->get());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessCommand());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessCommand());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 
@@ -188,12 +188,12 @@ TEST_F(CommandParserTest, TestMultipleCommands) {
   EXPECT_EQ(put, parser->put());
 
   param_array[0].value_int32 = 5656;
-  AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 4545, 1, param_array);
+  AddDoCommandExpect(BufferSyncInterface::kParseNoError, 4545, 1, param_array);
   param_array[1].value_int32 = 7878;
-  AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 6767, 1,
+  AddDoCommandExpect(BufferSyncInterface::kParseNoError, 6767, 1,
                      param_array+1);
 
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessAllCommands());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessAllCommands());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 }
@@ -209,11 +209,11 @@ TEST_F(CommandParserTest, TestWrap) {
     header.size = 1;
     header.command = i;
     buffer()[put++].value_header = header;
-    AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, i, 0, NULL);
+    AddDoCommandExpect(BufferSyncInterface::kParseNoError, i, 0, NULL);
   }
   parser->set_put(put);
   EXPECT_EQ(put, parser->put());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessAllCommands());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessAllCommands());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 
@@ -225,13 +225,13 @@ TEST_F(CommandParserTest, TestWrap) {
   buffer()[put++].value_int32 = 5;
   CommandBufferEntry param;
   param.value_int32 = 5;
-  AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 3, 1, &param);
+  AddDoCommandExpect(BufferSyncInterface::kParseNoError, 3, 1, &param);
 
   DCHECK_EQ(5, put);
   put = 0;
   parser->set_put(put);
   EXPECT_EQ(put, parser->put());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessAllCommands());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessAllCommands());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 
@@ -241,10 +241,10 @@ TEST_F(CommandParserTest, TestWrap) {
   buffer()[put++].value_header = header;
   buffer()[put++].value_int32 = 6;
   param.value_int32 = 6;
-  AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 4, 1, &param);
+  AddDoCommandExpect(BufferSyncInterface::kParseNoError, 4, 1, &param);
   parser->set_put(put);
   EXPECT_EQ(put, parser->put());
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessAllCommands());
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessAllCommands());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 }
@@ -262,7 +262,7 @@ TEST_F(CommandParserTest, TestError) {
 
   parser->set_put(put);
   EXPECT_EQ(put, parser->put());
-  EXPECT_EQ(BufferSyncInterface::PARSE_INVALID_SIZE,
+  EXPECT_EQ(BufferSyncInterface::kParseInvalidSize,
             parser->ProcessAllCommands());
   // check that no DoCommand call was made.
   Mock::VerifyAndClearExpectations(api_mock());
@@ -277,7 +277,7 @@ TEST_F(CommandParserTest, TestError) {
 
   parser->set_put(put);
   EXPECT_EQ(put, parser->put());
-  EXPECT_EQ(BufferSyncInterface::PARSE_OUT_OF_BOUNDS,
+  EXPECT_EQ(BufferSyncInterface::kParseOutOfBounds,
             parser->ProcessAllCommands());
   // check that no DoCommand call was made.
   Mock::VerifyAndClearExpectations(api_mock());
@@ -297,16 +297,16 @@ TEST_F(CommandParserTest, TestError) {
   parser->set_put(put);
   EXPECT_EQ(put, parser->put());
   // have the first command fail to parse.
-  AddDoCommandExpect(BufferSyncInterface::PARSE_UNKNOWN_COMMAND, 3, 0, NULL);
-  EXPECT_EQ(BufferSyncInterface::PARSE_UNKNOWN_COMMAND,
+  AddDoCommandExpect(BufferSyncInterface::kParseUnknownCommand, 3, 0, NULL);
+  EXPECT_EQ(BufferSyncInterface::kParseUnknownCommand,
             parser->ProcessAllCommands());
   // check that only one command was executed, and that get reflects that
   // correctly.
   EXPECT_EQ(put_post_fail, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
   // make the second one succeed, and check that the parser recovered fine.
-  AddDoCommandExpect(BufferSyncInterface::PARSE_NO_ERROR, 4, 0, NULL);
-  EXPECT_EQ(BufferSyncInterface::PARSE_NO_ERROR, parser->ProcessAllCommands());
+  AddDoCommandExpect(BufferSyncInterface::kParseNoError, 4, 0, NULL);
+  EXPECT_EQ(BufferSyncInterface::kParseNoError, parser->ProcessAllCommands());
   EXPECT_EQ(put, parser->get());
   Mock::VerifyAndClearExpectations(api_mock());
 }
diff --git a/o3d/command_buffer/service/cross/effect_utils.h b/o3d/command_buffer/service/cross/effect_utils.h
index 2402254..e4bad72 100644
--- a/o3d/command_buffer/service/cross/effect_utils.h
+++ b/o3d/command_buffer/service/cross/effect_utils.h
@@ -40,7 +40,7 @@
 namespace o3d {
 namespace command_buffer {
 
-// This function parses the data passed to the CREATE_EFFECT commands, which
+// This function parses the data passed to the CreateEffect commands, which
 // follows the following format:
 //   vertex_program_entry \0 fragment_program_entry \0 effect_code
 // It returns the various components.
diff --git a/o3d/command_buffer/service/cross/gapi_decoder.cc b/o3d/command_buffer/service/cross/gapi_decoder.cc
index aa9f019..e19b67a 100644
--- a/o3d/command_buffer/service/cross/gapi_decoder.cc
+++ b/o3d/command_buffer/service/cross/gapi_decoder.cc
@@ -43,30 +43,32 @@ namespace command_buffer {
 
 namespace {
 
+// Returns the address of the first byte after a struct.
 template <typename T>
 const void* AddressAfterStruct(const T& pod) {
   return reinterpret_cast<const uint8*>(&pod) + sizeof(pod);
 }
 
+// Returns the size in bytes of the data of an Immediate command, a command with
+// its data inline in the command buffer.
 template <typename T>
-unsigned int ImmediateSize(uint32 arg_count, const T& pod) {
-  return (arg_count - sizeof(pod) / sizeof(uint32)) * sizeof(uint32);
-}
-
-// TODO(gman): Remove this.
-CommandBufferEntry* TempHack(const void* foo) {
-  return reinterpret_cast<CommandBufferEntry*>(const_cast<void*>(foo));
+unsigned int ImmediateDataSize(uint32 arg_count, const T& pod) {
+  return static_cast<unsigned int>(
+      (arg_count + 1 - ComputeNumEntries(sizeof(pod))) *
+      sizeof(CommandBufferEntry));  // NOLINT
 }
 
+// A struct to hold info about each command.
 struct CommandInfo {
-  int arg_flags;
-  int arg_count;
+  int arg_flags;  // How to handle the arguments for this command
+  int arg_count;  // How many arguments are expected for this command.
 };
 
+// A table of CommandInfo for all the commands.
 const CommandInfo g_command_info[] = {
-  #define O3D_COMMAND_BUFFER_CMD_OP(name) {  \
-    cmd::name::kArgFlags,                    \
-    sizeof(cmd::name) / sizeof(uint32), },   \
+  #define O3D_COMMAND_BUFFER_CMD_OP(name) {                              \
+    cmd::name::kArgFlags,                                                \
+    sizeof(cmd::name) / sizeof(CommandBufferEntry) - 1, },  /* NOLINT */ \
 
   O3D_COMMAND_BUFFER_CMDS
 
@@ -83,355 +85,28 @@ const CommandInfo g_command_info[] = {
 BufferSyncInterface::ParseError GAPIDecoder::DoCommand(
     unsigned int command,
     unsigned int arg_count,
-    const void* args) {
+    const void* cmd_data) {
   if (command < arraysize(g_command_info)) {
     const CommandInfo& info = g_command_info[command];
-	unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count);
+  unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count);
     if ((info.arg_flags == cmd::kFixed && arg_count == info_arg_count) ||
         (info.arg_flags == cmd::kAtLeastN && arg_count > info_arg_count)) {
       switch (command) {
         #define O3D_COMMAND_BUFFER_CMD_OP(name)                    \
           case cmd::name::kCmdId:                                  \
-            return Handle_ ## name(                                \
+            return Handle ## name(                                 \
                 arg_count,                                         \
-                *static_cast<const cmd::name*>(args));             \
+                *static_cast<const cmd::name*>(cmd_data));         \
 
         O3D_COMMAND_BUFFER_CMDS
 
         #undef O3D_COMMAND_BUFFER_CMD_OP
       }
     } else {
-      return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      return BufferSyncInterface::kParseInvalidArguments;
     }
   }
-  return BufferSyncInterface::PARSE_UNKNOWN_COMMAND;
-}
-
-
-// Decodes the SET_VERTEX_INPUT command.
-BufferSyncInterface::ParseError GAPIDecoder::DecodeSetVertexInput(
-    unsigned int arg_count,
-    CommandBufferEntry *args) {
-  namespace cmd = set_vertex_input_cmd;
-  if (arg_count != 5) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  ResourceID vertex_struct_id = args[0].value_uint32;
-  unsigned int input_index = args[1].value_uint32;
-  ResourceID vertex_buffer_id = args[2].value_uint32;
-  unsigned int offset = args[3].value_uint32;
-  unsigned int type_stride_semantic = args[4].value_uint32;
-  unsigned int semantic_index = cmd::SemanticIndex::Get(type_stride_semantic);
-  unsigned int semantic = cmd::Semantic::Get(type_stride_semantic);
-  unsigned int type = cmd::Type::Get(type_stride_semantic);
-  unsigned int stride = cmd::Stride::Get(type_stride_semantic);
-  if (semantic >= vertex_struct::NUM_SEMANTICS ||
-      type >= vertex_struct::NUM_TYPES || stride == 0)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  return gapi_->SetVertexInput(vertex_struct_id, input_index, vertex_buffer_id,
-                               offset, stride,
-                               static_cast<vertex_struct::Type>(type),
-                               static_cast<vertex_struct::Semantic>(semantic),
-                               semantic_index);
-}
-
-// Decodes the CREATE_TEXTURE_2D command.
-BufferSyncInterface::ParseError GAPIDecoder::DecodeCreateTexture2D(
-    unsigned int arg_count,
-    CommandBufferEntry *args) {
-  if (arg_count == 3) {
-    namespace cmd = create_texture_2d_cmd;
-    unsigned int id = args[0].value_uint32;
-    unsigned int width_height = args[1].value_uint32;
-    unsigned int levels_format_flags = args[2].value_uint32;
-    unsigned int width = cmd::Width::Get(width_height);
-    unsigned int height = cmd::Height::Get(width_height);
-    unsigned int levels = cmd::Levels::Get(levels_format_flags);
-    unsigned int unused = cmd::Unused::Get(levels_format_flags);
-    unsigned int format = cmd::Format::Get(levels_format_flags);
-    unsigned int flags = cmd::Flags::Get(levels_format_flags);
-    unsigned int max_levels =
-        1 + base::bits::Log2Ceiling(std::max(width, height));
-    if ((width == 0) || (height == 0) || (levels > max_levels) ||
-        (unused != 0) || (format >= texture::NUM_FORMATS))
-      return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-    if (levels == 0) levels = max_levels;
-    bool enable_render_surfaces = !!flags;
-    return gapi_->CreateTexture2D(id, width, height, levels,
-                                  static_cast<texture::Format>(format), flags,
-                                  enable_render_surfaces);
-  } else {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  }
-}
-
-// Decodes the CREATE_TEXTURE_3D command.
-BufferSyncInterface::ParseError GAPIDecoder::DecodeCreateTexture3D(
-    unsigned int arg_count,
-    CommandBufferEntry *args) {
-  if (arg_count == 4) {
-    namespace cmd = create_texture_3d_cmd;
-    unsigned int id = args[0].value_uint32;
-    unsigned int width_height = args[1].value_uint32;
-    unsigned int depth_unused = args[2].value_uint32;
-    unsigned int levels_format_flags = args[3].value_uint32;
-    unsigned int width = cmd::Width::Get(width_height);
-    unsigned int height = cmd::Height::Get(width_height);
-    unsigned int depth = cmd::Depth::Get(depth_unused);
-    unsigned int unused1 = cmd::Unused1::Get(depth_unused);
-    unsigned int levels = cmd::Levels::Get(levels_format_flags);
-    unsigned int unused2 = cmd::Unused2::Get(levels_format_flags);
-    unsigned int format = cmd::Format::Get(levels_format_flags);
-    unsigned int flags = cmd::Flags::Get(levels_format_flags);
-    unsigned int max_levels =
-        1 + base::bits::Log2Ceiling(std::max(depth, std::max(width, height)));
-    if ((width == 0) || (height == 0) || (depth == 0) ||
-        (levels > max_levels) || (unused1 != 0) || (unused2 != 0) ||
-        (format >= texture::NUM_FORMATS))
-      return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-    if (levels == 0) levels = max_levels;
-    bool enable_render_surfaces = !!flags;
-    return gapi_->CreateTexture3D(id, width, height, depth, levels,
-                                  static_cast<texture::Format>(format), flags,
-                                  enable_render_surfaces);
-  } else {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  }
-}
-
-// Decodes the CREATE_TEXTURE_CUBE command.
-BufferSyncInterface::ParseError GAPIDecoder::DecodeCreateTextureCube(
-    unsigned int arg_count,
-    CommandBufferEntry *args) {
-  if (arg_count == 3) {
-    namespace cmd = create_texture_cube_cmd;
-    unsigned int id = args[0].value_uint32;
-    unsigned int side_unused = args[1].value_uint32;
-    unsigned int levels_format_flags = args[2].value_uint32;
-    unsigned int side = cmd::Side::Get(side_unused);
-    unsigned int unused1 = cmd::Unused1::Get(side_unused);
-    unsigned int levels = cmd::Levels::Get(levels_format_flags);
-    unsigned int unused2 = cmd::Unused2::Get(levels_format_flags);
-    unsigned int format = cmd::Format::Get(levels_format_flags);
-    unsigned int flags = cmd::Flags::Get(levels_format_flags);
-    unsigned int max_levels = 1 + base::bits::Log2Ceiling(side);
-    if ((side == 0) || (levels > max_levels) || (unused1 != 0) ||
-        (unused2 != 0) || (format >= texture::NUM_FORMATS))
-      return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-    if (levels == 0) levels = max_levels;
-    bool enable_render_surfaces = !!flags;
-    return gapi_->CreateTextureCube(id, side, levels,
-                                    static_cast<texture::Format>(format),
-                                    flags, enable_render_surfaces);
-  } else {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  }
-}
-
-// Decodes the SET_TEXTURE_DATA command.
-BufferSyncInterface::ParseError GAPIDecoder::DecodeSetTextureData(
-    unsigned int arg_count,
-    CommandBufferEntry *args) {
-  if (arg_count == 10) {
-    namespace cmd = set_texture_data_cmd;
-    unsigned int id = args[0].value_uint32;
-    unsigned int x_y = args[1].value_uint32;
-    unsigned int width_height = args[2].value_uint32;
-    unsigned int z_depth = args[3].value_uint32;
-    unsigned int level_face = args[4].value_uint32;
-    unsigned int row_pitch = args[5].value_uint32;
-    unsigned int slice_pitch = args[6].value_uint32;
-    unsigned int size = args[7].value_uint32;
-    unsigned int shm_id = args[8].value_uint32;
-    unsigned int offset = args[9].value_uint32;
-    unsigned int x = cmd::X::Get(x_y);
-    unsigned int y = cmd::Y::Get(x_y);
-    unsigned int width = cmd::Width::Get(width_height);
-    unsigned int height = cmd::Height::Get(width_height);
-    unsigned int z = cmd::Z::Get(z_depth);
-    unsigned int depth = cmd::Depth::Get(z_depth);
-    unsigned int level = cmd::Level::Get(level_face);
-    unsigned int face = cmd::Face::Get(level_face);
-    unsigned int unused = cmd::Unused::Get(level_face);
-    const void *data = GetAddressAndCheckSize(shm_id, offset, size);
-    if (face >= 6 || unused != 0 || !data)
-      return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-    return gapi_->SetTextureData(id, x, y, z, width, height, depth, level,
-                                 static_cast<texture::Face>(face), row_pitch,
-                                 slice_pitch, size, data);
-
-  } else {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  }
-}
-
-// Decodes the SET_TEXTURE_DATA_IMMEDIATE command.
-BufferSyncInterface::ParseError GAPIDecoder::DecodeSetTextureDataImmediate(
-    unsigned int arg_count,
-    CommandBufferEntry *args) {
-  if (arg_count > 8) {
-    namespace cmd = set_texture_data_immediate_cmd;
-    unsigned int id = args[0].value_uint32;
-    unsigned int x_y = args[1].value_uint32;
-    unsigned int width_height = args[2].value_uint32;
-    unsigned int z_depth = args[3].value_uint32;
-    unsigned int level_face = args[4].value_uint32;
-    unsigned int row_pitch = args[5].value_uint32;
-    unsigned int slice_pitch = args[6].value_uint32;
-    unsigned int size = args[7].value_uint32;
-    unsigned int x = cmd::X::Get(x_y);
-    unsigned int y = cmd::Y::Get(x_y);
-    unsigned int width = cmd::Width::Get(width_height);
-    unsigned int height = cmd::Height::Get(width_height);
-    unsigned int z = cmd::Z::Get(z_depth);
-    unsigned int depth = cmd::Depth::Get(z_depth);
-    unsigned int level = cmd::Level::Get(level_face);
-    unsigned int face = cmd::Face::Get(level_face);
-    unsigned int unused = cmd::Unused::Get(level_face);
-    if (face >= 6 || unused != 0 ||
-        size > (arg_count - 5) * sizeof(args[0]))
-      return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-    return gapi_->SetTextureData(id, x, y, z, width, height, depth, level,
-                                 static_cast<texture::Face>(face), row_pitch,
-                                 slice_pitch, size, args + 8);
-  } else {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  }
-}
-
-// Decodes the GET_TEXTURE_DATA command.
-BufferSyncInterface::ParseError GAPIDecoder::DecodeGetTextureData(
-    unsigned int arg_count,
-    CommandBufferEntry *args) {
-  if (arg_count == 10) {
-    namespace cmd = get_texture_data_cmd;
-    unsigned int id = args[0].value_uint32;
-    unsigned int x_y = args[1].value_uint32;
-    unsigned int width_height = args[2].value_uint32;
-    unsigned int z_depth = args[3].value_uint32;
-    unsigned int level_face = args[4].value_uint32;
-    unsigned int row_pitch = args[5].value_uint32;
-    unsigned int slice_pitch = args[6].value_uint32;
-    unsigned int size = args[7].value_uint32;
-    unsigned int shm_id = args[8].value_uint32;
-    unsigned int offset = args[9].value_uint32;
-    unsigned int x = cmd::X::Get(x_y);
-    unsigned int y = cmd::Y::Get(x_y);
-    unsigned int width = cmd::Width::Get(width_height);
-    unsigned int height = cmd::Height::Get(width_height);
-    unsigned int z = cmd::Z::Get(z_depth);
-    unsigned int depth = cmd::Depth::Get(z_depth);
-    unsigned int level = cmd::Level::Get(level_face);
-    unsigned int face = cmd::Face::Get(level_face);
-    unsigned int unused = cmd::Unused::Get(level_face);
-    void *data = GetAddressAndCheckSize(shm_id, offset, size);
-    if (face >= 6 || unused != 0 || !data)
-      return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-    return gapi_->GetTextureData(id, x, y, z, width, height, depth, level,
-                                 static_cast<texture::Face>(face), row_pitch,
-                                 slice_pitch, size, data);
-
-  } else {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  }
-}
-
-// Decodes the SET_SAMPLER_STATES command.
-BufferSyncInterface::ParseError GAPIDecoder::DecodeSetSamplerStates(
-    unsigned int arg_count,
-    CommandBufferEntry *args) {
-  namespace cmd = set_sampler_states;
-  if (arg_count != 2)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  ResourceID id = args[0].value_uint32;
-  Uint32 arg = args[1].value_uint32;
-  if (cmd::Unused::Get(arg) != 0)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  unsigned int address_u_value = cmd::AddressingU::Get(arg);
-  unsigned int address_v_value = cmd::AddressingV::Get(arg);
-  unsigned int address_w_value = cmd::AddressingW::Get(arg);
-  unsigned int mag_filter_value = cmd::MagFilter::Get(arg);
-  unsigned int min_filter_value = cmd::MinFilter::Get(arg);
-  unsigned int mip_filter_value = cmd::MipFilter::Get(arg);
-  unsigned int max_anisotropy = cmd::MaxAnisotropy::Get(arg);
-  if (address_u_value >= sampler::NUM_ADDRESSING_MODE ||
-      address_v_value >= sampler::NUM_ADDRESSING_MODE ||
-      address_w_value >= sampler::NUM_ADDRESSING_MODE ||
-      mag_filter_value >= sampler::NUM_FILTERING_MODE ||
-      min_filter_value >= sampler::NUM_FILTERING_MODE ||
-      mip_filter_value >= sampler::NUM_FILTERING_MODE ||
-      mag_filter_value == sampler::NONE ||
-      min_filter_value == sampler::NONE ||
-      max_anisotropy == 0) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  }
-  gapi_->SetSamplerStates(
-      id,
-      static_cast<sampler::AddressingMode>(address_u_value),
-      static_cast<sampler::AddressingMode>(address_v_value),
-      static_cast<sampler::AddressingMode>(address_w_value),
-      static_cast<sampler::FilteringMode>(mag_filter_value),
-      static_cast<sampler::FilteringMode>(min_filter_value),
-      static_cast<sampler::FilteringMode>(mip_filter_value),
-      max_anisotropy);
-  return BufferSyncInterface::PARSE_NO_ERROR;
-}
-
-// Decodes the SET_STENCIL_TEST command.
-BufferSyncInterface::ParseError GAPIDecoder::DecodeSetStencilTest(
-    unsigned int arg_count,
-    CommandBufferEntry *args) {
-  namespace cmd = set_stencil_test;
-  if (arg_count != 2)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  Uint32 arg0 = args[0].value_uint32;
-  Uint32 arg1 = args[1].value_uint32;
-  if (cmd::Unused0::Get(arg0) != 0 ||
-      cmd::Unused1::Get(arg1) != 0 ||
-      cmd::Unused2::Get(arg1) != 0)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  unsigned int write_mask = cmd::WriteMask::Get(arg0);
-  unsigned int compare_mask = cmd::CompareMask::Get(arg0);
-  unsigned int ref = cmd::ReferenceValue::Get(arg0);
-  bool enable = cmd::Enable::Get(arg0) != 0;
-  bool separate_ccw = cmd::SeparateCCW::Get(arg0) != 0;
-  gapi_->SetStencilTest(enable, separate_ccw, write_mask, compare_mask, ref,
-                        arg1);
-  return BufferSyncInterface::PARSE_NO_ERROR;
-}
-
-// Decodes the SET_BLENDING command.
-BufferSyncInterface::ParseError GAPIDecoder::DecodeSetBlending(
-    unsigned int arg_count,
-    CommandBufferEntry *args) {
-  namespace cmd = set_blending;
-  if (arg_count != 1)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  Uint32 arg = args[0].value_uint32;
-  bool enable = cmd::Enable::Get(arg) != 0;
-  bool separate_alpha = cmd::SeparateAlpha::Get(arg) != 0;
-  unsigned int color_eq = cmd::ColorEq::Get(arg);
-  unsigned int color_src = cmd::ColorSrcFunc::Get(arg);
-  unsigned int color_dst = cmd::ColorDstFunc::Get(arg);
-  unsigned int alpha_eq = cmd::AlphaEq::Get(arg);
-  unsigned int alpha_src = cmd::AlphaSrcFunc::Get(arg);
-  unsigned int alpha_dst = cmd::AlphaDstFunc::Get(arg);
-  if (cmd::Unused0::Get(arg) != 0 ||
-      cmd::Unused1::Get(arg) != 0 ||
-      color_eq >= GAPIInterface::NUM_BLEND_EQ ||
-      color_src >= GAPIInterface::NUM_BLEND_FUNC ||
-      color_dst >= GAPIInterface::NUM_BLEND_FUNC ||
-      alpha_eq >= GAPIInterface::NUM_BLEND_EQ ||
-      alpha_src >= GAPIInterface::NUM_BLEND_FUNC ||
-      alpha_dst >= GAPIInterface::NUM_BLEND_FUNC)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
-  gapi_->SetBlending(enable,
-                     separate_alpha,
-                     static_cast<GAPIInterface::BlendEq>(color_eq),
-                     static_cast<GAPIInterface::BlendFunc>(color_src),
-                     static_cast<GAPIInterface::BlendFunc>(color_dst),
-                     static_cast<GAPIInterface::BlendEq>(alpha_eq),
-                     static_cast<GAPIInterface::BlendFunc>(alpha_src),
-                     static_cast<GAPIInterface::BlendFunc>(alpha_dst));
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseUnknownCommand;
 }
 
 void *GAPIDecoder::GetAddressAndCheckSize(unsigned int shm_id,
@@ -444,426 +119,586 @@ void *GAPIDecoder::GetAddressAndCheckSize(unsigned int shm_id,
   return static_cast<char *>(shm_addr) + offset;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_NOOP(
+BufferSyncInterface::ParseError GAPIDecoder::HandleNoop(
     uint32 arg_count,
-    const cmd::NOOP& args) {
-  return BufferSyncInterface::PARSE_NO_ERROR;
+    const cmd::Noop& args) {
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_TOKEN(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetToken(
     uint32 arg_count,
-    const cmd::SET_TOKEN& args) {
+    const cmd::SetToken& args) {
   engine_->set_token(args.token);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_BEGIN_FRAME(
+BufferSyncInterface::ParseError GAPIDecoder::HandleBeginFrame(
     uint32 arg_count,
-    const cmd::BEGIN_FRAME& args) {
+    const cmd::BeginFrame& args) {
   gapi_->BeginFrame();
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_END_FRAME(
+BufferSyncInterface::ParseError GAPIDecoder::HandleEndFrame(
     uint32 arg_count,
-    const cmd::END_FRAME& args) {
+    const cmd::EndFrame& args) {
   gapi_->EndFrame();
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CLEAR(
+BufferSyncInterface::ParseError GAPIDecoder::HandleClear(
     uint32 arg_count,
-    const cmd::CLEAR& args) {
+    const cmd::Clear& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 buffers = args.buffers;
   if (buffers & ~GAPIInterface::ALL_BUFFERS)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   RGBA rgba;
   rgba.red = args.red;
   rgba.green = args.green;
   rgba.blue = args.blue;
   rgba.alpha = args.alpha;
   gapi_->Clear(buffers, rgba, args.depth, args.stencil);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_VIEWPORT(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetViewport(
     uint32 arg_count,
-    const cmd::SET_VIEWPORT& args) {
+    const cmd::SetViewport& args) {
   gapi_->SetViewport(args.left,
                      args.top,
                      args.width,
                      args.height,
                      args.z_min,
                      args.z_max);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_VERTEX_BUFFER(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateVertexBuffer(
     uint32 arg_count,
-    const cmd::CREATE_VERTEX_BUFFER& args) {
+    const cmd::CreateVertexBuffer& args) {
   return gapi_->CreateVertexBuffer(args.id, args.size, args.flags);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_VERTEX_BUFFER(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyVertexBuffer(
     uint32 arg_count,
-    const cmd::DESTROY_VERTEX_BUFFER& args) {
+    const cmd::DestroyVertexBuffer& args) {
   return gapi_->DestroyVertexBuffer(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_VERTEX_BUFFER_DATA_IMMEDIATE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetVertexBufferDataImmediate(
     uint32 arg_count,
-    const cmd::SET_VERTEX_BUFFER_DATA_IMMEDIATE& args) {
+    const cmd::SetVertexBufferDataImmediate& args) {
   return gapi_->SetVertexBufferData(args.id, args.offset,
-                                    ImmediateSize(arg_count, args),
+                                    ImmediateDataSize(arg_count, args),
                                     AddressAfterStruct(args));
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_VERTEX_BUFFER_DATA(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetVertexBufferData(
     uint32 arg_count,
-    const cmd::SET_VERTEX_BUFFER_DATA& args) {
+    const cmd::SetVertexBufferData& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->SetVertexBufferData(args.id, args.offset, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_VERTEX_BUFFER_DATA(
+BufferSyncInterface::ParseError GAPIDecoder::HandleGetVertexBufferData(
     uint32 arg_count,
-    const cmd::GET_VERTEX_BUFFER_DATA& args) {
+    const cmd::GetVertexBufferData& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->GetVertexBufferData(args.id, args.offset, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_INDEX_BUFFER(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateIndexBuffer(
     uint32 arg_count,
-    const cmd::CREATE_INDEX_BUFFER& args) {
+    const cmd::CreateIndexBuffer& args) {
   return gapi_->CreateIndexBuffer(args.id, args.size, args.flags);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_INDEX_BUFFER(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyIndexBuffer(
     uint32 arg_count,
-    const cmd::DESTROY_INDEX_BUFFER& args) {
+    const cmd::DestroyIndexBuffer& args) {
   return gapi_->DestroyIndexBuffer(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_INDEX_BUFFER_DATA_IMMEDIATE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetIndexBufferDataImmediate(
     uint32 arg_count,
-    const cmd::SET_INDEX_BUFFER_DATA_IMMEDIATE& args) {
+    const cmd::SetIndexBufferDataImmediate& args) {
   return gapi_->SetIndexBufferData(args.id, args.offset,
-                                   ImmediateSize(arg_count, args),
+                                   ImmediateDataSize(arg_count, args),
                                    AddressAfterStruct(args));
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_INDEX_BUFFER_DATA(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetIndexBufferData(
     uint32 arg_count,
-    const cmd::SET_INDEX_BUFFER_DATA& args) {
+    const cmd::SetIndexBufferData& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->SetIndexBufferData(args.id, args.offset, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_INDEX_BUFFER_DATA(
+BufferSyncInterface::ParseError GAPIDecoder::HandleGetIndexBufferData(
     uint32 arg_count,
-    const cmd::GET_INDEX_BUFFER_DATA& args) {
+    const cmd::GetIndexBufferData& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->GetIndexBufferData(args.id, args.offset, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_VERTEX_STRUCT(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateVertexStruct(
     uint32 arg_count,
-    const cmd::CREATE_VERTEX_STRUCT& args) {
+    const cmd::CreateVertexStruct& args) {
   return gapi_->CreateVertexStruct(args.id, args.input_count);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_VERTEX_STRUCT(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyVertexStruct(
     uint32 arg_count,
-    const cmd::DESTROY_VERTEX_STRUCT& args) {
+    const cmd::DestroyVertexStruct& args) {
   return gapi_->DestroyVertexStruct(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_VERTEX_INPUT(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetVertexInput(
     uint32 arg_count,
-    const cmd::SET_VERTEX_INPUT& args) {
-  // TODO(gman): fix.
-  return DecodeSetVertexInput(arg_count, TempHack(&args));
+    const cmd::SetVertexInput& args) {
+  namespace cmd = set_vertex_input_cmd;
+  unsigned int type_stride_semantic = args.fixme4;
+  unsigned int semantic_index = cmd::SemanticIndex::Get(type_stride_semantic);
+  unsigned int semantic = cmd::Semantic::Get(type_stride_semantic);
+  unsigned int type = cmd::Type::Get(type_stride_semantic);
+  unsigned int stride = cmd::Stride::Get(type_stride_semantic);
+  if (semantic >= vertex_struct::NUM_SEMANTICS ||
+      type >= vertex_struct::NUM_TYPES || stride == 0)
+    return BufferSyncInterface::kParseInvalidArguments;
+  return gapi_->SetVertexInput(
+      args.vertex_struct_id, args.input_index, args.vertex_buffer_id,
+      args.offset, stride,
+      static_cast<vertex_struct::Type>(type),
+      static_cast<vertex_struct::Semantic>(semantic),
+      semantic_index);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_VERTEX_STRUCT(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetVertexStruct(
     uint32 arg_count,
-    const cmd::SET_VERTEX_STRUCT& args) {
+    const cmd::SetVertexStruct& args) {
   return gapi_->SetVertexStruct(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DRAW(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDraw(
     uint32 arg_count,
-    const cmd::DRAW& args) {
+    const cmd::Draw& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 primitive_type = args.primitive_type;
   if (primitive_type >= GAPIInterface::MAX_PRIMITIVE_TYPE)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->Draw(
       static_cast<GAPIInterface::PrimitiveType>(primitive_type),
       args.first, args.count);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DRAW_INDEXED(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDrawIndexed(
     uint32 arg_count,
-    const cmd::DRAW_INDEXED& args) {
+    const cmd::DrawIndexed& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 primitive_type = args.primitive_type;
   if (primitive_type >= GAPIInterface::MAX_PRIMITIVE_TYPE)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->DrawIndexed(
       static_cast<GAPIInterface::PrimitiveType>(primitive_type),
       args.index_buffer_id,
       args.first, args.count, args.min_index, args.max_index);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_EFFECT(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateEffect(
     uint32 arg_count,
-    const cmd::CREATE_EFFECT& args) {
+    const cmd::CreateEffect& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->CreateEffect(args.id, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_EFFECT_IMMEDIATE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateEffectImmediate(
     uint32 arg_count,
-    const cmd::CREATE_EFFECT_IMMEDIATE& args) {
+    const cmd::CreateEffectImmediate& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
-  if (size > ImmediateSize(arg_count, args))
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  uint32 data_size = ImmediateDataSize(arg_count, args);
+  if (size > data_size)
+    return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->CreateEffect(args.id, size, AddressAfterStruct(args));
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_EFFECT(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyEffect(
     uint32 arg_count,
-    const cmd::DESTROY_EFFECT& args) {
+    const cmd::DestroyEffect& args) {
   return gapi_->DestroyEffect(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_EFFECT(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetEffect(
     uint32 arg_count,
-    const cmd::SET_EFFECT& args) {
+    const cmd::SetEffect& args) {
   return gapi_->SetEffect(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_PARAM_COUNT(
+BufferSyncInterface::ParseError GAPIDecoder::HandleGetParamCount(
     uint32 arg_count,
-    const cmd::GET_PARAM_COUNT& args) {
+    const cmd::GetParamCount& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->GetParamCount(args.id, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_PARAM(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateParam(
     uint32 arg_count,
-    const cmd::CREATE_PARAM& args) {
+    const cmd::CreateParam& args) {
   return gapi_->CreateParam(args.param_id, args.effect_id, args.index);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_PARAM_BY_NAME(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateParamByName(
     uint32 arg_count,
-    const cmd::CREATE_PARAM_BY_NAME& args) {
+    const cmd::CreateParamByName& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->CreateParamByName(args.param_id, args.effect_id, size,
                                   data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_PARAM_BY_NAME_IMMEDIATE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateParamByNameImmediate(
     uint32 arg_count,
-    const cmd::CREATE_PARAM_BY_NAME_IMMEDIATE& args) {
+    const cmd::CreateParamByNameImmediate& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
-  if (size > ImmediateSize(arg_count, args))
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  uint32 data_size = ImmediateDataSize(arg_count, args);
+  if (size > data_size)
+    return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->CreateParamByName(args.param_id, args.effect_id, size,
                                   AddressAfterStruct(args));
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_PARAM(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyParam(
     uint32 arg_count,
-    const cmd::DESTROY_PARAM& args) {
+    const cmd::DestroyParam& args) {
   return gapi_->DestroyParam(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_PARAM_DATA(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetParamData(
     uint32 arg_count,
-    const cmd::SET_PARAM_DATA& args) {
+    const cmd::SetParamData& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->SetParamData(args.id, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_PARAM_DATA_IMMEDIATE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetParamDataImmediate(
     uint32 arg_count,
-    const cmd::SET_PARAM_DATA_IMMEDIATE& args) {
+    const cmd::SetParamDataImmediate& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
-  if (size > ImmediateSize(arg_count, args))
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  uint32 data_size = ImmediateDataSize(arg_count, args);
+  if (size > data_size)
+    return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->SetParamData(args.id, size, AddressAfterStruct(args));
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_PARAM_DESC(
+BufferSyncInterface::ParseError GAPIDecoder::HandleGetParamDesc(
     uint32 arg_count,
-    const cmd::GET_PARAM_DESC& args) {
+    const cmd::GetParamDesc& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->GetParamDesc(args.id, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_STREAM_COUNT(
+BufferSyncInterface::ParseError GAPIDecoder::HandleGetStreamCount(
     uint32 arg_count,
-    const cmd::GET_STREAM_COUNT& args) {
+    const cmd::GetStreamCount& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->GetStreamCount(args.id, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_STREAM_DESC(
+BufferSyncInterface::ParseError GAPIDecoder::HandleGetStreamDesc(
     uint32 arg_count,
-    const cmd::GET_STREAM_DESC& args) {
+    const cmd::GetStreamDesc& args) {
   // Pull out some values so they can't be changed by another thread after we've
   // validated them.
   uint32 size = args.size;
   void *data = GetAddressAndCheckSize(args.shared_memory.id,
                                       args.shared_memory.offset,
                                       size);
-  if (!data) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!data) return BufferSyncInterface::kParseInvalidArguments;
   return gapi_->GetStreamDesc(args.id, args.index, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_TEXTURE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyTexture(
     uint32 arg_count,
-    const cmd::DESTROY_TEXTURE& args) {
+    const cmd::DestroyTexture& args) {
   return gapi_->DestroyTexture(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_TEXTURE_2D(
-    uint32 arg_count,
-    const cmd::CREATE_TEXTURE_2D& args) {
-  // TODO(gman): fix.
-  return DecodeCreateTexture2D(arg_count, TempHack(&args));
-}
-
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_TEXTURE_3D(
-    uint32 arg_count,
-    const cmd::CREATE_TEXTURE_3D& args) {
-  // TODO(gman): fix.
-  return DecodeCreateTexture3D(arg_count, TempHack(&args));
-}
-
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_TEXTURE_CUBE(
-    uint32 arg_count,
-    const cmd::CREATE_TEXTURE_CUBE& args) {
-  // TODO(gman): fix.
-  return DecodeCreateTextureCube(arg_count, TempHack(&args));
-}
-
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_TEXTURE_DATA(
-    uint32 arg_count,
-    const cmd::SET_TEXTURE_DATA& args) {
-  // TODO(gman): fix.
-  return DecodeSetTextureData(arg_count, TempHack(&args));
-}
-
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_TEXTURE_DATA_IMMEDIATE(
-    uint32 arg_count,
-    const cmd::SET_TEXTURE_DATA_IMMEDIATE& args) {
-  // TODO(gman): fix.
-  return DecodeSetTextureDataImmediate(arg_count, TempHack(&args));
-}
-
-BufferSyncInterface::ParseError GAPIDecoder::Handle_GET_TEXTURE_DATA(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateTexture2d(
     uint32 arg_count,
-    const cmd::GET_TEXTURE_DATA& args) {
-  // TODO(gman): fix.
-  return DecodeGetTextureData(arg_count, TempHack(&args));
+    const cmd::CreateTexture2d& args) {
+  namespace cmd = create_texture_2d_cmd;
+  unsigned int width_height = args.fixme1;
+  unsigned int levels_format_flags = args.fixme2;
+  unsigned int width = cmd::Width::Get(width_height);
+  unsigned int height = cmd::Height::Get(width_height);
+  unsigned int levels = cmd::Levels::Get(levels_format_flags);
+  unsigned int unused = cmd::Unused::Get(levels_format_flags);
+  unsigned int format = cmd::Format::Get(levels_format_flags);
+  unsigned int flags = cmd::Flags::Get(levels_format_flags);
+  unsigned int max_levels =
+      1 + base::bits::Log2Ceiling(std::max(width, height));
+  if ((width == 0) || (height == 0) || (levels > max_levels) ||
+      (unused != 0) || (format >= texture::NUM_FORMATS) || (levels == 0))
+    return BufferSyncInterface::kParseInvalidArguments;
+  bool enable_render_surfaces = !!flags;
+  return gapi_->CreateTexture2D(args.texture_id, width, height, levels,
+                                static_cast<texture::Format>(format), flags,
+                                enable_render_surfaces);
+}
+
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateTexture3d(
+    uint32 arg_count,
+    const cmd::CreateTexture3d& args) {
+  namespace cmd = create_texture_3d_cmd;
+  unsigned int width_height = args.fixme1;
+  unsigned int depth_unused = args.fixme2;
+  unsigned int levels_format_flags = args.fixme3;
+  unsigned int width = cmd::Width::Get(width_height);
+  unsigned int height = cmd::Height::Get(width_height);
+  unsigned int depth = cmd::Depth::Get(depth_unused);
+  unsigned int unused1 = cmd::Unused1::Get(depth_unused);
+  unsigned int levels = cmd::Levels::Get(levels_format_flags);
+  unsigned int unused2 = cmd::Unused2::Get(levels_format_flags);
+  unsigned int format = cmd::Format::Get(levels_format_flags);
+  unsigned int flags = cmd::Flags::Get(levels_format_flags);
+  unsigned int max_levels =
+      1 + base::bits::Log2Ceiling(std::max(depth, std::max(width, height)));
+  if ((width == 0) || (height == 0) || (depth == 0) ||
+      (levels > max_levels) || (unused1 != 0) || (unused2 != 0) ||
+      (format >= texture::NUM_FORMATS) || (levels == 0))
+    return BufferSyncInterface::kParseInvalidArguments;
+  bool enable_render_surfaces = !!flags;
+  return gapi_->CreateTexture3D(args.texture_id, width, height, depth, levels,
+                                static_cast<texture::Format>(format), flags,
+                                enable_render_surfaces);
+}
+
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateTextureCube(
+    uint32 arg_count,
+    const cmd::CreateTextureCube& args) {
+  namespace cmd = create_texture_cube_cmd;
+  unsigned int side_unused = args.edge_length;
+  unsigned int levels_format_flags = args.fixme2;
+  unsigned int side = cmd::Side::Get(side_unused);
+  unsigned int unused1 = cmd::Unused1::Get(side_unused);
+  unsigned int levels = cmd::Levels::Get(levels_format_flags);
+  unsigned int unused2 = cmd::Unused2::Get(levels_format_flags);
+  unsigned int format = cmd::Format::Get(levels_format_flags);
+  unsigned int flags = cmd::Flags::Get(levels_format_flags);
+  unsigned int max_levels = 1 + base::bits::Log2Ceiling(side);
+  if ((side == 0) || (levels > max_levels) || (unused1 != 0) ||
+      (unused2 != 0) || (format >= texture::NUM_FORMATS) || (levels == 0))
+    return BufferSyncInterface::kParseInvalidArguments;
+  bool enable_render_surfaces = !!flags;
+  return gapi_->CreateTextureCube(args.texture_id, side, levels,
+                                  static_cast<texture::Format>(format),
+                                  flags, enable_render_surfaces);
+}
+
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetTextureData(
+    uint32 arg_count,
+    const cmd::SetTextureData& args) {
+  namespace cmd = set_texture_data_cmd;
+  unsigned int x_y = args.fixme1;
+  unsigned int width_height = args.fixme2;
+  unsigned int z_depth = args.fixme3;
+  unsigned int level_face = args.fixme4;
+  unsigned int size = args.size;
+  unsigned int x = cmd::X::Get(x_y);
+  unsigned int y = cmd::Y::Get(x_y);
+  unsigned int width = cmd::Width::Get(width_height);
+  unsigned int height = cmd::Height::Get(width_height);
+  unsigned int z = cmd::Z::Get(z_depth);
+  unsigned int depth = cmd::Depth::Get(z_depth);
+  unsigned int level = cmd::Level::Get(level_face);
+  unsigned int face = cmd::Face::Get(level_face);
+  unsigned int unused = cmd::Unused::Get(level_face);
+  const void *data = GetAddressAndCheckSize(args.shared_memory.id,
+                                            args.shared_memory.offset, size);
+  if (face >= 6 || unused != 0 || !data)
+    return BufferSyncInterface::kParseInvalidArguments;
+  return gapi_->SetTextureData(
+      args.texture_id, x, y, z, width, height, depth, level,
+      static_cast<texture::Face>(face), args.row_pitch,
+      args.slice_pitch, size, data);
+}
+
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetTextureDataImmediate(
+    uint32 arg_count,
+    const cmd::SetTextureDataImmediate& args) {
+  namespace cmd = set_texture_data_immediate_cmd;
+  unsigned int x_y = args.fixme1;
+  unsigned int width_height = args.fixme2;
+  unsigned int z_depth = args.fixme3;
+  unsigned int level_face = args.fixme4;
+  unsigned int size = args.size;
+  unsigned int x = cmd::X::Get(x_y);
+  unsigned int y = cmd::Y::Get(x_y);
+  unsigned int width = cmd::Width::Get(width_height);
+  unsigned int height = cmd::Height::Get(width_height);
+  unsigned int z = cmd::Z::Get(z_depth);
+  unsigned int depth = cmd::Depth::Get(z_depth);
+  unsigned int level = cmd::Level::Get(level_face);
+  unsigned int face = cmd::Face::Get(level_face);
+  unsigned int unused = cmd::Unused::Get(level_face);
+  uint32 data_size = ImmediateDataSize(arg_count, args);
+  if (face >= 6 || unused != 0 ||
+      size > data_size)
+    return BufferSyncInterface::kParseInvalidArguments;
+  return gapi_->SetTextureData(
+      args.texture_id, x, y, z, width, height, depth, level,
+      static_cast<texture::Face>(face), args.row_pitch,
+      args.slice_pitch, size, AddressAfterStruct(args));
+}
+
+BufferSyncInterface::ParseError GAPIDecoder::HandleGetTextureData(
+    uint32 arg_count,
+    const cmd::GetTextureData& args) {
+  namespace cmd = get_texture_data_cmd;
+  unsigned int x_y = args.fixme1;
+  unsigned int width_height = args.fixme2;
+  unsigned int z_depth = args.fixme3;
+  unsigned int level_face = args.fixme4;
+  unsigned int size = args.size;
+  unsigned int x = cmd::X::Get(x_y);
+  unsigned int y = cmd::Y::Get(x_y);
+  unsigned int width = cmd::Width::Get(width_height);
+  unsigned int height = cmd::Height::Get(width_height);
+  unsigned int z = cmd::Z::Get(z_depth);
+  unsigned int depth = cmd::Depth::Get(z_depth);
+  unsigned int level = cmd::Level::Get(level_face);
+  unsigned int face = cmd::Face::Get(level_face);
+  unsigned int unused = cmd::Unused::Get(level_face);
+  void *data = GetAddressAndCheckSize(args.shared_memory.id,
+                                      args.shared_memory.offset, size);
+  if (face >= 6 || unused != 0 || !data)
+    return BufferSyncInterface::kParseInvalidArguments;
+  return gapi_->GetTextureData(
+      args.texture_id, x, y, z, width, height, depth, level,
+      static_cast<texture::Face>(face), args.row_pitch,
+      args.slice_pitch, size, data);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_SAMPLER(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateSampler(
     uint32 arg_count,
-    const cmd::CREATE_SAMPLER& args) {
+    const cmd::CreateSampler& args) {
   return gapi_->CreateSampler(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_SAMPLER(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDestroySampler(
     uint32 arg_count,
-    const cmd::DESTROY_SAMPLER& args) {
+    const cmd::DestroySampler& args) {
   return gapi_->DestroySampler(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SAMPLER_STATES(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetSamplerStates(
     uint32 arg_count,
-    const cmd::SET_SAMPLER_STATES& args) {
-  // TODO(gman): fix.
-  return DecodeSetSamplerStates(arg_count, TempHack(&args));
+    const cmd::SetSamplerStates& args) {
+  namespace cmd = set_sampler_states;
+  Uint32 arg = args.fixme1;
+  if (cmd::Unused::Get(arg) != 0)
+    return BufferSyncInterface::kParseInvalidArguments;
+  unsigned int address_u_value = cmd::AddressingU::Get(arg);
+  unsigned int address_v_value = cmd::AddressingV::Get(arg);
+  unsigned int address_w_value = cmd::AddressingW::Get(arg);
+  unsigned int mag_filter_value = cmd::MagFilter::Get(arg);
+  unsigned int min_filter_value = cmd::MinFilter::Get(arg);
+  unsigned int mip_filter_value = cmd::MipFilter::Get(arg);
+  unsigned int max_anisotropy = cmd::MaxAnisotropy::Get(arg);
+  if (address_u_value >= sampler::NUM_ADDRESSING_MODE ||
+      address_v_value >= sampler::NUM_ADDRESSING_MODE ||
+      address_w_value >= sampler::NUM_ADDRESSING_MODE ||
+      mag_filter_value >= sampler::NUM_FILTERING_MODE ||
+      min_filter_value >= sampler::NUM_FILTERING_MODE ||
+      mip_filter_value >= sampler::NUM_FILTERING_MODE ||
+      mag_filter_value == sampler::NONE ||
+      min_filter_value == sampler::NONE ||
+      max_anisotropy == 0) {
+    return BufferSyncInterface::kParseInvalidArguments;
+  }
+  gapi_->SetSamplerStates(
+      args.id,
+      static_cast<sampler::AddressingMode>(address_u_value),
+      static_cast<sampler::AddressingMode>(address_v_value),
+      static_cast<sampler::AddressingMode>(address_w_value),
+      static_cast<sampler::FilteringMode>(mag_filter_value),
+      static_cast<sampler::FilteringMode>(min_filter_value),
+      static_cast<sampler::FilteringMode>(mip_filter_value),
+      max_anisotropy);
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SAMPLER_BORDER_COLOR(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetSamplerBorderColor(
     uint32 arg_count,
-    const cmd::SET_SAMPLER_BORDER_COLOR& args) {
+    const cmd::SetSamplerBorderColor& args) {
   RGBA rgba;
   rgba.red = args.red;
   rgba.green = args.green;
@@ -872,19 +707,19 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SAMPLER_BORDER_COLOR(
   return gapi_->SetSamplerBorderColor(args.id, rgba);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SAMPLER_TEXTURE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetSamplerTexture(
     uint32 arg_count,
-    const cmd::SET_SAMPLER_TEXTURE& args) {
+    const cmd::SetSamplerTexture& args) {
   return gapi_->SetSamplerTexture(args.id, args.texture_id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SCISSOR(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetScissor(
     uint32 arg_count,
-    const cmd::SET_SCISSOR& args) {
+    const cmd::SetScissor& args) {
   namespace cmd = set_scissor;
   Uint32 x_y_enable = args.fixme0;
   if (cmd::Unused::Get(x_y_enable) != 0)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   unsigned int x = cmd::X::Get(x_y_enable);
   unsigned int y = cmd::Y::Get(x_y_enable);
   bool enable = cmd::Enable::Get(x_y_enable) != 0;
@@ -892,32 +727,32 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_SCISSOR(
   unsigned int width = cmd::Width::Get(width_height);
   unsigned int height = cmd::Height::Get(width_height);
   gapi_->SetScissor(enable, x, y, width, height);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_POLYGON_OFFSET(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetPolygonOffset(
     uint32 arg_count,
-    const cmd::SET_POLYGON_OFFSET& args) {
+    const cmd::SetPolygonOffset& args) {
   gapi_->SetPolygonOffset(args.slope_factor, args.units);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_POINT_LINE_RASTER(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetPointLineRaster(
     uint32 arg_count,
-    const cmd::SET_POINT_LINE_RASTER& args) {
+    const cmd::SetPointLineRaster& args) {
   namespace cmd = set_point_line_raster;
   Uint32 enables = args.fixme0;
   if (cmd::Unused::Get(enables) != 0)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   bool line_smooth = !!cmd::LineSmoothEnable::Get(enables);
   bool point_sprite = !!cmd::PointSpriteEnable::Get(enables);
   gapi_->SetPointLineRaster(line_smooth, point_sprite, args.point_size);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_POLYGON_RASTER(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetPolygonRaster(
     uint32 arg_count,
-    const cmd::SET_POLYGON_RASTER& args) {
+    const cmd::SetPolygonRaster& args) {
   namespace cmd = set_polygon_raster;
   Uint32 fill_cull = args.fixme0;
   unsigned int fill_value = cmd::FillMode::Get(fill_cull);
@@ -925,20 +760,20 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_POLYGON_RASTER(
   if (cmd::Unused::Get(fill_cull) != 0 ||
       fill_value >= GAPIInterface::NUM_POLYGON_MODE ||
       cull_value >= GAPIInterface::NUM_FACE_CULL_MODE)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   gapi_->SetPolygonRaster(
       static_cast<GAPIInterface::PolygonMode>(fill_value),
       static_cast<GAPIInterface::FaceCullMode>(cull_value));
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_ALPHA_TEST(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetAlphaTest(
     uint32 arg_count,
-    const cmd::SET_ALPHA_TEST& args) {
+    const cmd::SetAlphaTest& args) {
   namespace cmd = set_alpha_test;
   Uint32 func_enable = args.fixme0;
   if (cmd::Unused::Get(func_enable) != 0)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   // Check that the bitmask get cannot generate values outside of the
   // allowed range.
   COMPILE_ASSERT(cmd::Func::kMask < GAPIInterface::NUM_COMPARISON,
@@ -947,16 +782,16 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_ALPHA_TEST(
       static_cast<GAPIInterface::Comparison>(cmd::Func::Get(func_enable));
   bool enable = cmd::Enable::Get(func_enable) != 0;
   gapi_->SetAlphaTest(enable, args.value, comp);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_DEPTH_TEST(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetDepthTest(
     uint32 arg_count,
-    const cmd::SET_DEPTH_TEST& args) {
+    const cmd::SetDepthTest& args) {
   namespace cmd = set_depth_test;
   Uint32 func_enable = args.fixme0;
   if (cmd::Unused::Get(func_enable) != 0)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   // Check that the bitmask get cannot generate values outside of the
   // allowed range.
   COMPILE_ASSERT(cmd::Func::kMask < GAPIInterface::NUM_COMPARISON,
@@ -966,53 +801,93 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_DEPTH_TEST(
   bool write_enable = cmd::WriteEnable::Get(func_enable) != 0;
   bool enable = cmd::Enable::Get(func_enable) != 0;
   gapi_->SetDepthTest(enable, write_enable, comp);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_STENCIL_TEST(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetStencilTest(
     uint32 arg_count,
-    const cmd::SET_STENCIL_TEST& args) {
-  // TODO(gman): fix.
-  return DecodeSetStencilTest(arg_count, TempHack(&args));
+    const cmd::SetStencilTest& args) {
+  namespace cmd = set_stencil_test;
+  Uint32 arg0 = args.fixme0;
+  Uint32 arg1 = args.fixme1;
+  if (cmd::Unused0::Get(arg0) != 0 ||
+      cmd::Unused1::Get(arg1) != 0 ||
+      cmd::Unused2::Get(arg1) != 0)
+    return BufferSyncInterface::kParseInvalidArguments;
+  unsigned int write_mask = cmd::WriteMask::Get(arg0);
+  unsigned int compare_mask = cmd::CompareMask::Get(arg0);
+  unsigned int ref = cmd::ReferenceValue::Get(arg0);
+  bool enable = cmd::Enable::Get(arg0) != 0;
+  bool separate_ccw = cmd::SeparateCCW::Get(arg0) != 0;
+  gapi_->SetStencilTest(enable, separate_ccw, write_mask, compare_mask, ref,
+                        arg1);
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_COLOR_WRITE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetColorWrite(
     uint32 arg_count,
-    const cmd::SET_COLOR_WRITE& args) {
+    const cmd::SetColorWrite& args) {
   namespace cmd = set_color_write;
   Uint32 enables = args.flags;
   if (cmd::Unused::Get(enables) != 0)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   bool red = cmd::RedMask::Get(enables) != 0;
   bool green = cmd::GreenMask::Get(enables) != 0;
   bool blue = cmd::BlueMask::Get(enables) != 0;
   bool alpha = cmd::AlphaMask::Get(enables) != 0;
   bool dither = cmd::DitherEnable::Get(enables) != 0;
   gapi_->SetColorWrite(red, green, blue, alpha, dither);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_BLENDING(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetBlending(
     uint32 arg_count,
-    const cmd::SET_BLENDING& args) {
-  return DecodeSetBlending(arg_count, TempHack(&args));
+    const cmd::SetBlending& args) {
+  namespace cmd = set_blending;
+  Uint32 arg = args.fixme0;
+  bool enable = cmd::Enable::Get(arg) != 0;
+  bool separate_alpha = cmd::SeparateAlpha::Get(arg) != 0;
+  unsigned int color_eq = cmd::ColorEq::Get(arg);
+  unsigned int color_src = cmd::ColorSrcFunc::Get(arg);
+  unsigned int color_dst = cmd::ColorDstFunc::Get(arg);
+  unsigned int alpha_eq = cmd::AlphaEq::Get(arg);
+  unsigned int alpha_src = cmd::AlphaSrcFunc::Get(arg);
+  unsigned int alpha_dst = cmd::AlphaDstFunc::Get(arg);
+  if (cmd::Unused0::Get(arg) != 0 ||
+      cmd::Unused1::Get(arg) != 0 ||
+      color_eq >= GAPIInterface::NUM_BLEND_EQ ||
+      color_src >= GAPIInterface::NUM_BLEND_FUNC ||
+      color_dst >= GAPIInterface::NUM_BLEND_FUNC ||
+      alpha_eq >= GAPIInterface::NUM_BLEND_EQ ||
+      alpha_src >= GAPIInterface::NUM_BLEND_FUNC ||
+      alpha_dst >= GAPIInterface::NUM_BLEND_FUNC)
+    return BufferSyncInterface::kParseInvalidArguments;
+  gapi_->SetBlending(enable,
+                     separate_alpha,
+                     static_cast<GAPIInterface::BlendEq>(color_eq),
+                     static_cast<GAPIInterface::BlendFunc>(color_src),
+                     static_cast<GAPIInterface::BlendFunc>(color_dst),
+                     static_cast<GAPIInterface::BlendEq>(alpha_eq),
+                     static_cast<GAPIInterface::BlendFunc>(alpha_src),
+                     static_cast<GAPIInterface::BlendFunc>(alpha_dst));
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_BLENDING_COLOR(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetBlendingColor(
     uint32 arg_count,
-    const cmd::SET_BLENDING_COLOR& args) {
+    const cmd::SetBlendingColor& args) {
   RGBA rgba;
   rgba.red = args.red;
   rgba.green = args.green;
   rgba.blue = args.blue;
   rgba.alpha = args.alpha;
   gapi_->SetBlendingColor(rgba);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_RENDER_SURFACE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateRenderSurface(
     uint32 arg_count,
-    const cmd::CREATE_RENDER_SURFACE& args) {
+    const cmd::CreateRenderSurface& args) {
   namespace cmd = create_render_surface_cmd;
   unsigned int width_height = args.fixme1;
   unsigned int width = cmd::Width::Get(width_height);
@@ -1024,39 +899,39 @@ BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_RENDER_SURFACE(
                                     side, args.texture_id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_RENDER_SURFACE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyRenderSurface(
     uint32 arg_count,
-    const cmd::DESTROY_RENDER_SURFACE& args) {
+    const cmd::DestroyRenderSurface& args) {
   return gapi_->DestroyRenderSurface(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_CREATE_DEPTH_SURFACE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleCreateDepthSurface(
     uint32 arg_count,
-    const cmd::CREATE_DEPTH_SURFACE& args) {
-  namespace cmd = create_render_surface_cmd;
+    const cmd::CreateDepthSurface& args) {
+  namespace cmd = create_depth_surface_cmd;
   unsigned int width_height = args.fixme1;
   unsigned int width = cmd::Width::Get(width_height);
   unsigned int height = cmd::Height::Get(width_height);
   return gapi_->CreateDepthSurface(args.id, width, height);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_DESTROY_DEPTH_SURFACE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleDestroyDepthSurface(
     uint32 arg_count,
-    const cmd::DESTROY_DEPTH_SURFACE& args) {
+    const cmd::DestroyDepthSurface& args) {
   return gapi_->DestroyDepthSurface(args.id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_RENDER_SURFACE(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetRenderSurface(
     uint32 arg_count,
-    const cmd::SET_RENDER_SURFACE& args) {
+    const cmd::SetRenderSurface& args) {
   return gapi_->SetRenderSurface(args.render_surface_id, args.depth_surface_id);
 }
 
-BufferSyncInterface::ParseError GAPIDecoder::Handle_SET_BACK_SURFACES(
+BufferSyncInterface::ParseError GAPIDecoder::HandleSetBackSurfaces(
     uint32 arg_count,
-    const cmd::SET_BACK_SURFACES& args) {
+    const cmd::SetBackSurfaces& args) {
   gapi_->SetBackSurfaces();
-  return  BufferSyncInterface::PARSE_NO_ERROR;
+  return  BufferSyncInterface::kParseNoError;
 }
 
 }  // namespace command_buffer
diff --git a/o3d/command_buffer/service/cross/gapi_decoder.h b/o3d/command_buffer/service/cross/gapi_decoder.h
index 67b1806..a9af75c 100644
--- a/o3d/command_buffer/service/cross/gapi_decoder.h
+++ b/o3d/command_buffer/service/cross/gapi_decoder.h
@@ -52,14 +52,8 @@ class GAPIDecoder : public AsyncAPIInterface {
 
   explicit GAPIDecoder(GAPIInterface *gapi) : gapi_(gapi), engine_(NULL) {}
   virtual ~GAPIDecoder() {}
-  // Executes a command.
-  // Parameters:
-  //    command: the command index.
-  //    arg_count: the number of CommandBufferEntry arguments.
-  //    args: the arguments.
-  // Returns:
-  //   BufferSyncInterface::NO_ERROR if no error was found, one of
-  //   BufferSyncInterface::ParseError otherwise.
+
+  // Overridden from AsyncAPIInterface.
   virtual ParseError DoCommand(unsigned int command,
                                unsigned int arg_count,
                                const void* args);
@@ -68,46 +62,6 @@ class GAPIDecoder : public AsyncAPIInterface {
   // to.
   void set_engine(CommandBufferEngine *engine) { engine_ = engine; }
  private:
-  // Decodes the SET_VERTEX_INPUT command.
-  ParseError DecodeSetVertexInput(unsigned int arg_count,
-                                  CommandBufferEntry *args);
-
-  // Decodes the CREATE_TEXTURE_2D command.
-  ParseError DecodeCreateTexture2D(unsigned int arg_count,
-                                   CommandBufferEntry *args);
-
-  // Decodes the CREATE_TEXTURE_3D command.
-  ParseError DecodeCreateTexture3D(unsigned int arg_count,
-                                   CommandBufferEntry *args);
-
-  // Decodes the CREATE_TEXTURE_CUBE command.
-  ParseError DecodeCreateTextureCube(unsigned int arg_count,
-                                     CommandBufferEntry *args);
-
-  // Decodes the SET_TEXTURE_DATA command.
-  ParseError DecodeSetTextureData(unsigned int arg_count,
-                                  CommandBufferEntry *args);
-
-  // Decodes the SET_TEXTURE_DATA_IMMEDIATE command.
-  ParseError DecodeSetTextureDataImmediate(unsigned int arg_count,
-                                           CommandBufferEntry *args);
-
-  // Decodes the GET_TEXTURE_DATA command.
-  ParseError DecodeGetTextureData(unsigned int arg_count,
-                                  CommandBufferEntry *args);
-
-  // Decodes the SET_SAMPLER_STATES command.
-  ParseError DecodeSetSamplerStates(unsigned int arg_count,
-                                    CommandBufferEntry *args);
-
-  // Decodes the SET_STENCIL_TEST command.
-  ParseError DecodeSetStencilTest(unsigned int arg_count,
-                                  CommandBufferEntry *args);
-
-  // Decodes the SET_BLENDING command.
-  ParseError DecodeSetBlending(unsigned int arg_count,
-                               CommandBufferEntry *args);
-
   // Gets the address of shared memory data, given a shared memory ID and an
   // offset. Also checks that the size is consistent with the shared memory
   // size.
@@ -125,7 +79,7 @@ class GAPIDecoder : public AsyncAPIInterface {
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
   #define O3D_COMMAND_BUFFER_CMD_OP(name) \
-     ParseError Handle_ ## name(          \
+     ParseError Handle ## name(           \
        unsigned int arg_count,            \
        const cmd::name& args);            \
 
diff --git a/o3d/command_buffer/service/cross/gl/effect_gl.cc b/o3d/command_buffer/service/cross/gl/effect_gl.cc
index c2c49e3..3c0baf6 100644
--- a/o3d/command_buffer/service/cross/gl/effect_gl.cc
+++ b/o3d/command_buffer/service/cross/gl/effect_gl.cc
@@ -720,27 +720,27 @@ BufferSyncInterface::ParseError GAPIGL::CreateEffect(ResourceID id,
                        &vertex_program_entry,
                        &fragment_program_entry,
                        &effect_code)) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   EffectGL * effect = EffectGL::Create(this, effect_code,
                                        vertex_program_entry,
                                        fragment_program_entry);
-  if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   effects_.Assign(id, effect);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::DestroyEffect(ResourceID id) {
   if (id == current_effect_id_) DirtyEffect();
   return effects_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::SetEffect(ResourceID id) {
   DirtyEffect();
   current_effect_id_ = id;
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::GetParamCount(ResourceID id,
@@ -748,20 +748,20 @@ BufferSyncInterface::ParseError GAPIGL::GetParamCount(ResourceID id,
                                                       void *data) {
   EffectGL *effect = effects_.Get(id);
   if (!effect || size < sizeof(Uint32))  // NOLINT
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   *static_cast<Uint32 *>(data) = effect->GetParamCount();
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::CreateParam(ResourceID param_id,
                                                     ResourceID effect_id,
                                                     unsigned int index) {
   EffectGL *effect = effects_.Get(effect_id);
-  if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   EffectParamGL *param = effect->CreateParam(index);
-  if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!param) return BufferSyncInterface::kParseInvalidArguments;
   effect_params_.Assign(param_id, param);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::CreateParamByName(ResourceID param_id,
@@ -769,38 +769,38 @@ BufferSyncInterface::ParseError GAPIGL::CreateParamByName(ResourceID param_id,
                                                           unsigned int size,
                                                           const void *name) {
   EffectGL *effect = effects_.Get(effect_id);
-  if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   std::string string_name(static_cast<const char *>(name), size);
   EffectParamGL *param = effect->CreateParamByName(string_name.c_str());
-  if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!param) return BufferSyncInterface::kParseInvalidArguments;
   effect_params_.Assign(param_id, param);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::DestroyParam(ResourceID id) {
   return effect_params_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::SetParamData(ResourceID id,
                                                      unsigned int size,
                                                      const void *data) {
   EffectParamGL *param = effect_params_.Get(id);
-  if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!param) return BufferSyncInterface::kParseInvalidArguments;
   return param->SetData(this, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::GetParamDesc(ResourceID id,
                                                      unsigned int size,
                                                      void *data) {
   EffectParamGL *param = effect_params_.Get(id);
-  if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!param) return BufferSyncInterface::kParseInvalidArguments;
   return param->GetDesc(size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::GetStreamCount(
@@ -809,9 +809,9 @@ BufferSyncInterface::ParseError GAPIGL::GetStreamCount(
     void *data) {
   EffectGL *effect = effects_.Get(id);
   if (!effect || size < sizeof(Uint32))  // NOLINT
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   *static_cast<Uint32 *>(data) = effect->GetStreamCount();
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::GetStreamDesc(ResourceID id,
@@ -819,10 +819,10 @@ BufferSyncInterface::ParseError GAPIGL::GetStreamDesc(ResourceID id,
                                                       unsigned int size,
                                                       void *data) {
   EffectGL *effect = effects_.Get(id);
-  if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   return effect->GetStreamDesc(index, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // If the current effect is valid, call End on it, and tag for revalidation.
diff --git a/o3d/command_buffer/service/cross/gl/geometry_gl.cc b/o3d/command_buffer/service/cross/gl/geometry_gl.cc
index c6e1dc8..58bf819 100644
--- a/o3d/command_buffer/service/cross/gl/geometry_gl.cc
+++ b/o3d/command_buffer/service/cross/gl/geometry_gl.cc
@@ -311,13 +311,13 @@ BufferSyncInterface::ParseError GAPIGL::CreateVertexBuffer(ResourceID id,
   VertexBufferGL *vertex_buffer = new VertexBufferGL(size, flags);
   vertex_buffer->Create();
   vertex_buffers_.Assign(id, vertex_buffer);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::DestroyVertexBuffer(ResourceID id) {
   return vertex_buffers_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::SetVertexBufferData(ResourceID id,
@@ -325,10 +325,10 @@ BufferSyncInterface::ParseError GAPIGL::SetVertexBufferData(ResourceID id,
                                                             unsigned int size,
                                                             const void *data) {
   VertexBufferGL *vertex_buffer = vertex_buffers_.Get(id);
-  if (!vertex_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return vertex_buffer->SetData(offset, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::GetVertexBufferData(ResourceID id,
@@ -336,10 +336,10 @@ BufferSyncInterface::ParseError GAPIGL::GetVertexBufferData(ResourceID id,
                                                             unsigned int size,
                                                             void *data) {
   VertexBufferGL *vertex_buffer = vertex_buffers_.Get(id);
-  if (!vertex_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return vertex_buffer->GetData(offset, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::CreateIndexBuffer(ResourceID id,
@@ -348,13 +348,13 @@ BufferSyncInterface::ParseError GAPIGL::CreateIndexBuffer(ResourceID id,
   IndexBufferGL *index_buffer = new IndexBufferGL(size, flags);
   index_buffer->Create();
   index_buffers_.Assign(id, index_buffer);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::DestroyIndexBuffer(ResourceID id) {
   return index_buffers_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::SetIndexBufferData(ResourceID id,
@@ -362,10 +362,10 @@ BufferSyncInterface::ParseError GAPIGL::SetIndexBufferData(ResourceID id,
                                                            unsigned int size,
                                                            const void *data) {
   IndexBufferGL *index_buffer = index_buffers_.Get(id);
-  if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return index_buffer->SetData(offset, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::GetIndexBufferData(ResourceID id,
@@ -373,10 +373,10 @@ BufferSyncInterface::ParseError GAPIGL::GetIndexBufferData(ResourceID id,
                                                            unsigned int size,
                                                            void *data) {
   IndexBufferGL *index_buffer = index_buffers_.Get(id);
-  if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return index_buffer->GetData(offset, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::CreateVertexStruct(
@@ -385,14 +385,14 @@ BufferSyncInterface::ParseError GAPIGL::CreateVertexStruct(
   if (id == current_vertex_struct_) validate_streams_ = true;
   VertexStructGL *vertex_struct = new VertexStructGL(input_count);
   vertex_structs_.Assign(id, vertex_struct);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::DestroyVertexStruct(ResourceID id) {
   if (id == current_vertex_struct_) validate_streams_ = true;
   return vertex_structs_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::SetVertexInput(
@@ -407,22 +407,22 @@ BufferSyncInterface::ParseError GAPIGL::SetVertexInput(
   switch (semantic) {
     case vertex_struct::POSITION:
       if (semantic_index != 0) {
-        return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+        return BufferSyncInterface::kParseInvalidArguments;
       }
       break;
     case vertex_struct::NORMAL:
       if (semantic_index != 0) {
-        return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+        return BufferSyncInterface::kParseInvalidArguments;
       }
       break;
     case vertex_struct::COLOR:
       if (semantic_index >= 2) {
-        return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+        return BufferSyncInterface::kParseInvalidArguments;
       }
       break;
     case vertex_struct::TEX_COORD:
       if (semantic_index >= 8) {
-        return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+        return BufferSyncInterface::kParseInvalidArguments;
       }
       break;
     default:
@@ -432,16 +432,16 @@ BufferSyncInterface::ParseError GAPIGL::SetVertexInput(
   if (vertex_buffer_id == current_vertex_struct_) validate_streams_ = true;
   VertexStructGL *vertex_struct = vertex_structs_.Get(vertex_struct_id);
   if (!vertex_struct || input_index >= vertex_struct->count())
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   vertex_struct->SetInput(input_index, vertex_buffer_id, offset, stride, type,
                           semantic, semantic_index);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::SetVertexStruct(ResourceID id) {
   current_vertex_struct_ = id;
   validate_streams_ = true;
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 bool GAPIGL::ValidateStreams() {
@@ -497,20 +497,20 @@ BufferSyncInterface::ParseError GAPIGL::Draw(PrimitiveType primitive_type,
                                              unsigned int first,
                                              unsigned int count) {
   if (validate_effect_ && !ValidateEffect()) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   DCHECK(current_effect_);
   if (validate_streams_ && !ValidateStreams()) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   GLenum gl_mode = GL_POINTS;
   PrimitiveTypeToGL(primitive_type, &gl_mode, &count);
   if (first + count > max_vertices_) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   glDrawArrays(gl_mode, first, count);
   CHECK_GL_ERROR();
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::DrawIndexed(
@@ -521,16 +521,16 @@ BufferSyncInterface::ParseError GAPIGL::DrawIndexed(
     unsigned int min_index,
     unsigned int max_index) {
   IndexBufferGL *index_buffer = index_buffers_.Get(index_buffer_id);
-  if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   if (validate_effect_ && !ValidateEffect()) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   DCHECK(current_effect_);
   if (validate_streams_ && !ValidateStreams()) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   if ((min_index >= max_vertices_) || (max_index > max_vertices_)) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   GLenum gl_mode = GL_POINTS;
   PrimitiveTypeToGL(primitive_type, &gl_mode, &count);
@@ -541,12 +541,12 @@ BufferSyncInterface::ParseError GAPIGL::DrawIndexed(
                       sizeof(GLuint) : sizeof(GLushort);  // NOLINT
   GLuint offset = first * index_size;
   if (offset + count * index_size > index_buffer->size()) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   glDrawRangeElements(gl_mode, min_index, max_index, count, index_type,
                       OffsetToPtr(offset));
   CHECK_GL_ERROR();
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 }  // namespace command_buffer
diff --git a/o3d/command_buffer/service/cross/gl/sampler_gl.cc b/o3d/command_buffer/service/cross/gl/sampler_gl.cc
index cbd1d1b..6bcc9488 100644
--- a/o3d/command_buffer/service/cross/gl/sampler_gl.cc
+++ b/o3d/command_buffer/service/cross/gl/sampler_gl.cc
@@ -178,7 +178,7 @@ BufferSyncInterface::ParseError GAPIGL::CreateSampler(
   // Dirty effect, because this sampler id may be used.
   DirtyEffect();
   samplers_.Assign(id, new SamplerGL());
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Destroys the Sampler resource.
@@ -186,8 +186,8 @@ BufferSyncInterface::ParseError GAPIGL::DestroySampler(ResourceID id) {
   // Dirty effect, because this sampler id may be used.
   DirtyEffect();
   return samplers_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPIGL::SetSamplerStates(
@@ -201,12 +201,12 @@ BufferSyncInterface::ParseError GAPIGL::SetSamplerStates(
     unsigned int max_anisotropy) {
   SamplerGL *sampler = samplers_.Get(id);
   if (!sampler)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this sampler id may be used.
   DirtyEffect();
   sampler->SetStates(addressing_u, addressing_v, addressing_w,
                      mag_filter, min_filter, mip_filter, max_anisotropy);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::SetSamplerBorderColor(
@@ -214,11 +214,11 @@ BufferSyncInterface::ParseError GAPIGL::SetSamplerBorderColor(
     const RGBA &color) {
   SamplerGL *sampler = samplers_.Get(id);
   if (!sampler)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this sampler id may be used.
   DirtyEffect();
   sampler->SetBorderColor(color);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPIGL::SetSamplerTexture(
@@ -226,11 +226,11 @@ BufferSyncInterface::ParseError GAPIGL::SetSamplerTexture(
     ResourceID texture_id) {
   SamplerGL *sampler = samplers_.Get(id);
   if (!sampler)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this sampler id may be used.
   DirtyEffect();
   sampler->SetTexture(texture_id);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 
diff --git a/o3d/command_buffer/service/cross/gl/texture_gl.cc b/o3d/command_buffer/service/cross/gl/texture_gl.cc
index 8280b77..6dcdd09 100644
--- a/o3d/command_buffer/service/cross/gl/texture_gl.cc
+++ b/o3d/command_buffer/service/cross/gl/texture_gl.cc
@@ -631,8 +631,8 @@ BufferSyncInterface::ParseError GAPIGL::DestroyTexture(ResourceID id) {
   // Dirty effect, because this texture id may be used.
   DirtyEffect();
   return textures_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Creates a 2D texture resource.
@@ -646,11 +646,11 @@ BufferSyncInterface::ParseError GAPIGL::CreateTexture2D(
     bool enable_render_surfaces) {
   Texture2DGL *texture = Texture2DGL::Create(
       width, height, levels, format, flags, enable_render_surfaces);
-  if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!texture) return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this texture id may be used.
   DirtyEffect();
   textures_.Assign(id, texture);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Creates a 3D texture resource.
@@ -665,11 +665,11 @@ BufferSyncInterface::ParseError GAPIGL::CreateTexture3D(
     bool enable_render_surfaces) {
   Texture3DGL *texture = Texture3DGL::Create(
       width, height, depth, levels, format, flags, enable_render_surfaces);
-  if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!texture) return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this texture id may be used.
   DirtyEffect();
   textures_.Assign(id, texture);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Creates a cube map texture resource.
@@ -682,11 +682,11 @@ BufferSyncInterface::ParseError GAPIGL::CreateTextureCube(
     bool enable_render_surfaces) {
   TextureCubeGL *texture = TextureCubeGL::Create(
       side, levels, format, flags, enable_render_surfaces);
-  if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!texture) return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this texture id may be used.
   DirtyEffect();
   textures_.Assign(id, texture);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Copies the data into a texture resource.
@@ -706,15 +706,15 @@ BufferSyncInterface::ParseError GAPIGL::SetTextureData(
     const void *data) {
   TextureGL *texture = textures_.Get(id);
   if (!texture)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   Volume volume = {x, y, z, width, height, depth};
   // Dirty effect: SetData may need to call glBindTexture which will mess up the
   // sampler parameters.
   DirtyEffect();
   return texture->SetData(volume, level, face, row_pitch, slice_pitch,
                           size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data from a texture resource.
@@ -734,15 +734,15 @@ BufferSyncInterface::ParseError GAPIGL::GetTextureData(
     void *data) {
   TextureGL *texture = textures_.Get(id);
   if (!texture)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   Volume volume = {x, y, z, width, height, depth};
   // Dirty effect: GetData may need to call glBindTexture which will mess up the
   // sampler parameters.
   DirtyEffect();
   return texture->GetData(volume, level, face, row_pitch, slice_pitch,
                           size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 }  // namespace command_buffer
diff --git a/o3d/command_buffer/service/cross/mocks.h b/o3d/command_buffer/service/cross/mocks.h
index 353ff0c..dbd4c62 100644
--- a/o3d/command_buffer/service/cross/mocks.h
+++ b/o3d/command_buffer/service/cross/mocks.h
@@ -52,7 +52,7 @@ class AsyncAPIMock : public AsyncAPIInterface {
  public:
   AsyncAPIMock() {
     testing::DefaultValue<BufferSyncInterface::ParseError>::Set(
-        BufferSyncInterface::PARSE_NO_ERROR);
+        BufferSyncInterface::kParseNoError);
   }
 
   // Predicate that matches args passed to DoCommand, by looking at the values.
@@ -60,11 +60,12 @@ class AsyncAPIMock : public AsyncAPIInterface {
    public:
     IsArgs(unsigned int arg_count, const void* args)
         : arg_count_(arg_count),
-          args_(static_cast<CommandBufferEntry*>(const_cast<void*>(args))) { }
+          args_(static_cast<CommandBufferEntry*>(const_cast<void*>(args))) {
+    }
 
     bool operator() (const void* _args) const {
       const CommandBufferEntry* args =
-          static_cast<const CommandBufferEntry*>(_args);
+          static_cast<const CommandBufferEntry*>(_args) + 1;
       for (unsigned int i = 0; i < arg_count_; ++i) {
         if (args[i].value_uint32 != args_[i].value_uint32) return false;
       }
@@ -79,9 +80,9 @@ class AsyncAPIMock : public AsyncAPIInterface {
   MOCK_METHOD3(DoCommand, BufferSyncInterface::ParseError(
       unsigned int command,
       unsigned int arg_count,
-      const void* args));
+      const void* cmd_data));
 
-  // Sets the engine, to forward SET_TOKEN commands to it.
+  // Sets the engine, to forward SetToken commands to it.
   void set_engine(CommandBufferEngine *engine) { engine_ = engine; }
 
   // Forwards the SetToken commands to the engine.
diff --git a/o3d/command_buffer/service/win/d3d9/effect_d3d9.cc b/o3d/command_buffer/service/win/d3d9/effect_d3d9.cc
index 76da265..49672bf 100644
--- a/o3d/command_buffer/service/win/d3d9/effect_d3d9.cc
+++ b/o3d/command_buffer/service/win/d3d9/effect_d3d9.cc
@@ -534,14 +534,14 @@ BufferSyncInterface::ParseError GAPID3D9::CreateEffect(
                        &vertex_program_entry,
                        &fragment_program_entry,
                        &effect_code)) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   EffectD3D9 * effect = EffectD3D9::Create(this, effect_code,
                                            vertex_program_entry,
                                            fragment_program_entry);
-  if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   effects_.Assign(id, effect);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Destroys the Effect resource.
@@ -549,15 +549,15 @@ BufferSyncInterface::ParseError GAPID3D9::CreateEffect(
 BufferSyncInterface::ParseError GAPID3D9::DestroyEffect(ResourceID id) {
   if (id == current_effect_id_) DirtyEffect();
   return effects_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Sets the current effect ID, dirtying the current effect.
 BufferSyncInterface::ParseError GAPID3D9::SetEffect(ResourceID id) {
   DirtyEffect();
   current_effect_id_ = id;
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Gets the param count from the effect and store it in the memory buffer.
@@ -567,9 +567,9 @@ BufferSyncInterface::ParseError GAPID3D9::GetParamCount(
     void *data) {
   EffectD3D9 *effect = effects_.Get(id);
   if (!effect || size < sizeof(Uint32))  // NOLINT
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   *static_cast<Uint32 *>(data) = effect->GetParamCount();
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::CreateParam(
@@ -577,11 +577,11 @@ BufferSyncInterface::ParseError GAPID3D9::CreateParam(
     ResourceID effect_id,
     unsigned int index) {
   EffectD3D9 *effect = effects_.Get(effect_id);
-  if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   EffectParamD3D9 *param = effect->CreateParam(index);
-  if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!param) return BufferSyncInterface::kParseInvalidArguments;
   effect_params_.Assign(param_id, param);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::CreateParamByName(
@@ -590,18 +590,18 @@ BufferSyncInterface::ParseError GAPID3D9::CreateParamByName(
     unsigned int size,
     const void *name) {
   EffectD3D9 *effect = effects_.Get(effect_id);
-  if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   std::string string_name(static_cast<const char *>(name), size);
   EffectParamD3D9 *param = effect->CreateParamByName(string_name.c_str());
-  if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!param) return BufferSyncInterface::kParseInvalidArguments;
   effect_params_.Assign(param_id, param);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::DestroyParam(ResourceID id) {
   return effect_params_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::SetParamData(
@@ -609,10 +609,10 @@ BufferSyncInterface::ParseError GAPID3D9::SetParamData(
     unsigned int size,
     const void *data) {
   EffectParamD3D9 *param = effect_params_.Get(id);
-  if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!param) return BufferSyncInterface::kParseInvalidArguments;
   return param->SetData(this, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::GetParamDesc(
@@ -620,10 +620,10 @@ BufferSyncInterface::ParseError GAPID3D9::GetParamDesc(
     unsigned int size,
     void *data) {
   EffectParamD3D9 *param = effect_params_.Get(id);
-  if (!param) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!param) return BufferSyncInterface::kParseInvalidArguments;
   return param->GetDesc(size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Gets the stream count from the effect and stores it in the memory buffer.
@@ -633,9 +633,9 @@ BufferSyncInterface::ParseError GAPID3D9::GetStreamCount(
     void *data) {
   EffectD3D9 *effect = effects_.Get(id);
   if (!effect || size < sizeof(Uint32))  // NOLINT
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   *static_cast<Uint32 *>(data) = effect->GetStreamCount();
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::GetStreamDesc(
@@ -644,10 +644,10 @@ BufferSyncInterface::ParseError GAPID3D9::GetStreamDesc(
     unsigned int size,
     void *data) {
   EffectD3D9 *effect = effects_.Get(id);
-  if (!effect) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!effect) return BufferSyncInterface::kParseInvalidArguments;
   return effect->GetStreamDesc(index, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 
diff --git a/o3d/command_buffer/service/win/d3d9/gapi_d3d9.cc b/o3d/command_buffer/service/win/d3d9/gapi_d3d9.cc
index 824f504..5c71793 100644
--- a/o3d/command_buffer/service/win/d3d9/gapi_d3d9.cc
+++ b/o3d/command_buffer/service/win/d3d9/gapi_d3d9.cc
@@ -217,7 +217,7 @@ static unsigned int RGBAToARGB(unsigned int rgba) {
 BufferSyncInterface::ParseError GAPID3D9::SetVertexStruct(ResourceID id) {
   current_vertex_struct_ = id;
   validate_streams_ = true;
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Sets in D3D the input streams of the current vertex struct.
@@ -261,22 +261,22 @@ BufferSyncInterface::ParseError GAPID3D9::Draw(
     unsigned int count) {
   if (validate_streams_ && !ValidateStreams()) {
     // TODO: add proper error management
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   if (validate_effect_ && !ValidateEffect()) {
     // TODO: add proper error management
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   DCHECK(current_effect_);
   if (!current_effect_->CommitParameters(this)) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   if (first + count > max_vertices_) {
     // TODO: add proper error management
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   HR(d3d_device_->DrawPrimitive(D3DPrimitive(primitive_type), first, count));
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Draws with the current vertex struct.
@@ -288,29 +288,29 @@ BufferSyncInterface::ParseError GAPID3D9::DrawIndexed(
     unsigned int min_index,
     unsigned int max_index) {
   IndexBufferD3D9 *index_buffer = index_buffers_.Get(index_buffer_id);
-  if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   if (validate_streams_ && !ValidateStreams()) {
     // TODO: add proper error management
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   if (validate_effect_ && !ValidateEffect()) {
     // TODO: add proper error management
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   DCHECK(current_effect_);
   if (!current_effect_->CommitParameters(this)) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   if ((min_index >= max_vertices_) || (max_index > max_vertices_)) {
     // TODO: add proper error management
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
 
   HR(d3d_device_->SetIndices(index_buffer->d3d_index_buffer()));
   HR(d3d_device_->DrawIndexedPrimitive(D3DPrimitive(primitive_type), 0,
                                        min_index, max_index - min_index + 1,
                                        first, count));
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 }  // namespace command_buffer
diff --git a/o3d/command_buffer/service/win/d3d9/geometry_d3d9.cc b/o3d/command_buffer/service/win/d3d9/geometry_d3d9.cc
index e5f32b9..deeab89 100644
--- a/o3d/command_buffer/service/win/d3d9/geometry_d3d9.cc
+++ b/o3d/command_buffer/service/win/d3d9/geometry_d3d9.cc
@@ -316,14 +316,14 @@ BufferSyncInterface::ParseError GAPID3D9::CreateVertexBuffer(
   VertexBufferD3D9 *vertex_buffer = new VertexBufferD3D9(size, flags);
   vertex_buffer->Create(this);
   vertex_buffers_.Assign(id, vertex_buffer);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Destroys a VertexBufferD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::DestroyVertexBuffer(ResourceID id) {
   return vertex_buffers_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data into the VertexBufferD3D9 resource.
@@ -333,10 +333,10 @@ BufferSyncInterface::ParseError GAPID3D9::SetVertexBufferData(
     unsigned int size,
     const void *data) {
   VertexBufferD3D9 *vertex_buffer = vertex_buffers_.Get(id);
-  if (!vertex_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return vertex_buffer->SetData(offset, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data from the VertexBufferD3D9 resource.
@@ -346,10 +346,10 @@ BufferSyncInterface::ParseError GAPID3D9::GetVertexBufferData(
     unsigned int size,
     void *data) {
   VertexBufferD3D9 *vertex_buffer = vertex_buffers_.Get(id);
-  if (!vertex_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!vertex_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return vertex_buffer->GetData(offset, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Creates and assigns an IndexBufferD3D9 resource.
@@ -360,14 +360,14 @@ BufferSyncInterface::ParseError GAPID3D9::CreateIndexBuffer(
   IndexBufferD3D9 *index_buffer = new IndexBufferD3D9(size, flags);
   index_buffer->Create(this);
   index_buffers_.Assign(id, index_buffer);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Destroys an IndexBufferD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::DestroyIndexBuffer(ResourceID id) {
   return index_buffers_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data into the IndexBufferD3D9 resource.
@@ -377,10 +377,10 @@ BufferSyncInterface::ParseError GAPID3D9::SetIndexBufferData(
     unsigned int size,
     const void *data) {
   IndexBufferD3D9 *index_buffer = index_buffers_.Get(id);
-  if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return index_buffer->SetData(offset, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data from the IndexBufferD3D9 resource.
@@ -390,10 +390,10 @@ BufferSyncInterface::ParseError GAPID3D9::GetIndexBufferData(
     unsigned int size,
     void *data) {
   IndexBufferD3D9 *index_buffer = index_buffers_.Get(id);
-  if (!index_buffer) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!index_buffer) return BufferSyncInterface::kParseInvalidArguments;
   return index_buffer->GetData(offset, size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Creates and assigns a VertexStructD3D9 resource.
@@ -402,15 +402,15 @@ BufferSyncInterface::ParseError GAPID3D9::CreateVertexStruct(
   if (id == current_vertex_struct_) validate_streams_ = true;
   VertexStructD3D9 *vertex_struct = new VertexStructD3D9(input_count);
   vertex_structs_.Assign(id, vertex_struct);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Destroys a VertexStructD3D9 resource.
 BufferSyncInterface::ParseError GAPID3D9::DestroyVertexStruct(ResourceID id) {
   if (id == current_vertex_struct_) validate_streams_ = true;
   return vertex_structs_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Sets an input into a VertexStructD3D9 resource.
@@ -426,10 +426,10 @@ BufferSyncInterface::ParseError GAPID3D9::SetVertexInput(
   if (vertex_buffer_id == current_vertex_struct_) validate_streams_ = true;
   VertexStructD3D9 *vertex_struct = vertex_structs_.Get(vertex_struct_id);
   if (!vertex_struct || input_index >= vertex_struct->count())
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   vertex_struct->SetInput(input_index, vertex_buffer_id, offset, stride, type,
                           semantic, semantic_index);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 }  // namespace command_buffer
diff --git a/o3d/command_buffer/service/win/d3d9/render_surface_d3d9.cc b/o3d/command_buffer/service/win/d3d9/render_surface_d3d9.cc
index 2883baf..a26d0dc 100644
--- a/o3d/command_buffer/service/win/d3d9/render_surface_d3d9.cc
+++ b/o3d/command_buffer/service/win/d3d9/render_surface_d3d9.cc
@@ -136,11 +136,11 @@ BufferSyncInterface::ParseError GAPID3D9::CreateRenderSurface(
     ResourceID texture_id) {
   if (id == current_surface_id_) {
     // This will delete the current surface which would be bad.
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   TextureD3D9 *texture = textures_.Get(texture_id);
   if (!texture->render_surfaces_enabled()) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   } else {
     RenderSurfaceD3D9 *render_surface = RenderSurfaceD3D9::Create(this,
                                                                   width,
@@ -149,20 +149,20 @@ BufferSyncInterface::ParseError GAPID3D9::CreateRenderSurface(
                                                                   side,
                                                                   texture);
     if (render_surface == NULL) {
-      return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      return BufferSyncInterface::kParseInvalidArguments;
     }
     render_surfaces_.Assign(id, render_surface);
   }
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::DestroyRenderSurface(ResourceID id) {
   if (id == current_surface_id_) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   return render_surfaces_.Destroy(id) ?
-    BufferSyncInterface::PARSE_NO_ERROR :
-    BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    BufferSyncInterface::kParseNoError :
+    BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::CreateDepthSurface(
@@ -171,24 +171,24 @@ BufferSyncInterface::ParseError GAPID3D9::CreateDepthSurface(
     unsigned int height) {
   if (id == current_depth_surface_id_) {
     // This will delete the current surface which would be bad.
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   RenderDepthStencilSurfaceD3D9 *depth_surface =
     RenderDepthStencilSurfaceD3D9::Create(this, width, height);
   if (depth_surface == NULL) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   depth_surfaces_.Assign(id, depth_surface);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::DestroyDepthSurface(ResourceID id) {
   if (id == current_depth_surface_id_) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
   return depth_surfaces_.Destroy(id) ?
-    BufferSyncInterface::PARSE_NO_ERROR :
-    BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    BufferSyncInterface::kParseNoError :
+    BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::SetRenderSurface(
@@ -200,7 +200,7 @@ BufferSyncInterface::ParseError GAPID3D9::SetRenderSurface(
     depth_surfaces_.Get(depth_stencil_id);
 
   if (d3d_render_surface == NULL && d3d_render_depth_surface == NULL) {
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   }
 
   IDirect3DSurface9 *d3d_surface =
@@ -215,7 +215,7 @@ BufferSyncInterface::ParseError GAPID3D9::SetRenderSurface(
   HR(device->SetDepthStencilSurface(d3d_depth_surface));
   current_surface_id_ = render_surface_id;
   current_depth_surface_id_ = depth_stencil_id;
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 void GAPID3D9::SetBackSurfaces() {
diff --git a/o3d/command_buffer/service/win/d3d9/sampler_d3d9.cc b/o3d/command_buffer/service/win/d3d9/sampler_d3d9.cc
index 3645a5d..e37c37f 100644
--- a/o3d/command_buffer/service/win/d3d9/sampler_d3d9.cc
+++ b/o3d/command_buffer/service/win/d3d9/sampler_d3d9.cc
@@ -139,7 +139,7 @@ BufferSyncInterface::ParseError GAPID3D9::CreateSampler(
   // Dirty effect, because this sampler id may be used
   DirtyEffect();
   samplers_.Assign(id, new SamplerD3D9());
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Destroys the Sampler resource.
@@ -147,8 +147,8 @@ BufferSyncInterface::ParseError GAPID3D9::DestroySampler(ResourceID id) {
   // Dirty effect, because this sampler id may be used
   DirtyEffect();
   return samplers_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::SetSamplerStates(
@@ -162,12 +162,12 @@ BufferSyncInterface::ParseError GAPID3D9::SetSamplerStates(
     unsigned int max_anisotropy) {
   SamplerD3D9 *sampler = samplers_.Get(id);
   if (!sampler)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this sampler id may be used
   DirtyEffect();
   sampler->SetStates(addressing_u, addressing_v, addressing_w,
                      mag_filter, min_filter, mip_filter, max_anisotropy);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::SetSamplerBorderColor(
@@ -175,11 +175,11 @@ BufferSyncInterface::ParseError GAPID3D9::SetSamplerBorderColor(
     const RGBA &color) {
   SamplerD3D9 *sampler = samplers_.Get(id);
   if (!sampler)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this sampler id may be used
   DirtyEffect();
   sampler->SetBorderColor(color);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 BufferSyncInterface::ParseError GAPID3D9::SetSamplerTexture(
@@ -187,11 +187,11 @@ BufferSyncInterface::ParseError GAPID3D9::SetSamplerTexture(
     ResourceID texture_id) {
   SamplerD3D9 *sampler = samplers_.Get(id);
   if (!sampler)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this sampler id may be used
   DirtyEffect();
   sampler->SetTexture(texture_id);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 
diff --git a/o3d/command_buffer/service/win/d3d9/texture_d3d9.cc b/o3d/command_buffer/service/win/d3d9/texture_d3d9.cc
index b11121fa..cb220f8 100644
--- a/o3d/command_buffer/service/win/d3d9/texture_d3d9.cc
+++ b/o3d/command_buffer/service/win/d3d9/texture_d3d9.cc
@@ -612,8 +612,8 @@ BufferSyncInterface::ParseError GAPID3D9::DestroyTexture(ResourceID id) {
   // Dirty effect, because this texture id may be used
   DirtyEffect();
   return textures_.Destroy(id) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Creates a 2D texture resource.
@@ -628,11 +628,11 @@ BufferSyncInterface::ParseError GAPID3D9::CreateTexture2D(
   Texture2DD3D9 *texture = Texture2DD3D9::Create(this, width, height, levels,
                                                  format, flags,
                                                  enable_render_surfaces);
-  if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!texture) return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this texture id may be used
   DirtyEffect();
   textures_.Assign(id, texture);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Creates a 3D texture resource.
@@ -648,11 +648,11 @@ BufferSyncInterface::ParseError GAPID3D9::CreateTexture3D(
   Texture3DD3D9 *texture = Texture3DD3D9::Create(this, width, height, depth,
                                                  levels, format, flags,
                                                  enable_render_surfaces);
-  if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!texture) return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this texture id may be used
   DirtyEffect();
   textures_.Assign(id, texture);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Creates a cube map texture resource.
@@ -666,11 +666,11 @@ BufferSyncInterface::ParseError GAPID3D9::CreateTextureCube(
   TextureCubeD3D9 *texture = TextureCubeD3D9::Create(this, side, levels,
                                                      format, flags,
                                                      enable_render_surfaces);
-  if (!texture) return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+  if (!texture) return BufferSyncInterface::kParseInvalidArguments;
   // Dirty effect, because this texture id may be used
   DirtyEffect();
   textures_.Assign(id, texture);
-  return BufferSyncInterface::PARSE_NO_ERROR;
+  return BufferSyncInterface::kParseNoError;
 }
 
 // Copies the data into a texture resource.
@@ -690,12 +690,12 @@ BufferSyncInterface::ParseError GAPID3D9::SetTextureData(
     const void *data) {
   TextureD3D9 *texture = textures_.Get(id);
   if (!texture)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   Volume volume = {x, y, z, width, height, depth};
   return texture->SetData(this, volume, level, face, row_pitch, slice_pitch,
                           size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 // Copies the data from a texture resource.
@@ -715,12 +715,12 @@ BufferSyncInterface::ParseError GAPID3D9::GetTextureData(
     void *data) {
   TextureD3D9 *texture = textures_.Get(id);
   if (!texture)
-    return BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+    return BufferSyncInterface::kParseInvalidArguments;
   Volume volume = {x, y, z, width, height, depth};
   return texture->GetData(this, volume, level, face, row_pitch, slice_pitch,
                           size, data) ?
-      BufferSyncInterface::PARSE_NO_ERROR :
-      BufferSyncInterface::PARSE_INVALID_ARGUMENTS;
+      BufferSyncInterface::kParseNoError :
+      BufferSyncInterface::kParseInvalidArguments;
 }
 
 }  // namespace command_buffer
diff --git a/o3d/core/cross/command_buffer/buffer_cb.cc b/o3d/core/cross/command_buffer/buffer_cb.cc
index 0914abd..32adbc9 100644
--- a/o3d/core/cross/command_buffer/buffer_cb.cc
+++ b/o3d/core/cross/command_buffer/buffer_cb.cc
@@ -56,29 +56,23 @@ VertexBufferCB::~VertexBufferCB() {
   ConcreteFree();
 }
 
-// Sends the DESTROY_VERTEX_BUFFER command, and frees the ID from the allocator.
+// Sends the DestroyVertexBuffer command, and frees the ID from the allocator.
 void VertexBufferCB::ConcreteFree() {
   if (resource_id_ != command_buffer::kInvalidResource) {
     CommandBufferHelper *helper = renderer_->helper();
-    CommandBufferEntry args[1];
-    args[0].value_uint32 = resource_id_;
-    helper->AddCommand(command_buffer::DESTROY_VERTEX_BUFFER, 1, args);
+    helper->DestroyVertexBuffer(resource_id_);
     renderer_->vertex_buffer_ids().FreeID(resource_id_);
     resource_id_ = command_buffer::kInvalidResource;
   }
 }
 
-// Allocates a resource ID, and sends the CREATE_VERTEX_BUFFER command.
+// Allocates a resource ID, and sends the CreateVertexBuffer command.
 bool VertexBufferCB::ConcreteAllocate(size_t size_in_bytes) {
   ConcreteFree();
   if (size_in_bytes > 0) {
     resource_id_ = renderer_->vertex_buffer_ids().AllocateID();
     CommandBufferHelper *helper = renderer_->helper();
-    CommandBufferEntry args[3];
-    args[0].value_uint32 = resource_id_;
-    args[1].value_uint32 = size_in_bytes;
-    args[2].value_uint32 = 0;  // no flags.
-    helper->AddCommand(command_buffer::CREATE_VERTEX_BUFFER, 3, args);
+    helper->CreateVertexBuffer(resource_id_, size_in_bytes, 0);
     has_data_ = false;
   }
   return true;
@@ -86,7 +80,7 @@ bool VertexBufferCB::ConcreteAllocate(size_t size_in_bytes) {
 
 // Allocates the locked region into the transfer shared memory area. If the
 // buffer resource contains data, copies it back (by sending the
-// GET_VERTEX_BUFFER_DATA command).
+// GetVertexBufferData command).
 bool VertexBufferCB::ConcreteLock(AccessMode access_mode, void **buffer_data) {
   *buffer_data = NULL;
   if (GetSizeInBytes() == 0 || lock_pointer_)
@@ -95,32 +89,27 @@ bool VertexBufferCB::ConcreteLock(AccessMode access_mode, void **buffer_data) {
   if (!lock_pointer_) return false;
   if (has_data_) {
     CommandBufferHelper *helper = renderer_->helper();
-    CommandBufferEntry args[5];
-    args[0].value_uint32 = resource_id_;
-    args[1].value_uint32 = 0;
-    args[2].value_uint32 = GetSizeInBytes();
-    args[3].value_uint32 = renderer_->transfer_shm_id();
-    args[4].value_uint32 = renderer_->allocator()->GetOffset(lock_pointer_);
-    helper->AddCommand(command_buffer::GET_VERTEX_BUFFER_DATA, 5, args);
+    helper->GetVertexBufferData(
+        resource_id_, 0, GetSizeInBytes(),
+        renderer_->transfer_shm_id(),
+        renderer_->allocator()->GetOffset(lock_pointer_));
     helper->Finish();
   }
   *buffer_data = lock_pointer_;
   return true;
 }
 
-// Copies the data into the resource by sending the SET_VERTEX_BUFFER_DATA
+// Copies the data into the resource by sending the SetVertexBufferData
 // command, then frees the shared memory, pending the transfer completion.
 bool VertexBufferCB::ConcreteUnlock() {
   if (GetSizeInBytes() == 0 || !lock_pointer_)
     return false;
   CommandBufferHelper *helper = renderer_->helper();
-  CommandBufferEntry args[5];
-  args[0].value_uint32 = resource_id_;
-  args[1].value_uint32 = 0;
-  args[2].value_uint32 = GetSizeInBytes();
-  args[3].value_uint32 = renderer_->transfer_shm_id();
-  args[4].value_uint32 = renderer_->allocator()->GetOffset(lock_pointer_);
-  helper->AddCommand(command_buffer::SET_VERTEX_BUFFER_DATA, 5, args);
+  helper->SetVertexBufferData(
+      resource_id_, 0, GetSizeInBytes(),
+      renderer_->transfer_shm_id(),
+      renderer_->allocator()->GetOffset(lock_pointer_));
+
   renderer_->allocator()->FreePendingToken(lock_pointer_,
                                            helper->InsertToken());
   lock_pointer_ = NULL;
@@ -142,29 +131,25 @@ IndexBufferCB::~IndexBufferCB() {
   ConcreteFree();
 }
 
-// Sends the DESTROY_INDEX_BUFFER command, and frees the ID from the allocator.
+// Sends the DestroyIndexBuffer command, and frees the ID from the allocator.
 void IndexBufferCB::ConcreteFree() {
   if (resource_id_ != command_buffer::kInvalidResource) {
     CommandBufferHelper *helper = renderer_->helper();
-    CommandBufferEntry args[1];
-    args[0].value_uint32 = resource_id_;
-    helper->AddCommand(command_buffer::DESTROY_INDEX_BUFFER, 1, args);
+    helper->DestroyIndexBuffer(resource_id_);
     renderer_->index_buffer_ids().FreeID(resource_id_);
     resource_id_ = command_buffer::kInvalidResource;
   }
 }
 
-// Allocates a resource ID, and sends the CREATE_INDEX_BUFFER command.
+// Allocates a resource ID, and sends the CreateIndexBuffer command.
 bool IndexBufferCB::ConcreteAllocate(size_t size_in_bytes) {
   ConcreteFree();
   if (size_in_bytes > 0) {
     resource_id_ = renderer_->index_buffer_ids().AllocateID();
     CommandBufferHelper *helper = renderer_->helper();
-    CommandBufferEntry args[3];
-    args[0].value_uint32 = resource_id_;
-    args[1].value_uint32 = size_in_bytes;
-    args[2].value_uint32 = command_buffer::index_buffer::INDEX_32BIT;
-    helper->AddCommand(command_buffer::CREATE_INDEX_BUFFER, 3, args);
+    helper->CreateIndexBuffer(
+        resource_id_, size_in_bytes,
+        command_buffer::index_buffer::INDEX_32BIT);
     has_data_ = false;
   }
   return true;
@@ -172,7 +157,7 @@ bool IndexBufferCB::ConcreteAllocate(size_t size_in_bytes) {
 
 // Allocates the locked region into the transfer shared memory area. If the
 // buffer resource contains data, copies it back (by sending the
-// GET_INDEX_BUFFER_DATA command).
+// GetIndexBufferData command).
 bool IndexBufferCB::ConcreteLock(AccessMode access_mode, void **buffer_data) {
   *buffer_data = NULL;
   if (GetSizeInBytes() == 0 || lock_pointer_)
@@ -181,32 +166,26 @@ bool IndexBufferCB::ConcreteLock(AccessMode access_mode, void **buffer_data) {
   if (!lock_pointer_) return false;
   if (has_data_) {
     CommandBufferHelper *helper = renderer_->helper();
-    CommandBufferEntry args[5];
-    args[0].value_uint32 = resource_id_;
-    args[1].value_uint32 = 0;
-    args[2].value_uint32 = GetSizeInBytes();
-    args[3].value_uint32 = renderer_->transfer_shm_id();
-    args[4].value_uint32 = renderer_->allocator()->GetOffset(lock_pointer_);
-    helper->AddCommand(command_buffer::GET_INDEX_BUFFER_DATA, 5, args);
+    helper->GetIndexBufferData(
+        resource_id_, 0, GetSizeInBytes(),
+        renderer_->transfer_shm_id(),
+        renderer_->allocator()->GetOffset(lock_pointer_));
     helper->Finish();
   }
   *buffer_data = lock_pointer_;
   return true;
 }
 
-// Copies the data into the resource by sending the SET_INDEX_BUFFER_DATA
+// Copies the data into the resource by sending the SetIndexBufferData
 // command, then frees the shared memory, pending the transfer completion.
 bool IndexBufferCB::ConcreteUnlock() {
   if (GetSizeInBytes() == 0 || !lock_pointer_)
     return false;
   CommandBufferHelper *helper = renderer_->helper();
-  CommandBufferEntry args[5];
-  args[0].value_uint32 = resource_id_;
-  args[1].value_uint32 = 0;
-  args[2].value_uint32 = GetSizeInBytes();
-  args[3].value_uint32 = renderer_->transfer_shm_id();
-  args[4].value_uint32 = renderer_->allocator()->GetOffset(lock_pointer_);
-  helper->AddCommand(command_buffer::SET_INDEX_BUFFER_DATA, 5, args);
+  helper->SetIndexBufferData(
+      resource_id_, 0, GetSizeInBytes(),
+      renderer_->transfer_shm_id(),
+      renderer_->allocator()->GetOffset(lock_pointer_));
   renderer_->allocator()->FreePendingToken(lock_pointer_,
                                            helper->InsertToken());
   lock_pointer_ = NULL;
diff --git a/o3d/core/cross/command_buffer/effect_cb.cc b/o3d/core/cross/command_buffer/effect_cb.cc
index ed35a77..332da8f 100644
--- a/o3d/core/cross/command_buffer/effect_cb.cc
+++ b/o3d/core/cross/command_buffer/effect_cb.cc
@@ -92,19 +92,17 @@ bool EffectCB::LoadFromFXString(const String& source) {
   ResourceID resource_id = renderer_->effect_ids().AllocateID();
 
   CommandBufferHelper *helper = renderer_->helper();
-  CommandBufferEntry args[4];
-  args[0].value_uint32 = resource_id;
-  args[1].value_uint32 = source_size;
-  args[2].value_uint32 = renderer_->transfer_shm_id();
-  args[3].value_uint32 = renderer_->allocator()->GetOffset(buffer_data);
-  helper->AddCommand(command_buffer::CREATE_EFFECT, 4, args);
+  helper->CreateEffect(
+      resource_id, source_size,
+      renderer_->transfer_shm_id(),
+      renderer_->allocator()->GetOffset(buffer_data));
   renderer_->allocator()->FreePendingToken(buffer_data, helper->InsertToken());
 
   // NOTE: we're calling Finish to check the command result, to see if
   // the effect has succesfully compiled.
   helper->Finish();
   if (renderer_->sync_interface()->GetParseError() !=
-      BufferSyncInterface::PARSE_NO_ERROR) {
+      BufferSyncInterface::kParseNoError) {
     O3D_ERROR(service_locator()) << "Effect failed to compile.";
     renderer_->effect_ids().FreeID(resource_id);
     return false;
@@ -140,9 +138,7 @@ void EffectCB::Destroy() {
   ++generation_;
   if (resource_id_ != command_buffer::kInvalidResource) {
     CommandBufferHelper *helper = renderer_->helper();
-    CommandBufferEntry args[1];
-    args[0].value_uint32 = resource_id_;
-    helper->AddCommand(command_buffer::DESTROY_EFFECT, 1, args);
+    helper->DestroyEffect(resource_id_);
     renderer_->effect_ids().FreeID(resource_id_);
     resource_id_ = command_buffer::kInvalidResource;
   }
diff --git a/o3d/core/cross/command_buffer/param_cache_cb.cc b/o3d/core/cross/command_buffer/param_cache_cb.cc
index c41d72e..e6351dc 100644
--- a/o3d/core/cross/command_buffer/param_cache_cb.cc
+++ b/o3d/core/cross/command_buffer/param_cache_cb.cc
@@ -70,15 +70,8 @@ class TypedParamHandlerCB : public ParamHandlerCB {
   // This template definition only works for value types (floatn, matrix, int,
   // ..., but not textures or samplers).
   virtual void SetValue(CommandBufferHelper *helper) {
-    static const unsigned int kEntryCount =
-        (sizeof(typename T::DataType) + 3) / 4;
-    CommandBufferEntry args[2 + kEntryCount];
     typename T::DataType value = param_->value();
-    args[0].value_uint32 = id_;
-    args[1].value_uint32 = sizeof(value);
-    memcpy(args + 2, &value, sizeof(value));
-    helper->AddCommand(command_buffer::SET_PARAM_DATA_IMMEDIATE,
-                       2 + kEntryCount, args);
+    helper->SetParamDataImmediate(id_, sizeof(value), &value);
   }
  private:
   T* param_;
@@ -99,12 +92,8 @@ class MatrixParamHandlerColumnsCB : public ParamHandlerCB {
 
   // Sends the param value to the service.
   virtual void SetValue(CommandBufferHelper *helper) {
-    CommandBufferEntry args[18];
     Matrix4 value = transpose(param_->value());
-    args[0].value_uint32 = id_;
-    args[1].value_uint32 = sizeof(value);
-    memcpy(args + 2, &value, sizeof(value));
-    helper->AddCommand(command_buffer::SET_PARAM_DATA_IMMEDIATE, 18, args);
+    helper->SetParamDataImmediate(id_, sizeof(value), &value);
   }
  private:
   ParamMatrix4* param_;
@@ -121,17 +110,15 @@ class SamplerParamHandlerCB : public ParamHandlerCB {
   // Sends the param value to the service.
   virtual void SetValue(CommandBufferHelper *helper) {
     SamplerCB *sampler = down_cast<SamplerCB *>(param_->value());
-    CommandBufferEntry args[3];
-    args[0].value_uint32 = id_;
-    args[1].value_uint32 = sizeof(ResourceID);
+    uint32 value;
     if (!sampler) {
       // TODO: use error sampler
-      args[2].value_uint32 = command_buffer::kInvalidResource;
+      value = command_buffer::kInvalidResource;
     } else {
       sampler->SetTextureAndStates();
-      args[2].value_uint32 = sampler->resource_id();
+      value = sampler->resource_id();
     }
-    helper->AddCommand(command_buffer::SET_PARAM_DATA_IMMEDIATE, 3, args);
+    helper->SetParamDataImmediate(id_, sizeof(value), &value);
   }
  private:
   ParamSampler* param_;
diff --git a/o3d/core/cross/command_buffer/primitive_cb.cc b/o3d/core/cross/command_buffer/primitive_cb.cc
index 2f02dba..208a1b0 100644
--- a/o3d/core/cross/command_buffer/primitive_cb.cc
+++ b/o3d/core/cross/command_buffer/primitive_cb.cc
@@ -112,8 +112,7 @@ void PrimitiveCB::PlatformSpecificRender(Renderer* renderer,
   IndexBufferCB *index_buffer_cb =
       down_cast<IndexBufferCB *>(index_buffer());
   if (!index_buffer_cb) {
-    // TODO: draw non-index in this case ? we don't do it currently on
-    // other platforms, so keep compatibility.
+    // TODO(gman): draw non-indexed primitives.
     DLOG(INFO) << "Trying to draw with an empty index buffer.";
     return;
   }
@@ -130,23 +129,15 @@ void PrimitiveCB::PlatformSpecificRender(Renderer* renderer,
   stream_bank_cb->BindStreamsForRendering();
 
   CommandBufferHelper *helper = renderer_->helper();
-  CommandBufferEntry args[6];
 
   // Sets current effect.
   // TODO: cache current effect ?
-  args[0].value_uint32 = effect_cb->resource_id();
-  helper->AddCommand(command_buffer::SET_EFFECT, 1, args);
+  helper->SetEffect(effect_cb->resource_id());
   param_cache_cb->RunHandlers(helper);
 
-
   // Draws.
-  args[0].value_uint32 = cb_primitive_type;
-  args[1].value_uint32 = index_buffer_cb->resource_id();
-  args[2].value_uint32 = 0;                     // first index.
-  args[3].value_uint32 = number_primitives_;    // primitive count.
-  args[4].value_uint32 = 0;                     // min index.
-  args[5].value_uint32 = number_vertices_ - 1;  // max index.
-  helper->AddCommand(command_buffer::DRAW_INDEXED, 6, args);
+  helper->DrawIndexed(cb_primitive_type, index_buffer_cb->resource_id(),
+                       0, number_primitives_, 0, number_vertices_ - 1);
 }
 
 }  // namespace o3d
diff --git a/o3d/core/cross/command_buffer/render_surface_cb.cc b/o3d/core/cross/command_buffer/render_surface_cb.cc
index bb967d2..443cc2f 100644
--- a/o3d/core/cross/command_buffer/render_surface_cb.cc
+++ b/o3d/core/cross/command_buffer/render_surface_cb.cc
@@ -59,17 +59,10 @@ RenderSurfaceCB::RenderSurfaceCB(ServiceLocator *service_locator,
   ResourceID id = renderer_->render_surface_ids().AllocateID();
   resource_id_ = id;
   CommandBufferHelper *helper = renderer_->helper();
-  CommandBufferEntry args[4];
-  args[0].value_uint32 = id;
-  args[1].value_uint32 =
-    create_render_surface_cmd::Width::MakeValue(width) |
-    create_render_surface_cmd::Height::MakeValue(height);
-  args[2].value_uint32 =
-    create_render_surface_cmd::Levels::MakeValue(mip_level) |
-    create_render_surface_cmd::Side::MakeValue(side);
-  args[3].value_uint32 =
-    reinterpret_cast<ResourceID>(texture->GetTextureHandle());
-  helper->AddCommand(command_buffer::CREATE_RENDER_SURFACE, 4, args);
+  helper->CreateRenderSurface(
+      id,
+      reinterpret_cast<uint32>(texture->GetTextureHandle()),
+      width, height, mip_level, side);
 }
 
 RenderSurfaceCB::~RenderSurfaceCB() {
@@ -80,9 +73,7 @@ void RenderSurfaceCB::Destroy() {
   // This should never be called during rendering.
   if (resource_id_ != command_buffer::kInvalidResource) {
     CommandBufferHelper *helper = renderer_->helper();
-    CommandBufferEntry args[1];
-    args[0].value_uint32 = resource_id_;
-    helper->AddCommand(command_buffer::DESTROY_RENDER_SURFACE, 1, args);
+    helper->DestroyRenderSurface(resource_id_);
     renderer_->render_surface_ids().FreeID(resource_id_);
     resource_id_ = command_buffer::kInvalidResource;
   }
@@ -102,20 +93,13 @@ RenderDepthStencilSurfaceCB::RenderDepthStencilSurfaceCB(
   ResourceID id = renderer_->depth_surface_ids().AllocateID();
   resource_id_ = id;
   CommandBufferHelper *helper = renderer_->helper();
-  CommandBufferEntry args[2];
-  args[0].value_uint32 = id;
-  args[1].value_uint32 =
-    create_render_surface_cmd::Width::MakeValue(width) |
-    create_render_surface_cmd::Height::MakeValue(height);
-  helper->AddCommand(command_buffer::CREATE_DEPTH_SURFACE, 2, args);
+  helper->CreateDepthSurface(id, width, height);
 }
 
 void RenderDepthStencilSurfaceCB::Destroy() {
   if (resource_id_ != command_buffer::kInvalidResource) {
     CommandBufferHelper *helper = renderer_->helper();
-    CommandBufferEntry args[1];
-    args[0].value_uint32 = resource_id_;
-    helper->AddCommand(command_buffer::DESTROY_DEPTH_SURFACE, 1, args);
+    helper->DestroyDepthSurface(resource_id_);
     renderer_->depth_surface_ids().FreeID(resource_id_);
     resource_id_ = command_buffer::kInvalidResource;
   }
diff --git a/o3d/core/cross/command_buffer/renderer_cb.cc b/o3d/core/cross/command_buffer/renderer_cb.cc
index e2d3998..f2d919b5 100644
--- a/o3d/core/cross/command_buffer/renderer_cb.cc
+++ b/o3d/core/cross/command_buffer/renderer_cb.cc
@@ -187,38 +187,31 @@ void RendererCB::PlatformSpecificClear(const Float4 &color,
   uint32 buffers = (color_flag ? GAPIInterface::COLOR : 0) |
       (depth_flag ? GAPIInterface::DEPTH : 0) |
       (stencil_flag ? GAPIInterface::STENCIL : 0);
-  command_buffer::CommandBufferEntry args[7];
-  args[0].value_uint32 = buffers;
-  args[1].value_float = color[0];
-  args[2].value_float = color[1];
-  args[3].value_float = color[2];
-  args[4].value_float = color[3];
-  args[5].value_float = depth;
-  args[6].value_uint32 = stencil;
-  helper_->AddCommand(command_buffer::CLEAR, 7, args);
+  helper_->Clear(buffers, color[0], color[1], color[2], color[3],
+                 depth, stencil);
 }
 
 void RendererCB::PlatformSpecificEndDraw() {
 }
 
-// Adds the BEGIN_FRAME command to the command buffer.
+// Adds the BeginFrame command to the command buffer.
 bool RendererCB::PlatformSpecificStartRendering() {
   // Any device issues are handled in the command buffer backend
   DCHECK(helper_);
-  helper_->AddCommand(command_buffer::BEGIN_FRAME, 0 , NULL);
+  helper_->BeginFrame();
   return true;
 }
 
-// Adds the END_FRAME command to the command buffer, and flushes the commands.
+// Adds the EndFrame command to the command buffer, and flushes the commands.
 void RendererCB::PlatformSpecificFinishRendering() {
   // Any device issues are handled in the command buffer backend
-  helper_->AddCommand(command_buffer::END_FRAME, 0 , NULL);
+  helper_->EndFrame();
   helper_->WaitForToken(frame_token_);
   frame_token_ = helper_->InsertToken();
 }
 
 void RendererCB::PlatformSpecificPresent() {
-  // TODO(gman): The END_FRAME command needs to be split into END_FRAME
+  // TODO(gman): The EndFrame command needs to be split into EndFrame
   //     and PRESENT.
 }
 
@@ -231,14 +224,13 @@ void RendererCB::SetRenderSurfacesPlatformSpecific(
       down_cast<const RenderSurfaceCB*>(surface);
   const RenderDepthStencilSurfaceCB* surface_depth_cb =
       down_cast<const RenderDepthStencilSurfaceCB*>(surface_depth);
-  command_buffer::CommandBufferEntry args[2];
-  args[0].value_uint32 = surface_cb->resource_id();
-  args[1].value_uint32 = surface_depth_cb->resource_id();
-  helper_->AddCommand(command_buffer::SET_RENDER_SURFACE, 2, args);
+  helper_->SetRenderSurface(
+      surface_cb->resource_id(),
+      surface_depth_cb->resource_id());
 }
 
 void RendererCB::SetBackBufferPlatformSpecific() {
-  helper_->AddCommand(command_buffer::SET_BACK_SURFACES, 0, NULL);
+  helper_->SetBackSurfaces();
 }
 
 // Creates a StreamBank, returning a platform specific implementation class.
@@ -314,14 +306,7 @@ void RendererCB::SetViewportInPixels(int left,
                                      int height,
                                      float min_z,
                                      float max_z) {
-  command_buffer::CommandBufferEntry args[6];
-  args[0].value_uint32 = left;
-  args[1].value_uint32 = top;
-  args[2].value_uint32 = width;
-  args[3].value_uint32 = height;
-  args[4].value_float = min_z;
-  args[5].value_float = max_z;
-  helper_->AddCommand(command_buffer::SET_VIEWPORT, 6, args);
+  helper_->SetViewport(left, top, width, height, min_z, max_z);
 }
 
 const int* RendererCB::GetRGBAUByteNSwizzleTable() {
diff --git a/o3d/core/cross/command_buffer/sampler_cb.cc b/o3d/core/cross/command_buffer/sampler_cb.cc
index df7b02f..b185076 100644
--- a/o3d/core/cross/command_buffer/sampler_cb.cc
+++ b/o3d/core/cross/command_buffer/sampler_cb.cc
@@ -86,15 +86,11 @@ SamplerCB::SamplerCB(ServiceLocator* service_locator, RendererCB* renderer)
       renderer_(renderer) {
   DCHECK(renderer_);
   resource_id_ = renderer_->sampler_ids().AllocateID();
-  CommandBufferEntry args[1];
-  args[0].value_uint32 = resource_id_;
-  renderer_->helper()->AddCommand(command_buffer::CREATE_SAMPLER, 1, args);
+  renderer_->helper()->CreateSampler(resource_id_);
 }
 
 SamplerCB::~SamplerCB() {
-  CommandBufferEntry args[1];
-  args[0].value_uint32 = resource_id_;
-  renderer_->helper()->AddCommand(command_buffer::DESTROY_SAMPLER, 1, args);
+  renderer_->helper()->DestroySampler(resource_id_);
   renderer_->sampler_ids().FreeID(resource_id_);
 }
 
@@ -102,6 +98,7 @@ void SamplerCB::SetTextureAndStates() {
   CommandBufferHelper *helper = renderer_->helper();
   sampler::AddressingMode address_mode_u_cb = AddressModeToCB(address_mode_u());
   sampler::AddressingMode address_mode_v_cb = AddressModeToCB(address_mode_v());
+  sampler::AddressingMode address_mode_w_cb = AddressModeToCB(address_mode_w());
   sampler::FilteringMode mag_filter_cb = FilterTypeToCB(mag_filter());
   sampler::FilteringMode min_filter_cb = FilterTypeToCB(min_filter());
   sampler::FilteringMode mip_filter_cb = FilterTypeToCB(mip_filter());
@@ -113,24 +110,19 @@ void SamplerCB::SetTextureAndStates() {
   if (min_filter() != Sampler::ANISOTROPIC) {
     max_anisotropy_cb = 1;
   }
-  CommandBufferEntry args[5];
-  args[0].value_uint32 = resource_id_;
-  args[1].value_uint32 =
-      set_sampler_states::AddressingU::MakeValue(address_mode_u_cb) |
-      set_sampler_states::AddressingV::MakeValue(address_mode_v_cb) |
-      set_sampler_states::AddressingW::MakeValue(sampler::WRAP) |
-      set_sampler_states::MagFilter::MakeValue(mag_filter_cb) |
-      set_sampler_states::MinFilter::MakeValue(min_filter_cb) |
-      set_sampler_states::MipFilter::MakeValue(mip_filter_cb) |
-      set_sampler_states::MaxAnisotropy::MakeValue(max_anisotropy_cb);
-  helper->AddCommand(command_buffer::SET_SAMPLER_STATES, 2, args);
+  helper->SetSamplerStates(
+      resource_id_,
+      address_mode_u_cb,
+      address_mode_v_cb,
+      address_mode_w_cb,
+      mag_filter_cb,
+      min_filter_cb,
+      mip_filter_cb,
+      max_anisotropy_cb);
 
   Float4 color = border_color();
-  args[1].value_float = color[0];
-  args[2].value_float = color[1];
-  args[3].value_float = color[2];
-  args[4].value_float = color[3];
-  helper->AddCommand(command_buffer::SET_SAMPLER_BORDER_COLOR, 5, args);
+  helper->SetSamplerBorderColor(resource_id_,
+                                   color[0], color[1], color[2], color[3]);
 
   Texture *texture_object = texture();
   if (!texture_object) {
@@ -143,9 +135,9 @@ void SamplerCB::SetTextureAndStates() {
   }
 
   if (texture_object) {
-    args[1].value_uint32 =
-        reinterpret_cast<ResourceID>(texture_object->GetTextureHandle());
-    helper->AddCommand(command_buffer::SET_SAMPLER_TEXTURE, 2, args);
+    helper->SetSamplerTexture(
+        resource_id_,
+        reinterpret_cast<uint32>(texture_object->GetTextureHandle()));
   }
 }
 
diff --git a/o3d/core/cross/command_buffer/states_cb.cc b/o3d/core/cross/command_buffer/states_cb.cc
index 9126069..c6d4818 100644
--- a/o3d/core/cross/command_buffer/states_cb.cc
+++ b/o3d/core/cross/command_buffer/states_cb.cc
@@ -441,31 +441,6 @@ class BlendEqStateHandler : public TypedStateHandler<ParamInteger> {
   bool *dirty_;
 };
 
-// A handler that sets the blending color.
-// Parameters:
-//   args: a pointer to the arguments.
-//   dirty: a pointer to the dirty bit.
-class BlendColorStateHandler : public TypedStateHandler<ParamFloat4> {
- public:
-  BlendColorStateHandler(CommandBufferEntry *args, bool *dirty)
-      : args_(args),
-        dirty_(dirty) {
-  }
-
-  virtual void SetStateFromTypedParam(RendererCB* renderer,
-                                      ParamFloat4* param) const {
-    Float4 value = param->value();
-    args_[0].value_float = value[0];
-    args_[1].value_float = value[1];
-    args_[2].value_float = value[2];
-    args_[3].value_float = value[3];
-    *dirty_ = true;
-  }
- private:
-  CommandBufferEntry *args_;
-  bool *dirty_;
-};
-
 // Adds all the state handlers for all the states. The list of handlers must
 // match in names and types the list in Renderer::AddDefaultStates()
 // (in renderer.cc).
@@ -475,52 +450,58 @@ void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) {
     using command_buffer::set_point_line_raster::LineSmoothEnable;
     using command_buffer::set_point_line_raster::PointSpriteEnable;
     bool *dirty = point_line_helper_.dirty_ptr();
-    uint32 *arg0 = &(point_line_helper_.args()[0].value_uint32);
-    float *arg1 = &(point_line_helper_.args()[1].value_float);
+    command_buffer::cmd::SetPointLineRaster& cmd =
+        point_line_helper_.command();
     renderer->AddStateHandler(
         State::kLineSmoothEnableParamName,
-        new EnableStateHandler<LineSmoothEnable>(arg0, dirty));
+        new EnableStateHandler<LineSmoothEnable>(&cmd.fixme0, dirty));
     renderer->AddStateHandler(
         State::kPointSpriteEnableParamName,
-        new EnableStateHandler<PointSpriteEnable>(arg0, dirty));
+        new EnableStateHandler<PointSpriteEnable>(&cmd.fixme0, dirty));
     renderer->AddStateHandler(State::kPointSizeParamName,
-                              new ValueStateHandler<ParamFloat>(arg1, dirty));
+                              new ValueStateHandler<ParamFloat>(
+                                  &cmd.point_size, dirty));
   }
 
   // Polygon Raster
   {
     bool *dirty = poly_raster_helper_.dirty_ptr();
-    uint32 *arg = &(poly_raster_helper_.args()[0].value_uint32);
+    command_buffer::cmd::SetPolygonRaster& cmd =
+        poly_raster_helper_.command();
     renderer->AddStateHandler(State::kCullModeParamName,
-                              new CullModeStateHandler(arg, dirty));
+                              new CullModeStateHandler(&cmd.fixme0, dirty));
     renderer->AddStateHandler(State::kFillModeParamName,
-                              new FillModeStateHandler(arg, dirty));
+                              new FillModeStateHandler(&cmd.fixme0, dirty));
   }
 
   // Polygon Offset
   {
     bool *dirty = poly_offset_helper_.dirty_ptr();
-    float *arg0 = &(poly_offset_helper_.args()[0].value_float);
-    float *arg1 = &(poly_offset_helper_.args()[1].value_float);
-    renderer->AddStateHandler(State::kPolygonOffset1ParamName,
-                              new ValueStateHandler<ParamFloat>(arg0, dirty));
-    renderer->AddStateHandler(State::kPolygonOffset2ParamName,
-                              new ValueStateHandler<ParamFloat>(arg1, dirty));
+    command_buffer::cmd::SetPolygonOffset& cmd =
+        poly_offset_helper_.command();
+    renderer->AddStateHandler(
+        State::kPolygonOffset1ParamName,
+        new ValueStateHandler<ParamFloat>(&cmd.slope_factor, dirty));
+    renderer->AddStateHandler(
+        State::kPolygonOffset2ParamName,
+        new ValueStateHandler<ParamFloat>(&cmd.units, dirty));
   }
 
   // Alpha test
   {
     using command_buffer::set_alpha_test::Enable;
     using command_buffer::set_alpha_test::Func;
+    command_buffer::cmd::SetAlphaTest& cmd = alpha_test_helper_.command();
     bool *dirty = alpha_test_helper_.dirty_ptr();
-    uint32 *arg0 = &(alpha_test_helper_.args()[0].value_uint32);
-    float *arg1 = &(alpha_test_helper_.args()[1].value_float);
-    renderer->AddStateHandler(State::kAlphaTestEnableParamName,
-                              new EnableStateHandler<Enable>(arg0, dirty));
-    renderer->AddStateHandler(State::kAlphaComparisonFunctionParamName,
-                              new ComparisonStateHandler<Func>(arg0, dirty));
-    renderer->AddStateHandler(State::kAlphaReferenceParamName,
-                              new ValueStateHandler<ParamFloat>(arg1, dirty));
+    renderer->AddStateHandler(
+        State::kAlphaTestEnableParamName,
+        new EnableStateHandler<Enable>(&cmd.fixme0, dirty));
+    renderer->AddStateHandler(
+        State::kAlphaComparisonFunctionParamName,
+        new ComparisonStateHandler<Func>(&cmd.fixme0, dirty));
+    renderer->AddStateHandler(
+        State::kAlphaReferenceParamName,
+        new ValueStateHandler<ParamFloat>(&cmd.value, dirty));
   }
 
   // Depth Test
@@ -529,13 +510,16 @@ void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) {
     using command_buffer::set_depth_test::WriteEnable;
     using command_buffer::set_depth_test::Func;
     bool *dirty = depth_test_helper_.dirty_ptr();
-    uint32 *arg = &(depth_test_helper_.args()[0].value_uint32);
-    renderer->AddStateHandler(State::kZWriteEnableParamName,
-                              new EnableStateHandler<WriteEnable>(arg, dirty));
-    renderer->AddStateHandler(State::kZEnableParamName,
-                              new EnableStateHandler<Enable>(arg, dirty));
-    renderer->AddStateHandler(State::kZComparisonFunctionParamName,
-                              new ComparisonStateHandler<Func>(arg, dirty));
+    command_buffer::cmd::SetDepthTest& cmd = depth_test_helper_.command();
+    renderer->AddStateHandler(
+        State::kZWriteEnableParamName,
+        new EnableStateHandler<WriteEnable>(&cmd.fixme0, dirty));
+    renderer->AddStateHandler(
+        State::kZEnableParamName,
+        new EnableStateHandler<Enable>(&cmd.fixme0, dirty));
+    renderer->AddStateHandler(
+        State::kZComparisonFunctionParamName,
+        new ComparisonStateHandler<Func>(&cmd.fixme0, dirty));
   }
 
   // Stencil Test
@@ -554,42 +538,49 @@ void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) {
     using command_buffer::set_stencil_test::CCWFailOp;
     using command_buffer::set_stencil_test::CCWZFailOp;
     bool *dirty = stencil_test_helper_.dirty_ptr();
-    uint32 *arg0 = &(stencil_test_helper_.args()[0].value_uint32);
-    uint32 *arg1 = &(stencil_test_helper_.args()[1].value_uint32);
-    renderer->AddStateHandler(State::kStencilEnableParamName,
-                              new EnableStateHandler<Enable>(arg0, dirty));
-    renderer->AddStateHandler(State::kTwoSidedStencilEnableParamName,
-                              new EnableStateHandler<SeparateCCW>(arg0, dirty));
+    command_buffer::cmd::SetStencilTest& cmd = stencil_test_helper_.command();
+    renderer->AddStateHandler(
+        State::kStencilEnableParamName,
+        new EnableStateHandler<Enable>(&cmd.fixme0, dirty));
+    renderer->AddStateHandler(
+        State::kTwoSidedStencilEnableParamName,
+        new EnableStateHandler<SeparateCCW>(&cmd.fixme0, dirty));
     renderer->AddStateHandler(
         State::kStencilReferenceParamName,
-        new BitFieldStateHandler<ReferenceValue>(arg0, dirty));
+        new BitFieldStateHandler<ReferenceValue>(&cmd.fixme0, dirty));
     renderer->AddStateHandler(
         State::kStencilMaskParamName,
-        new BitFieldStateHandler<CompareMask>(arg0, dirty));
-    renderer->AddStateHandler(State::kStencilWriteMaskParamName,
-                              new BitFieldStateHandler<WriteMask>(arg0, dirty));
+        new BitFieldStateHandler<CompareMask>(&cmd.fixme0, dirty));
+    renderer->AddStateHandler(
+        State::kStencilWriteMaskParamName,
+        new BitFieldStateHandler<WriteMask>(&cmd.fixme0, dirty));
 
-    renderer->AddStateHandler(State::kStencilComparisonFunctionParamName,
-                              new ComparisonStateHandler<CWFunc>(arg1, dirty));
-    renderer->AddStateHandler(State::kStencilPassOperationParamName,
-                              new StencilOpStateHandler<CWPassOp>(arg1, dirty));
-    renderer->AddStateHandler(State::kStencilFailOperationParamName,
-                              new StencilOpStateHandler<CWFailOp>(arg1, dirty));
+    renderer->AddStateHandler(
+        State::kStencilComparisonFunctionParamName,
+        new ComparisonStateHandler<CWFunc>(&cmd.fixme1, dirty));
+    renderer->AddStateHandler(
+        State::kStencilPassOperationParamName,
+        new StencilOpStateHandler<CWPassOp>(&cmd.fixme1, dirty));
+    renderer->AddStateHandler(
+        State::kStencilFailOperationParamName,
+        new StencilOpStateHandler<CWFailOp>(&cmd.fixme1, dirty));
     renderer->AddStateHandler(
         State::kStencilZFailOperationParamName,
-        new StencilOpStateHandler<CWZFailOp>(arg1, dirty));
+        new StencilOpStateHandler<CWZFailOp>(&cmd.fixme1, dirty));
+
+    renderer->AddStateHandler(
+        State::kCCWStencilComparisonFunctionParamName,
+        new ComparisonStateHandler<CCWFunc>(&cmd.fixme1, dirty));
 
-    renderer->AddStateHandler(State::kCCWStencilComparisonFunctionParamName,
-                              new ComparisonStateHandler<CCWFunc>(arg1, dirty));
     renderer->AddStateHandler(
         State::kCCWStencilPassOperationParamName,
-        new StencilOpStateHandler<CCWPassOp>(arg1, dirty));
+        new StencilOpStateHandler<CCWPassOp>(&cmd.fixme1, dirty));
     renderer->AddStateHandler(
         State::kCCWStencilFailOperationParamName,
-        new StencilOpStateHandler<CCWFailOp>(arg1, dirty));
+        new StencilOpStateHandler<CCWFailOp>(&cmd.fixme1, dirty));
     renderer->AddStateHandler(
         State::kCCWStencilZFailOperationParamName,
-        new StencilOpStateHandler<CCWZFailOp>(arg1, dirty));
+        new StencilOpStateHandler<CCWZFailOp>(&cmd.fixme1, dirty));
   }
 
   // Blending
@@ -603,29 +594,32 @@ void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) {
     using command_buffer::set_blending::AlphaSrcFunc;
     using command_buffer::set_blending::AlphaDstFunc;
     bool *dirty = blending_helper_.dirty_ptr();
-    uint32 *arg = &(blending_helper_.args()[0].value_uint32);
-    renderer->AddStateHandler(State::kAlphaBlendEnableParamName,
-                              new EnableStateHandler<Enable>(arg, dirty));
+    command_buffer::cmd::SetBlending& cmd = blending_helper_.command();
+    renderer->AddStateHandler(
+        State::kAlphaBlendEnableParamName,
+        new EnableStateHandler<Enable>(&cmd.fixme0, dirty));
     renderer->AddStateHandler(
         State::kSeparateAlphaBlendEnableParamName,
-        new EnableStateHandler<SeparateAlpha>(arg, dirty));
+        new EnableStateHandler<SeparateAlpha>(&cmd.fixme0, dirty));
 
     renderer->AddStateHandler(
         State::kSourceBlendFunctionParamName,
-        new BlendFuncStateHandler<ColorSrcFunc>(arg, dirty));
+        new BlendFuncStateHandler<ColorSrcFunc>(&cmd.fixme0, dirty));
     renderer->AddStateHandler(
         State::kDestinationBlendFunctionParamName,
-        new BlendFuncStateHandler<ColorDstFunc>(arg, dirty));
-    renderer->AddStateHandler(State::kBlendEquationParamName,
-                              new BlendEqStateHandler<ColorEq>(arg, dirty));
+        new BlendFuncStateHandler<ColorDstFunc>(&cmd.fixme0, dirty));
+    renderer->AddStateHandler(
+        State::kBlendEquationParamName,
+        new BlendEqStateHandler<ColorEq>(&cmd.fixme0, dirty));
     renderer->AddStateHandler(
         State::kSourceBlendAlphaFunctionParamName,
-        new BlendFuncStateHandler<AlphaSrcFunc>(arg, dirty));
+        new BlendFuncStateHandler<AlphaSrcFunc>(&cmd.fixme0, dirty));
     renderer->AddStateHandler(
         State::kDestinationBlendAlphaFunctionParamName,
-        new BlendFuncStateHandler<AlphaDstFunc>(arg, dirty));
-    renderer->AddStateHandler(State::kBlendAlphaEquationParamName,
-                              new BlendEqStateHandler<AlphaEq>(arg, dirty));
+        new BlendFuncStateHandler<AlphaDstFunc>(&cmd.fixme0, dirty));
+    renderer->AddStateHandler(
+        State::kBlendAlphaEquationParamName,
+        new BlendEqStateHandler<AlphaEq>(&cmd.fixme0, dirty));
   }
 
   // Color Write
@@ -633,12 +627,13 @@ void RendererCB::StateManager::AddStateHandlers(RendererCB *renderer) {
     using command_buffer::set_color_write::DitherEnable;
     using command_buffer::set_color_write::AllColorsMask;
     bool *dirty = color_write_helper_.dirty_ptr();
-    uint32 *arg = &(color_write_helper_.args()[0].value_uint32);
-    renderer->AddStateHandler(State::kDitherEnableParamName,
-                              new EnableStateHandler<DitherEnable>(arg, dirty));
+    command_buffer::cmd::SetColorWrite& cmd = color_write_helper_.command();
+    renderer->AddStateHandler(
+        State::kDitherEnableParamName,
+        new EnableStateHandler<DitherEnable>(&cmd.flags, dirty));
     renderer->AddStateHandler(
         State::kColorWriteEnableParamName,
-        new ColorWriteStateHandler(arg, dirty));
+        new ColorWriteStateHandler(&cmd.flags, dirty));
   }
 }
 
@@ -651,7 +646,6 @@ void RendererCB::StateManager::ValidateStates(CommandBufferHelper *helper) {
   stencil_test_helper_.Validate(helper);
   color_write_helper_.Validate(helper);
   blending_helper_.Validate(helper);
-  blending_color_helper_.Validate(helper);
 }
 
 }  // namespace o3d
diff --git a/o3d/core/cross/command_buffer/states_cb.h b/o3d/core/cross/command_buffer/states_cb.h
index 352e1b0..471f92a 100644
--- a/o3d/core/cross/command_buffer/states_cb.h
+++ b/o3d/core/cross/command_buffer/states_cb.h
@@ -59,41 +59,43 @@ class RendererCB::StateManager {
   // A template helper. This wraps a command sent to set a set of states. It
   // keeps all the arguments of a single command, that get modified by the
   // various handles, as well as a dirty bit.
-  template <command_buffer::CommandId command, unsigned int arg_count>
+  template <typename CommandType>
   class StateHelper {
    public:
-    static const unsigned int kArgCount = arg_count;
-
     StateHelper() : dirty_(false) {
-      for (unsigned int i = 0; i < kArgCount; ++i) {
-        args_[i].value_uint32 = 0;
-      }
+      // NOTE: This code assumes the state commands only need their
+      // header set and that the rest will be set by the state handlers.
+      memset(&command_, 0, sizeof(command_));
+      command_.SetHeader();
     }
 
     // Sends the command if it is marked as dirty.
     void Validate(command_buffer::CommandBufferHelper *helper) {
       if (!dirty_) return;
-      helper->AddCommand(command, kArgCount, args_);
+      helper->AddTypedCmdData(command_);
       dirty_ = false;
     }
 
-    command_buffer::CommandBufferEntry *args() { return args_; }
+    CommandType& command() {
+      return command_;
+    }
+
     bool *dirty_ptr() { return &dirty_; }
    private:
     bool dirty_;
-    command_buffer::CommandBufferEntry args_[kArgCount];
+    CommandType command_;
     DISALLOW_COPY_AND_ASSIGN(StateHelper);
   };
 
-  StateHelper<command_buffer::SET_POINT_LINE_RASTER, 2> point_line_helper_;
-  StateHelper<command_buffer::SET_POLYGON_OFFSET, 2> poly_offset_helper_;
-  StateHelper<command_buffer::SET_POLYGON_RASTER, 1> poly_raster_helper_;
-  StateHelper<command_buffer::SET_ALPHA_TEST, 2> alpha_test_helper_;
-  StateHelper<command_buffer::SET_DEPTH_TEST, 1> depth_test_helper_;
-  StateHelper<command_buffer::SET_STENCIL_TEST, 2> stencil_test_helper_;
-  StateHelper<command_buffer::SET_COLOR_WRITE, 1> color_write_helper_;
-  StateHelper<command_buffer::SET_BLENDING, 1> blending_helper_;
-  StateHelper<command_buffer::SET_BLENDING_COLOR, 4> blending_color_helper_;
+  StateHelper<command_buffer::cmd::SetPointLineRaster> point_line_helper_;
+  StateHelper<command_buffer::cmd::SetPolygonOffset> poly_offset_helper_;
+  StateHelper<command_buffer::cmd::SetPolygonRaster> poly_raster_helper_;
+  StateHelper<command_buffer::cmd::SetAlphaTest> alpha_test_helper_;
+  StateHelper<command_buffer::cmd::SetDepthTest> depth_test_helper_;
+  StateHelper<command_buffer::cmd::SetStencilTest> stencil_test_helper_;
+  StateHelper<command_buffer::cmd::SetColorWrite> color_write_helper_;
+  StateHelper<command_buffer::cmd::SetBlending> blending_helper_;
+  StateHelper<command_buffer::cmd::SetBlendingColor> blending_color_helper_;
   DISALLOW_COPY_AND_ASSIGN(StateManager);
 };
 
diff --git a/o3d/core/cross/command_buffer/stream_bank_cb.cc b/o3d/core/cross/command_buffer/stream_bank_cb.cc
index 42b9158..1ddca52 100644
--- a/o3d/core/cross/command_buffer/stream_bank_cb.cc
+++ b/o3d/core/cross/command_buffer/stream_bank_cb.cc
@@ -147,10 +147,7 @@ void StreamBankCB::CreateVertexStruct() {
   DCHECK_EQ(kInvalidResource, vertex_struct_id_);
   vertex_struct_id_ = renderer_->vertex_structs_ids().AllocateID();
   CommandBufferHelper *helper = renderer_->helper();
-  CommandBufferEntry args[5];
-  args[0].value_uint32 = vertex_struct_id_;
-  args[1].value_uint32 = vertex_stream_params_.size();
-  helper->AddCommand(command_buffer::CREATE_VERTEX_STRUCT, 2, args);
+  helper->CreateVertexStruct(vertex_struct_id_, vertex_stream_params_.size());
   for (unsigned int i = 0; i < vertex_stream_params_.size(); ++i) {
     const Stream &stream = vertex_stream_params_[i]->stream();
     vertex_struct::Semantic cb_semantic;
@@ -168,19 +165,16 @@ void StreamBankCB::CreateVertexStruct() {
       continue;
     }
 
-    namespace cmd = command_buffer::set_vertex_input_cmd;
     VertexBufferCB *vertex_buffer =
         static_cast<VertexBufferCB *>(stream.field().buffer());
-    args[0].value_uint32 = vertex_struct_id_;
-    args[1].value_uint32 = i;
-    args[2].value_uint32 = vertex_buffer->resource_id();
-    args[3].value_uint32 = stream.field().offset();
-    args[4].value_uint32 =
-        cmd::SemanticIndex::MakeValue(cb_semantic_index) |
-        cmd::Semantic::MakeValue(cb_semantic) |
-        cmd::Type::MakeValue(cb_type) |
-        cmd::Stride::MakeValue(vertex_buffer->stride());
-    helper->AddCommand(command_buffer::SET_VERTEX_INPUT, 5, args);
+    helper->SetVertexInput(
+        vertex_struct_id_, i,
+        vertex_buffer->resource_id(),
+        stream.field().offset(),
+        cb_semantic,
+        cb_semantic_index,
+        cb_type,
+        vertex_buffer->stride());
   }
 }
 
@@ -188,9 +182,7 @@ void StreamBankCB::CreateVertexStruct() {
 void StreamBankCB::DestroyVertexStruct() {
   if (vertex_struct_id_ != kInvalidResource) {
     CommandBufferHelper *helper = renderer_->helper();
-    CommandBufferEntry args[1];
-    args[0].value_uint32 = vertex_struct_id_;
-    helper->AddCommand(command_buffer::DESTROY_VERTEX_STRUCT, 1, args);
+    helper->DestroyVertexStruct(vertex_struct_id_);
     renderer_->vertex_structs_ids().FreeID(vertex_struct_id_);
     vertex_struct_id_ = kInvalidResource;
   }
@@ -200,10 +192,7 @@ void StreamBankCB::BindStreamsForRendering() {
   if (vertex_struct_id_ == kInvalidResource)
     CreateVertexStruct();
   CommandBufferHelper *helper = renderer_->helper();
-  CommandBufferEntry args[6];
-  // Sets current vertex struct.
-  args[0].value_uint32 = vertex_struct_id_;
-  helper->AddCommand(command_buffer::SET_VERTEX_STRUCT, 1, args);
+  helper->SetVertexStruct(vertex_struct_id_);
 }
 
 }  // namespace o3d
diff --git a/o3d/core/cross/command_buffer/texture_cb.cc b/o3d/core/cross/command_buffer/texture_cb.cc
index 12e3d98..d00a094 100644
--- a/o3d/core/cross/command_buffer/texture_cb.cc
+++ b/o3d/core/cross/command_buffer/texture_cb.cc
@@ -120,7 +120,7 @@ void SetTextureDataBuffer(Texture::Format format,
   }
 }
 
-// Sends the SET_TEXTURE_DATA command after formatting the args properly.
+// Sends the SetTextureData command after formatting the args properly.
 void SetTextureData(RendererCB *renderer,
                     ResourceID texture_id,
                     unsigned int x,
@@ -136,27 +136,16 @@ void SetTextureData(RendererCB *renderer,
                     unsigned char* mip_data) {
   FencedAllocatorWrapper *allocator = renderer->allocator();
   CommandBufferHelper *helper = renderer->helper();
-
-  CommandBufferEntry args[10];
-  args[0].value_uint32 = texture_id;
-  args[1].value_uint32 =
-      set_texture_data_cmd::X::MakeValue(x) |
-      set_texture_data_cmd::Y::MakeValue(y);
-  args[2].value_uint32 =
-      set_texture_data_cmd::Width::MakeValue(mip_width) |
-      set_texture_data_cmd::Height::MakeValue(mip_height);
-  args[3].value_uint32 =
-      set_texture_data_cmd::Z::MakeValue(z) |
-      set_texture_data_cmd::Depth::MakeValue(depth);
-  args[4].value_uint32 =
-      set_texture_data_cmd::Level::MakeValue(level) |
-      set_texture_data_cmd::Face::MakeValue(face);
-  args[5].value_uint32 = pitch;
-  args[6].value_uint32 = 0;  // slice_pitch
-  args[7].value_uint32 = mip_size;
-  args[8].value_uint32 = renderer->transfer_shm_id();
-  args[9].value_uint32 = allocator->GetOffset(mip_data);
-  helper->AddCommand(command_buffer::SET_TEXTURE_DATA, 10, args);
+  helper->SetTextureData(
+      texture_id,
+      x, y, z,
+      mip_width, mip_height, depth,
+      level, face,
+      pitch,
+      0,  // slice_pitch
+      mip_size,
+      renderer->transfer_shm_id(),
+      allocator->GetOffset(mip_data));
   allocator->FreePendingToken(mip_data, helper->InsertToken());
 }
 // Updates a command buffer texture resource from a bitmap, rescaling if
@@ -213,26 +202,21 @@ void CopyBackResourceToBitmap(RendererCB *renderer,
 
   size_t pitch = image::ComputeBufferSize(mip_width, 1, bitmap.format());
 
-  CommandBufferEntry args[10];
-  args[0].value_uint32 = texture_id;
-  args[1].value_uint32 =
-      get_texture_data_cmd::X::MakeValue(0) |
-      get_texture_data_cmd::Y::MakeValue(0);
-  args[2].value_uint32 =
-      get_texture_data_cmd::Width::MakeValue(mip_width) |
-      get_texture_data_cmd::Height::MakeValue(mip_height);
-  args[3].value_uint32 =
-      get_texture_data_cmd::Z::MakeValue(0) |
-      get_texture_data_cmd::Depth::MakeValue(1);
-  args[4].value_uint32 =
-      get_texture_data_cmd::Level::MakeValue(level) |
-      get_texture_data_cmd::Face::MakeValue(face);
-  args[5].value_uint32 = pitch;
-  args[6].value_uint32 = 0;  // slice_pitch
-  args[7].value_uint32 = mip_size;
-  args[8].value_uint32 = renderer->transfer_shm_id();
-  args[9].value_uint32 = allocator->GetOffset(buffer);
-  helper->AddCommand(command_buffer::GET_TEXTURE_DATA, 10, args);
+  helper->GetTextureData(
+      texture_id,
+      0,
+      0,
+      0,
+      mip_width,
+      mip_height,
+      1,
+      level,
+      face,
+      pitch,
+      0,
+      mip_size,
+      renderer->transfer_shm_id(),
+      allocator->GetOffset(buffer));
   helper->Finish();
   memcpy(bitmap.GetMipData(level), buffer, mip_size);
   allocator->Free(buffer);
@@ -272,9 +256,7 @@ Texture2DCB::Texture2DCB(ServiceLocator* service_locator,
 
 Texture2DCB::~Texture2DCB() {
   if (resource_id_ != command_buffer::kInvalidResource) {
-    CommandBufferEntry args[1];
-    args[0].value_uint32 = resource_id_;
-    renderer_->helper()->AddCommand(command_buffer::DESTROY_TEXTURE, 1, args);
+    renderer_->helper()->DestroyTexture(resource_id_);
   }
 }
 
@@ -301,16 +283,10 @@ Texture2DCB* Texture2DCB::Create(ServiceLocator* service_locator,
   }
 
   ResourceID texture_id = renderer->texture_ids().AllocateID();
-  CommandBufferEntry args[3];
-  args[0].value_uint32 = texture_id;
-  args[1].value_uint32 =
-      create_texture_2d_cmd::Width::MakeValue(width) |
-      create_texture_2d_cmd::Height::MakeValue(height);
-  args[2].value_uint32 =
-      create_texture_2d_cmd::Levels::MakeValue(levels) |
-      create_texture_2d_cmd::Format::MakeValue(cb_format) |
-      create_texture_2d_cmd::Flags::MakeValue(enable_render_surfaces);
-  renderer->helper()->AddCommand(command_buffer::CREATE_TEXTURE_2D, 3, args);
+  renderer->helper()->CreateTexture2d(
+      texture_id,
+      width, height,
+      levels, cb_format, enable_render_surfaces);
 
   Texture2DCB *texture = new Texture2DCB(service_locator, texture_id,
                                          format, levels, width, height,
@@ -496,9 +472,7 @@ TextureCUBECB::TextureCUBECB(ServiceLocator* service_locator,
 
 TextureCUBECB::~TextureCUBECB() {
   if (resource_id_ != command_buffer::kInvalidResource) {
-    CommandBufferEntry args[1];
-    args[0].value_uint32 = resource_id_;
-    renderer_->helper()->AddCommand(command_buffer::DESTROY_TEXTURE, 1, args);
+    renderer_->helper()->DestroyTexture(resource_id_);
   }
 }
 
@@ -524,14 +498,10 @@ TextureCUBECB* TextureCUBECB::Create(ServiceLocator* service_locator,
   }
 
   ResourceID texture_id = renderer->texture_ids().AllocateID();
-  CommandBufferEntry args[3];
-  args[0].value_uint32 = texture_id;
-  args[1].value_uint32 = create_texture_cube_cmd::Side::MakeValue(edge_length);
-  args[2].value_uint32 =
-      create_texture_cube_cmd::Levels::MakeValue(levels) |
-      create_texture_cube_cmd::Format::MakeValue(cb_format) |
-      create_texture_cube_cmd::Flags::MakeValue(enable_render_surfaces);
-  renderer->helper()->AddCommand(command_buffer::CREATE_TEXTURE_CUBE, 3, args);
+  renderer->helper()->CreateTextureCube(
+      texture_id,
+      edge_length,
+      levels, cb_format, enable_render_surfaces);
 
   TextureCUBECB* texture =
       new TextureCUBECB(service_locator, texture_id, format, levels,