Refactor/Rename a bunch of GPU stuff

gpu/command_buffer/common/gles2_cmd_format_test_autogen.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file is auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
 // DO NOT EDIT!
 
 // This file contains unit tests for gles2 commmands
 // It is included by gles2_cmd_format_test.cc
 
 #ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_
 #define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_
 
 TEST_F(GLES2FormatTest, ActiveTexture) {
-  ActiveTexture& cmd = *GetBufferAs<ActiveTexture>();
+  cmds::ActiveTexture& cmd = *GetBufferAs<cmds::ActiveTexture>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(ActiveTexture::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ActiveTexture::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.texture);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, AttachShader) {
-  AttachShader& cmd = *GetBufferAs<AttachShader>();
+  cmds::AttachShader& cmd = *GetBufferAs<cmds::AttachShader>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(AttachShader::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::AttachShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.shader);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BindAttribLocation) {
-  BindAttribLocation& cmd = *GetBufferAs<BindAttribLocation>();
+  cmds::BindAttribLocation& cmd = *GetBufferAs<cmds::BindAttribLocation>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLuint>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(BindAttribLocation::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BindAttribLocation::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
   EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset);
   EXPECT_EQ(static_cast<uint32>(15), cmd.data_size);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 
 TEST_F(GLES2FormatTest, BindAttribLocationImmediate) {
-  BindAttribLocationImmediate& cmd =
-      *GetBufferAs<BindAttribLocationImmediate>();
+  cmds::BindAttribLocationImmediate& cmd =
+      *GetBufferAs<cmds::BindAttribLocationImmediate>();
   static const char* const test_str = "test string";
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLuint>(12),
       test_str,
       strlen(test_str));
-  EXPECT_EQ(static_cast<uint32>(BindAttribLocationImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BindAttribLocationImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(strlen(test_str)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<char*>(next_cmd),
             reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
                 RoundSizeToMultipleOfEntries(strlen(test_str)));
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
   EXPECT_EQ(static_cast<uint32>(strlen(test_str)), cmd.data_size);
   EXPECT_EQ(0, memcmp(test_str, ImmediateDataAddress(&cmd), strlen(test_str)));
   CheckBytesWritten(
       next_cmd,
       sizeof(cmd) + RoundSizeToMultipleOfEntries(strlen(test_str)),
       sizeof(cmd) + strlen(test_str));
 }
 
 TEST_F(GLES2FormatTest, BindAttribLocationBucket) {
-  BindAttribLocationBucket& cmd = *GetBufferAs<BindAttribLocationBucket>();
+  cmds::BindAttribLocationBucket& cmd =
+      *GetBufferAs<cmds::BindAttribLocationBucket>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLuint>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(BindAttribLocationBucket::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BindAttribLocationBucket::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
   EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BindBuffer) {
-  BindBuffer& cmd = *GetBufferAs<BindBuffer>();
+  cmds::BindBuffer& cmd = *GetBufferAs<cmds::BindBuffer>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(BindBuffer::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BindBuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.buffer);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BindFramebuffer) {
-  BindFramebuffer& cmd = *GetBufferAs<BindFramebuffer>();
+  cmds::BindFramebuffer& cmd = *GetBufferAs<cmds::BindFramebuffer>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(BindFramebuffer::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BindFramebuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.framebuffer);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BindRenderbuffer) {
-  BindRenderbuffer& cmd = *GetBufferAs<BindRenderbuffer>();
+  cmds::BindRenderbuffer& cmd = *GetBufferAs<cmds::BindRenderbuffer>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(BindRenderbuffer::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BindRenderbuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.renderbuffer);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BindTexture) {
-  BindTexture& cmd = *GetBufferAs<BindTexture>();
+  cmds::BindTexture& cmd = *GetBufferAs<cmds::BindTexture>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(BindTexture::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BindTexture::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.texture);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BlendColor) {
-  BlendColor& cmd = *GetBufferAs<BlendColor>();
+  cmds::BlendColor& cmd = *GetBufferAs<cmds::BlendColor>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLclampf>(11),
       static_cast<GLclampf>(12),
       static_cast<GLclampf>(13),
       static_cast<GLclampf>(14));
-  EXPECT_EQ(static_cast<uint32>(BlendColor::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BlendColor::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.red);
   EXPECT_EQ(static_cast<GLclampf>(12), cmd.green);
   EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue);
   EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BlendEquation) {
-  BlendEquation& cmd = *GetBufferAs<BlendEquation>();
+  cmds::BlendEquation& cmd = *GetBufferAs<cmds::BlendEquation>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(BlendEquation::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BlendEquation::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BlendEquationSeparate) {
-  BlendEquationSeparate& cmd = *GetBufferAs<BlendEquationSeparate>();
+  cmds::BlendEquationSeparate& cmd =
+      *GetBufferAs<cmds::BlendEquationSeparate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12));
-  EXPECT_EQ(static_cast<uint32>(BlendEquationSeparate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BlendEquationSeparate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.modeRGB);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.modeAlpha);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BlendFunc) {
-  BlendFunc& cmd = *GetBufferAs<BlendFunc>();
+  cmds::BlendFunc& cmd = *GetBufferAs<cmds::BlendFunc>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12));
-  EXPECT_EQ(static_cast<uint32>(BlendFunc::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BlendFunc::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.sfactor);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.dfactor);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BlendFuncSeparate) {
-  BlendFuncSeparate& cmd = *GetBufferAs<BlendFuncSeparate>();
+  cmds::BlendFuncSeparate& cmd = *GetBufferAs<cmds::BlendFuncSeparate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLenum>(13),
       static_cast<GLenum>(14));
-  EXPECT_EQ(static_cast<uint32>(BlendFuncSeparate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BlendFuncSeparate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.srcRGB);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.dstRGB);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.srcAlpha);
   EXPECT_EQ(static_cast<GLenum>(14), cmd.dstAlpha);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BufferData) {
-  BufferData& cmd = *GetBufferAs<BufferData>();
+  cmds::BufferData& cmd = *GetBufferAs<cmds::BufferData>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLsizeiptr>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14),
       static_cast<GLenum>(15));
-  EXPECT_EQ(static_cast<uint32>(BufferData::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BufferData::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLsizeiptr>(12), cmd.size);
   EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_offset);
   EXPECT_EQ(static_cast<GLenum>(15), cmd.usage);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 // TODO(gman): Implement test for BufferDataImmediate
 TEST_F(GLES2FormatTest, BufferSubData) {
-  BufferSubData& cmd = *GetBufferAs<BufferSubData>();
+  cmds::BufferSubData& cmd = *GetBufferAs<cmds::BufferSubData>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLintptr>(12),
       static_cast<GLsizeiptr>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(BufferSubData::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BufferSubData::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLintptr>(12), cmd.offset);
   EXPECT_EQ(static_cast<GLsizeiptr>(13), cmd.size);
   EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_id);
   EXPECT_EQ(static_cast<uint32>(15), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 // TODO(gman): Implement test for BufferSubDataImmediate
 TEST_F(GLES2FormatTest, CheckFramebufferStatus) {
-  CheckFramebufferStatus& cmd = *GetBufferAs<CheckFramebufferStatus>();
+  cmds::CheckFramebufferStatus& cmd =
+      *GetBufferAs<cmds::CheckFramebufferStatus>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(CheckFramebufferStatus::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CheckFramebufferStatus::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Clear) {
-  Clear& cmd = *GetBufferAs<Clear>();
+  cmds::Clear& cmd = *GetBufferAs<cmds::Clear>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLbitfield>(11));
-  EXPECT_EQ(static_cast<uint32>(Clear::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Clear::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLbitfield>(11), cmd.mask);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ClearColor) {
-  ClearColor& cmd = *GetBufferAs<ClearColor>();
+  cmds::ClearColor& cmd = *GetBufferAs<cmds::ClearColor>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLclampf>(11),
       static_cast<GLclampf>(12),
       static_cast<GLclampf>(13),
       static_cast<GLclampf>(14));
-  EXPECT_EQ(static_cast<uint32>(ClearColor::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ClearColor::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.red);
   EXPECT_EQ(static_cast<GLclampf>(12), cmd.green);
   EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue);
   EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ClearDepthf) {
-  ClearDepthf& cmd = *GetBufferAs<ClearDepthf>();
+  cmds::ClearDepthf& cmd = *GetBufferAs<cmds::ClearDepthf>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLclampf>(11));
-  EXPECT_EQ(static_cast<uint32>(ClearDepthf::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ClearDepthf::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.depth);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ClearStencil) {
-  ClearStencil& cmd = *GetBufferAs<ClearStencil>();
+  cmds::ClearStencil& cmd = *GetBufferAs<cmds::ClearStencil>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11));
-  EXPECT_EQ(static_cast<uint32>(ClearStencil::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ClearStencil::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.s);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ColorMask) {
-  ColorMask& cmd = *GetBufferAs<ColorMask>();
+  cmds::ColorMask& cmd = *GetBufferAs<cmds::ColorMask>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLboolean>(11),
       static_cast<GLboolean>(12),
       static_cast<GLboolean>(13),
       static_cast<GLboolean>(14));
-  EXPECT_EQ(static_cast<uint32>(ColorMask::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ColorMask::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLboolean>(11), cmd.red);
   EXPECT_EQ(static_cast<GLboolean>(12), cmd.green);
   EXPECT_EQ(static_cast<GLboolean>(13), cmd.blue);
   EXPECT_EQ(static_cast<GLboolean>(14), cmd.alpha);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CompileShader) {
-  CompileShader& cmd = *GetBufferAs<CompileShader>();
+  cmds::CompileShader& cmd = *GetBufferAs<cmds::CompileShader>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(CompileShader::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CompileShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CompressedTexImage2D) {
-  CompressedTexImage2D& cmd = *GetBufferAs<CompressedTexImage2D>();
+  cmds::CompressedTexImage2D& cmd = *GetBufferAs<cmds::CompressedTexImage2D>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLenum>(13),
       static_cast<GLsizei>(14),
       static_cast<GLsizei>(15),
       static_cast<GLint>(16),
       static_cast<GLsizei>(17),
       static_cast<uint32>(18),
       static_cast<uint32>(19));
-  EXPECT_EQ(static_cast<uint32>(CompressedTexImage2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
   EXPECT_EQ(static_cast<GLsizei>(17), cmd.imageSize);
   EXPECT_EQ(static_cast<uint32>(18), cmd.data_shm_id);
   EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 // TODO(gman): Implement test for CompressedTexImage2DImmediate
 TEST_F(GLES2FormatTest, CompressedTexImage2DBucket) {
-  CompressedTexImage2DBucket& cmd = *GetBufferAs<CompressedTexImage2DBucket>();
+  cmds::CompressedTexImage2DBucket& cmd =
+      *GetBufferAs<cmds::CompressedTexImage2DBucket>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLenum>(13),
       static_cast<GLsizei>(14),
       static_cast<GLsizei>(15),
       static_cast<GLint>(16),
       static_cast<GLuint>(17));
-  EXPECT_EQ(static_cast<uint32>(CompressedTexImage2DBucket::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexImage2DBucket::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
   EXPECT_EQ(static_cast<GLuint>(17), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CompressedTexSubImage2D) {
-  CompressedTexSubImage2D& cmd = *GetBufferAs<CompressedTexSubImage2D>();
+  cmds::CompressedTexSubImage2D& cmd =
+      *GetBufferAs<cmds::CompressedTexSubImage2D>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLint>(14),
       static_cast<GLsizei>(15),
       static_cast<GLsizei>(16),
       static_cast<GLenum>(17),
       static_cast<GLsizei>(18),
       static_cast<uint32>(19),
       static_cast<uint32>(20));
-  EXPECT_EQ(static_cast<uint32>(CompressedTexSubImage2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexSubImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLsizei>(18), cmd.imageSize);
   EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id);
   EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 // TODO(gman): Implement test for CompressedTexSubImage2DImmediate
 TEST_F(GLES2FormatTest, CompressedTexSubImage2DBucket) {
-  CompressedTexSubImage2DBucket& cmd =
-      *GetBufferAs<CompressedTexSubImage2DBucket>();
+  cmds::CompressedTexSubImage2DBucket& cmd =
+      *GetBufferAs<cmds::CompressedTexSubImage2DBucket>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLint>(14),
       static_cast<GLsizei>(15),
       static_cast<GLsizei>(16),
       static_cast<GLenum>(17),
       static_cast<GLuint>(18));
-  EXPECT_EQ(static_cast<uint32>(CompressedTexSubImage2DBucket::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CompressedTexSubImage2DBucket::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLuint>(18), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CopyTexImage2D) {
-  CopyTexImage2D& cmd = *GetBufferAs<CopyTexImage2D>();
+  cmds::CopyTexImage2D& cmd = *GetBufferAs<cmds::CopyTexImage2D>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLenum>(13),
       static_cast<GLint>(14),
       static_cast<GLint>(15),
       static_cast<GLsizei>(16),
       static_cast<GLsizei>(17),
       static_cast<GLint>(18));
-  EXPECT_EQ(static_cast<uint32>(CopyTexImage2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CopyTexImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLint>(14), cmd.x);
   EXPECT_EQ(static_cast<GLint>(15), cmd.y);
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(17), cmd.height);
   EXPECT_EQ(static_cast<GLint>(18), cmd.border);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CopyTexSubImage2D) {
-  CopyTexSubImage2D& cmd = *GetBufferAs<CopyTexSubImage2D>();
+  cmds::CopyTexSubImage2D& cmd = *GetBufferAs<cmds::CopyTexSubImage2D>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLint>(14),
       static_cast<GLint>(15),
       static_cast<GLint>(16),
       static_cast<GLsizei>(17),
       static_cast<GLsizei>(18));
-  EXPECT_EQ(static_cast<uint32>(CopyTexSubImage2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CopyTexSubImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
   EXPECT_EQ(static_cast<GLint>(15), cmd.x);
   EXPECT_EQ(static_cast<GLint>(16), cmd.y);
   EXPECT_EQ(static_cast<GLsizei>(17), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(18), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CreateProgram) {
-  CreateProgram& cmd = *GetBufferAs<CreateProgram>();
+  cmds::CreateProgram& cmd = *GetBufferAs<cmds::CreateProgram>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<uint32>(11));
-  EXPECT_EQ(static_cast<uint32>(CreateProgram::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CreateProgram::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<uint32>(11), cmd.client_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CreateShader) {
-  CreateShader& cmd = *GetBufferAs<CreateShader>();
+  cmds::CreateShader& cmd = *GetBufferAs<cmds::CreateShader>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(CreateShader::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CreateShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.type);
   EXPECT_EQ(static_cast<uint32>(12), cmd.client_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CullFace) {
-  CullFace& cmd = *GetBufferAs<CullFace>();
+  cmds::CullFace& cmd = *GetBufferAs<cmds::CullFace>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(CullFace::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CullFace::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteBuffers) {
-  DeleteBuffers& cmd = *GetBufferAs<DeleteBuffers>();
+  cmds::DeleteBuffers& cmd = *GetBufferAs<cmds::DeleteBuffers>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(DeleteBuffers::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteBuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteBuffersImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  DeleteBuffersImmediate& cmd = *GetBufferAs<DeleteBuffersImmediate>();
+  cmds::DeleteBuffersImmediate& cmd =
+      *GetBufferAs<cmds::DeleteBuffersImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(DeleteBuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteBuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, DeleteFramebuffers) {
-  DeleteFramebuffers& cmd = *GetBufferAs<DeleteFramebuffers>();
+  cmds::DeleteFramebuffers& cmd = *GetBufferAs<cmds::DeleteFramebuffers>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(DeleteFramebuffers::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteFramebuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteFramebuffersImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  DeleteFramebuffersImmediate& cmd =
-      *GetBufferAs<DeleteFramebuffersImmediate>();
+  cmds::DeleteFramebuffersImmediate& cmd =
+      *GetBufferAs<cmds::DeleteFramebuffersImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(DeleteFramebuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteFramebuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, DeleteProgram) {
-  DeleteProgram& cmd = *GetBufferAs<DeleteProgram>();
+  cmds::DeleteProgram& cmd = *GetBufferAs<cmds::DeleteProgram>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(DeleteProgram::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteProgram::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteRenderbuffers) {
-  DeleteRenderbuffers& cmd = *GetBufferAs<DeleteRenderbuffers>();
+  cmds::DeleteRenderbuffers& cmd = *GetBufferAs<cmds::DeleteRenderbuffers>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(DeleteRenderbuffers::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteRenderbuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteRenderbuffersImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  DeleteRenderbuffersImmediate& cmd =
-      *GetBufferAs<DeleteRenderbuffersImmediate>();
+  cmds::DeleteRenderbuffersImmediate& cmd =
+      *GetBufferAs<cmds::DeleteRenderbuffersImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(DeleteRenderbuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteRenderbuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, DeleteShader) {
-  DeleteShader& cmd = *GetBufferAs<DeleteShader>();
+  cmds::DeleteShader& cmd = *GetBufferAs<cmds::DeleteShader>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(DeleteShader::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteTextures) {
-  DeleteTextures& cmd = *GetBufferAs<DeleteTextures>();
+  cmds::DeleteTextures& cmd = *GetBufferAs<cmds::DeleteTextures>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(DeleteTextures::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteTextures::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteTexturesImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  DeleteTexturesImmediate& cmd = *GetBufferAs<DeleteTexturesImmediate>();
+  cmds::DeleteTexturesImmediate& cmd =
+      *GetBufferAs<cmds::DeleteTexturesImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(DeleteTexturesImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteTexturesImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, DepthFunc) {
-  DepthFunc& cmd = *GetBufferAs<DepthFunc>();
+  cmds::DepthFunc& cmd = *GetBufferAs<cmds::DepthFunc>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(DepthFunc::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DepthFunc::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DepthMask) {
-  DepthMask& cmd = *GetBufferAs<DepthMask>();
+  cmds::DepthMask& cmd = *GetBufferAs<cmds::DepthMask>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLboolean>(11));
-  EXPECT_EQ(static_cast<uint32>(DepthMask::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DepthMask::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLboolean>(11), cmd.flag);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DepthRangef) {
-  DepthRangef& cmd = *GetBufferAs<DepthRangef>();
+  cmds::DepthRangef& cmd = *GetBufferAs<cmds::DepthRangef>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLclampf>(11),
       static_cast<GLclampf>(12));
-  EXPECT_EQ(static_cast<uint32>(DepthRangef::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DepthRangef::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.zNear);
   EXPECT_EQ(static_cast<GLclampf>(12), cmd.zFar);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DetachShader) {
-  DetachShader& cmd = *GetBufferAs<DetachShader>();
+  cmds::DetachShader& cmd = *GetBufferAs<cmds::DetachShader>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(DetachShader::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DetachShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.shader);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Disable) {
-  Disable& cmd = *GetBufferAs<Disable>();
+  cmds::Disable& cmd = *GetBufferAs<cmds::Disable>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(Disable::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Disable::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DisableVertexAttribArray) {
-  DisableVertexAttribArray& cmd = *GetBufferAs<DisableVertexAttribArray>();
+  cmds::DisableVertexAttribArray& cmd =
+      *GetBufferAs<cmds::DisableVertexAttribArray>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(DisableVertexAttribArray::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DisableVertexAttribArray::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DrawArrays) {
-  DrawArrays& cmd = *GetBufferAs<DrawArrays>();
+  cmds::DrawArrays& cmd = *GetBufferAs<cmds::DrawArrays>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLsizei>(13));
-  EXPECT_EQ(static_cast<uint32>(DrawArrays::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DrawArrays::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
   EXPECT_EQ(static_cast<GLint>(12), cmd.first);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DrawElements) {
-  DrawElements& cmd = *GetBufferAs<DrawElements>();
+  cmds::DrawElements& cmd = *GetBufferAs<cmds::DrawElements>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLsizei>(12),
       static_cast<GLenum>(13),
       static_cast<GLuint>(14));
-  EXPECT_EQ(static_cast<uint32>(DrawElements::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DrawElements::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Enable) {
-  Enable& cmd = *GetBufferAs<Enable>();
+  cmds::Enable& cmd = *GetBufferAs<cmds::Enable>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(Enable::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Enable::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, EnableVertexAttribArray) {
-  EnableVertexAttribArray& cmd = *GetBufferAs<EnableVertexAttribArray>();
+  cmds::EnableVertexAttribArray& cmd =
+      *GetBufferAs<cmds::EnableVertexAttribArray>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(EnableVertexAttribArray::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::EnableVertexAttribArray::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Finish) {
-  Finish& cmd = *GetBufferAs<Finish>();
+  cmds::Finish& cmd = *GetBufferAs<cmds::Finish>();
   void* next_cmd = cmd.Set(
       &cmd);
-  EXPECT_EQ(static_cast<uint32>(Finish::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Finish::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Flush) {
-  Flush& cmd = *GetBufferAs<Flush>();
+  cmds::Flush& cmd = *GetBufferAs<cmds::Flush>();
   void* next_cmd = cmd.Set(
       &cmd);
-  EXPECT_EQ(static_cast<uint32>(Flush::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Flush::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, FramebufferRenderbuffer) {
-  FramebufferRenderbuffer& cmd = *GetBufferAs<FramebufferRenderbuffer>();
+  cmds::FramebufferRenderbuffer& cmd =
+      *GetBufferAs<cmds::FramebufferRenderbuffer>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLenum>(13),
       static_cast<GLuint>(14));
-  EXPECT_EQ(static_cast<uint32>(FramebufferRenderbuffer::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::FramebufferRenderbuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.renderbuffertarget);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.renderbuffer);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, FramebufferTexture2D) {
-  FramebufferTexture2D& cmd = *GetBufferAs<FramebufferTexture2D>();
+  cmds::FramebufferTexture2D& cmd = *GetBufferAs<cmds::FramebufferTexture2D>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLenum>(13),
       static_cast<GLuint>(14),
       static_cast<GLint>(15));
-  EXPECT_EQ(static_cast<uint32>(FramebufferTexture2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::FramebufferTexture2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
   EXPECT_EQ(static_cast<GLint>(15), cmd.level);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, FrontFace) {
-  FrontFace& cmd = *GetBufferAs<FrontFace>();
+  cmds::FrontFace& cmd = *GetBufferAs<cmds::FrontFace>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(FrontFace::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::FrontFace::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenBuffers) {
-  GenBuffers& cmd = *GetBufferAs<GenBuffers>();
+  cmds::GenBuffers& cmd = *GetBufferAs<cmds::GenBuffers>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(GenBuffers::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenBuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenBuffersImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  GenBuffersImmediate& cmd = *GetBufferAs<GenBuffersImmediate>();
+  cmds::GenBuffersImmediate& cmd = *GetBufferAs<cmds::GenBuffersImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(GenBuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenBuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, GenerateMipmap) {
-  GenerateMipmap& cmd = *GetBufferAs<GenerateMipmap>();
+  cmds::GenerateMipmap& cmd = *GetBufferAs<cmds::GenerateMipmap>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11));
-  EXPECT_EQ(static_cast<uint32>(GenerateMipmap::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenerateMipmap::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenFramebuffers) {
-  GenFramebuffers& cmd = *GetBufferAs<GenFramebuffers>();
+  cmds::GenFramebuffers& cmd = *GetBufferAs<cmds::GenFramebuffers>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(GenFramebuffers::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenFramebuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenFramebuffersImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  GenFramebuffersImmediate& cmd = *GetBufferAs<GenFramebuffersImmediate>();
+  cmds::GenFramebuffersImmediate& cmd =
+      *GetBufferAs<cmds::GenFramebuffersImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(GenFramebuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenFramebuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, GenRenderbuffers) {
-  GenRenderbuffers& cmd = *GetBufferAs<GenRenderbuffers>();
+  cmds::GenRenderbuffers& cmd = *GetBufferAs<cmds::GenRenderbuffers>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(GenRenderbuffers::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenRenderbuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenRenderbuffersImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  GenRenderbuffersImmediate& cmd = *GetBufferAs<GenRenderbuffersImmediate>();
+  cmds::GenRenderbuffersImmediate& cmd =
+      *GetBufferAs<cmds::GenRenderbuffersImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(GenRenderbuffersImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenRenderbuffersImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, GenTextures) {
-  GenTextures& cmd = *GetBufferAs<GenTextures>();
+  cmds::GenTextures& cmd = *GetBufferAs<cmds::GenTextures>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(GenTextures::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenTextures::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenTexturesImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  GenTexturesImmediate& cmd = *GetBufferAs<GenTexturesImmediate>();
+  cmds::GenTexturesImmediate& cmd = *GetBufferAs<cmds::GenTexturesImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(GenTexturesImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenTexturesImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, GetActiveAttrib) {
-  GetActiveAttrib& cmd = *GetBufferAs<GetActiveAttrib>();
+  cmds::GetActiveAttrib& cmd = *GetBufferAs<cmds::GetActiveAttrib>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLuint>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(GetActiveAttrib::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetActiveAttrib::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
   EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetActiveUniform) {
-  GetActiveUniform& cmd = *GetBufferAs<GetActiveUniform>();
+  cmds::GetActiveUniform& cmd = *GetBufferAs<cmds::GetActiveUniform>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLuint>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(GetActiveUniform::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetActiveUniform::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
   EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetAttachedShaders) {
-  GetAttachedShaders& cmd = *GetBufferAs<GetAttachedShaders>();
+  cmds::GetAttachedShaders& cmd = *GetBufferAs<cmds::GetAttachedShaders>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetAttachedShaders::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetAttachedShaders::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   EXPECT_EQ(static_cast<uint32>(14), cmd.result_size);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 // TODO(gman): Write test for GetAttribLocation
 // TODO(gman): Write test for GetAttribLocationImmediate
 // TODO(gman): Write test for GetAttribLocationBucket
 TEST_F(GLES2FormatTest, GetBooleanv) {
-  GetBooleanv& cmd = *GetBufferAs<GetBooleanv>();
+  cmds::GetBooleanv& cmd = *GetBufferAs<cmds::GetBooleanv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(GetBooleanv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetBooleanv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetBufferParameteriv) {
-  GetBufferParameteriv& cmd = *GetBufferAs<GetBufferParameteriv>();
+  cmds::GetBufferParameteriv& cmd = *GetBufferAs<cmds::GetBufferParameteriv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetBufferParameteriv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetBufferParameteriv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetError) {
-  GetError& cmd = *GetBufferAs<GetError>();
+  cmds::GetError& cmd = *GetBufferAs<cmds::GetError>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<uint32>(11),
       static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(GetError::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetError::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<uint32>(11), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetFloatv) {
-  GetFloatv& cmd = *GetBufferAs<GetFloatv>();
+  cmds::GetFloatv& cmd = *GetBufferAs<cmds::GetFloatv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(GetFloatv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetFloatv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetFramebufferAttachmentParameteriv) {
-  GetFramebufferAttachmentParameteriv& cmd =
-      *GetBufferAs<GetFramebufferAttachmentParameteriv>();
+  cmds::GetFramebufferAttachmentParameteriv& cmd =
+      *GetBufferAs<cmds::GetFramebufferAttachmentParameteriv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLenum>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(GetFramebufferAttachmentParameteriv::kCmdId),
+  EXPECT_EQ(
+      static_cast<uint32>(cmds::GetFramebufferAttachmentParameteriv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(15), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetIntegerv) {
-  GetIntegerv& cmd = *GetBufferAs<GetIntegerv>();
+  cmds::GetIntegerv& cmd = *GetBufferAs<cmds::GetIntegerv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(GetIntegerv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetIntegerv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetProgramiv) {
-  GetProgramiv& cmd = *GetBufferAs<GetProgramiv>();
+  cmds::GetProgramiv& cmd = *GetBufferAs<cmds::GetProgramiv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetProgramiv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetProgramiv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetProgramInfoLog) {
-  GetProgramInfoLog& cmd = *GetBufferAs<GetProgramInfoLog>();
+  cmds::GetProgramInfoLog& cmd = *GetBufferAs<cmds::GetProgramInfoLog>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(GetProgramInfoLog::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetProgramInfoLog::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetRenderbufferParameteriv) {
-  GetRenderbufferParameteriv& cmd = *GetBufferAs<GetRenderbufferParameteriv>();
+  cmds::GetRenderbufferParameteriv& cmd =
+      *GetBufferAs<cmds::GetRenderbufferParameteriv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetRenderbufferParameteriv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetRenderbufferParameteriv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetShaderiv) {
-  GetShaderiv& cmd = *GetBufferAs<GetShaderiv>();
+  cmds::GetShaderiv& cmd = *GetBufferAs<cmds::GetShaderiv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetShaderiv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderiv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetShaderInfoLog) {
-  GetShaderInfoLog& cmd = *GetBufferAs<GetShaderInfoLog>();
+  cmds::GetShaderInfoLog& cmd = *GetBufferAs<cmds::GetShaderInfoLog>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(GetShaderInfoLog::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderInfoLog::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetShaderPrecisionFormat) {
-  GetShaderPrecisionFormat& cmd = *GetBufferAs<GetShaderPrecisionFormat>();
+  cmds::GetShaderPrecisionFormat& cmd =
+      *GetBufferAs<cmds::GetShaderPrecisionFormat>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetShaderPrecisionFormat::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderPrecisionFormat::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.shadertype);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.precisiontype);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetShaderSource) {
-  GetShaderSource& cmd = *GetBufferAs<GetShaderSource>();
+  cmds::GetShaderSource& cmd = *GetBufferAs<cmds::GetShaderSource>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(GetShaderSource::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetShaderSource::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetString) {
-  GetString& cmd = *GetBufferAs<GetString>();
+  cmds::GetString& cmd = *GetBufferAs<cmds::GetString>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(GetString::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetString::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.name);
   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetTexParameterfv) {
-  GetTexParameterfv& cmd = *GetBufferAs<GetTexParameterfv>();
+  cmds::GetTexParameterfv& cmd = *GetBufferAs<cmds::GetTexParameterfv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetTexParameterfv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetTexParameterfv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetTexParameteriv) {
-  GetTexParameteriv& cmd = *GetBufferAs<GetTexParameteriv>();
+  cmds::GetTexParameteriv& cmd = *GetBufferAs<cmds::GetTexParameteriv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetTexParameteriv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetTexParameteriv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetUniformfv) {
-  GetUniformfv& cmd = *GetBufferAs<GetUniformfv>();
+  cmds::GetUniformfv& cmd = *GetBufferAs<cmds::GetUniformfv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLint>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetUniformfv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetUniformfv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetUniformiv) {
-  GetUniformiv& cmd = *GetBufferAs<GetUniformiv>();
+  cmds::GetUniformiv& cmd = *GetBufferAs<cmds::GetUniformiv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLint>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetUniformiv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetUniformiv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 // TODO(gman): Write test for GetUniformLocation
 // TODO(gman): Write test for GetUniformLocationImmediate
 // TODO(gman): Write test for GetUniformLocationBucket
 TEST_F(GLES2FormatTest, GetVertexAttribfv) {
-  GetVertexAttribfv& cmd = *GetBufferAs<GetVertexAttribfv>();
+  cmds::GetVertexAttribfv& cmd = *GetBufferAs<cmds::GetVertexAttribfv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetVertexAttribfv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetVertexAttribfv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetVertexAttribiv) {
-  GetVertexAttribiv& cmd = *GetBufferAs<GetVertexAttribiv>();
+  cmds::GetVertexAttribiv& cmd = *GetBufferAs<cmds::GetVertexAttribiv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetVertexAttribiv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetVertexAttribiv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetVertexAttribPointerv) {
-  GetVertexAttribPointerv& cmd = *GetBufferAs<GetVertexAttribPointerv>();
+  cmds::GetVertexAttribPointerv& cmd =
+      *GetBufferAs<cmds::GetVertexAttribPointerv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(GetVertexAttribPointerv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetVertexAttribPointerv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.pointer_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.pointer_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Hint) {
-  Hint& cmd = *GetBufferAs<Hint>();
+  cmds::Hint& cmd = *GetBufferAs<cmds::Hint>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12));
-  EXPECT_EQ(static_cast<uint32>(Hint::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Hint::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.mode);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, IsBuffer) {
-  IsBuffer& cmd = *GetBufferAs<IsBuffer>();
+  cmds::IsBuffer& cmd = *GetBufferAs<cmds::IsBuffer>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(IsBuffer::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::IsBuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, IsEnabled) {
-  IsEnabled& cmd = *GetBufferAs<IsEnabled>();
+  cmds::IsEnabled& cmd = *GetBufferAs<cmds::IsEnabled>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(IsEnabled::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::IsEnabled::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, IsFramebuffer) {
-  IsFramebuffer& cmd = *GetBufferAs<IsFramebuffer>();
+  cmds::IsFramebuffer& cmd = *GetBufferAs<cmds::IsFramebuffer>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(IsFramebuffer::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::IsFramebuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.framebuffer);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, IsProgram) {
-  IsProgram& cmd = *GetBufferAs<IsProgram>();
+  cmds::IsProgram& cmd = *GetBufferAs<cmds::IsProgram>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(IsProgram::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::IsProgram::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, IsRenderbuffer) {
-  IsRenderbuffer& cmd = *GetBufferAs<IsRenderbuffer>();
+  cmds::IsRenderbuffer& cmd = *GetBufferAs<cmds::IsRenderbuffer>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(IsRenderbuffer::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::IsRenderbuffer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.renderbuffer);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, IsShader) {
-  IsShader& cmd = *GetBufferAs<IsShader>();
+  cmds::IsShader& cmd = *GetBufferAs<cmds::IsShader>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(IsShader::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::IsShader::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, IsTexture) {
-  IsTexture& cmd = *GetBufferAs<IsTexture>();
+  cmds::IsTexture& cmd = *GetBufferAs<cmds::IsTexture>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(IsTexture::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::IsTexture::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.texture);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, LineWidth) {
-  LineWidth& cmd = *GetBufferAs<LineWidth>();
+  cmds::LineWidth& cmd = *GetBufferAs<cmds::LineWidth>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLfloat>(11));
-  EXPECT_EQ(static_cast<uint32>(LineWidth::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::LineWidth::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLfloat>(11), cmd.width);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, LinkProgram) {
-  LinkProgram& cmd = *GetBufferAs<LinkProgram>();
+  cmds::LinkProgram& cmd = *GetBufferAs<cmds::LinkProgram>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(LinkProgram::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::LinkProgram::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, PixelStorei) {
-  PixelStorei& cmd = *GetBufferAs<PixelStorei>();
+  cmds::PixelStorei& cmd = *GetBufferAs<cmds::PixelStorei>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12));
-  EXPECT_EQ(static_cast<uint32>(PixelStorei::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::PixelStorei::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
   EXPECT_EQ(static_cast<GLint>(12), cmd.param);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, PolygonOffset) {
-  PolygonOffset& cmd = *GetBufferAs<PolygonOffset>();
+  cmds::PolygonOffset& cmd = *GetBufferAs<cmds::PolygonOffset>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLfloat>(11),
       static_cast<GLfloat>(12));
-  EXPECT_EQ(static_cast<uint32>(PolygonOffset::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::PolygonOffset::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLfloat>(11), cmd.factor);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.units);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ReadPixels) {
-  ReadPixels& cmd = *GetBufferAs<ReadPixels>();
+  cmds::ReadPixels& cmd = *GetBufferAs<cmds::ReadPixels>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLint>(12),
       static_cast<GLsizei>(13),
       static_cast<GLsizei>(14),
       static_cast<GLenum>(15),
       static_cast<GLenum>(16),
       static_cast<uint32>(17),
       static_cast<uint32>(18),
       static_cast<uint32>(19),
       static_cast<uint32>(20));
-  EXPECT_EQ(static_cast<uint32>(ReadPixels::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ReadPixels::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(15), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(16), cmd.type);
   EXPECT_EQ(static_cast<uint32>(17), cmd.pixels_shm_id);
   EXPECT_EQ(static_cast<uint32>(18), cmd.pixels_shm_offset);
   EXPECT_EQ(static_cast<uint32>(19), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(20), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ReleaseShaderCompiler) {
-  ReleaseShaderCompiler& cmd = *GetBufferAs<ReleaseShaderCompiler>();
+  cmds::ReleaseShaderCompiler& cmd =
+      *GetBufferAs<cmds::ReleaseShaderCompiler>();
   void* next_cmd = cmd.Set(
       &cmd);
-  EXPECT_EQ(static_cast<uint32>(ReleaseShaderCompiler::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ReleaseShaderCompiler::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, RenderbufferStorage) {
-  RenderbufferStorage& cmd = *GetBufferAs<RenderbufferStorage>();
+  cmds::RenderbufferStorage& cmd = *GetBufferAs<cmds::RenderbufferStorage>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLsizei>(13),
       static_cast<GLsizei>(14));
-  EXPECT_EQ(static_cast<uint32>(RenderbufferStorage::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::RenderbufferStorage::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, SampleCoverage) {
-  SampleCoverage& cmd = *GetBufferAs<SampleCoverage>();
+  cmds::SampleCoverage& cmd = *GetBufferAs<cmds::SampleCoverage>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLclampf>(11),
       static_cast<GLboolean>(12));
-  EXPECT_EQ(static_cast<uint32>(SampleCoverage::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::SampleCoverage::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLclampf>(11), cmd.value);
   EXPECT_EQ(static_cast<GLboolean>(12), cmd.invert);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Scissor) {
-  Scissor& cmd = *GetBufferAs<Scissor>();
+  cmds::Scissor& cmd = *GetBufferAs<cmds::Scissor>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLint>(12),
       static_cast<GLsizei>(13),
       static_cast<GLsizei>(14));
-  EXPECT_EQ(static_cast<uint32>(Scissor::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Scissor::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ShaderBinary) {
-  ShaderBinary& cmd = *GetBufferAs<ShaderBinary>();
+  cmds::ShaderBinary& cmd = *GetBufferAs<cmds::ShaderBinary>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13),
       static_cast<GLenum>(14),
       static_cast<uint32>(15),
       static_cast<uint32>(16),
       static_cast<GLsizei>(17));
-  EXPECT_EQ(static_cast<uint32>(ShaderBinary::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ShaderBinary::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.shaders_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.shaders_shm_offset);
   EXPECT_EQ(static_cast<GLenum>(14), cmd.binaryformat);
   EXPECT_EQ(static_cast<uint32>(15), cmd.binary_shm_id);
   EXPECT_EQ(static_cast<uint32>(16), cmd.binary_shm_offset);
   EXPECT_EQ(static_cast<GLsizei>(17), cmd.length);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ShaderSource) {
-  ShaderSource& cmd = *GetBufferAs<ShaderSource>();
+  cmds::ShaderSource& cmd = *GetBufferAs<cmds::ShaderSource>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(ShaderSource::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ShaderSource::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   EXPECT_EQ(static_cast<uint32>(12), cmd.data_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_offset);
   EXPECT_EQ(static_cast<uint32>(14), cmd.data_size);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 // TODO(gman): Implement test for ShaderSourceImmediate
 TEST_F(GLES2FormatTest, ShaderSourceBucket) {
-  ShaderSourceBucket& cmd = *GetBufferAs<ShaderSourceBucket>();
+  cmds::ShaderSourceBucket& cmd = *GetBufferAs<cmds::ShaderSourceBucket>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(ShaderSourceBucket::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ShaderSourceBucket::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   EXPECT_EQ(static_cast<uint32>(12), cmd.data_bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, StencilFunc) {
-  StencilFunc& cmd = *GetBufferAs<StencilFunc>();
+  cmds::StencilFunc& cmd = *GetBufferAs<cmds::StencilFunc>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLuint>(13));
-  EXPECT_EQ(static_cast<uint32>(StencilFunc::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::StencilFunc::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
   EXPECT_EQ(static_cast<GLint>(12), cmd.ref);
   EXPECT_EQ(static_cast<GLuint>(13), cmd.mask);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, StencilFuncSeparate) {
-  StencilFuncSeparate& cmd = *GetBufferAs<StencilFuncSeparate>();
+  cmds::StencilFuncSeparate& cmd = *GetBufferAs<cmds::StencilFuncSeparate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLint>(13),
       static_cast<GLuint>(14));
-  EXPECT_EQ(static_cast<uint32>(StencilFuncSeparate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::StencilFuncSeparate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.func);
   EXPECT_EQ(static_cast<GLint>(13), cmd.ref);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.mask);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, StencilMask) {
-  StencilMask& cmd = *GetBufferAs<StencilMask>();
+  cmds::StencilMask& cmd = *GetBufferAs<cmds::StencilMask>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(StencilMask::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::StencilMask::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.mask);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, StencilMaskSeparate) {
-  StencilMaskSeparate& cmd = *GetBufferAs<StencilMaskSeparate>();
+  cmds::StencilMaskSeparate& cmd = *GetBufferAs<cmds::StencilMaskSeparate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(StencilMaskSeparate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::StencilMaskSeparate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.mask);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, StencilOp) {
-  StencilOp& cmd = *GetBufferAs<StencilOp>();
+  cmds::StencilOp& cmd = *GetBufferAs<cmds::StencilOp>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLenum>(13));
-  EXPECT_EQ(static_cast<uint32>(StencilOp::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::StencilOp::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.fail);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.zfail);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.zpass);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, StencilOpSeparate) {
-  StencilOpSeparate& cmd = *GetBufferAs<StencilOpSeparate>();
+  cmds::StencilOpSeparate& cmd = *GetBufferAs<cmds::StencilOpSeparate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLenum>(13),
       static_cast<GLenum>(14));
-  EXPECT_EQ(static_cast<uint32>(StencilOpSeparate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::StencilOpSeparate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.fail);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.zfail);
   EXPECT_EQ(static_cast<GLenum>(14), cmd.zpass);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexImage2D) {
-  TexImage2D& cmd = *GetBufferAs<TexImage2D>();
+  cmds::TexImage2D& cmd = *GetBufferAs<cmds::TexImage2D>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLsizei>(14),
       static_cast<GLsizei>(15),
       static_cast<GLint>(16),
       static_cast<GLenum>(17),
       static_cast<GLenum>(18),
       static_cast<uint32>(19),
       static_cast<uint32>(20));
-  EXPECT_EQ(static_cast<uint32>(TexImage2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TexImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
   EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
   EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 // TODO(gman): Implement test for TexImage2DImmediate
 TEST_F(GLES2FormatTest, TexParameterf) {
-  TexParameterf& cmd = *GetBufferAs<TexParameterf>();
+  cmds::TexParameterf& cmd = *GetBufferAs<cmds::TexParameterf>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLfloat>(13));
-  EXPECT_EQ(static_cast<uint32>(TexParameterf::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterf::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.param);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexParameterfv) {
-  TexParameterfv& cmd = *GetBufferAs<TexParameterfv>();
+  cmds::TexParameterfv& cmd = *GetBufferAs<cmds::TexParameterfv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(TexParameterfv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterfv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexParameterfvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
   };
-  TexParameterfvImmediate& cmd = *GetBufferAs<TexParameterfvImmediate>();
+  cmds::TexParameterfvImmediate& cmd =
+      *GetBufferAs<cmds::TexParameterfvImmediate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       data);
-  EXPECT_EQ(static_cast<uint32>(TexParameterfvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterfvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, TexParameteri) {
-  TexParameteri& cmd = *GetBufferAs<TexParameteri>();
+  cmds::TexParameteri& cmd = *GetBufferAs<cmds::TexParameteri>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLint>(13));
-  EXPECT_EQ(static_cast<uint32>(TexParameteri::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TexParameteri::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<GLint>(13), cmd.param);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexParameteriv) {
-  TexParameteriv& cmd = *GetBufferAs<TexParameteriv>();
+  cmds::TexParameteriv& cmd = *GetBufferAs<cmds::TexParameteriv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(TexParameteriv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TexParameteriv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexParameterivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLint data[] = {
     static_cast<GLint>(kSomeBaseValueToTestWith + 0),
   };
-  TexParameterivImmediate& cmd = *GetBufferAs<TexParameterivImmediate>();
+  cmds::TexParameterivImmediate& cmd =
+      *GetBufferAs<cmds::TexParameterivImmediate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       data);
-  EXPECT_EQ(static_cast<uint32>(TexParameterivImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TexParameterivImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, TexSubImage2D) {
-  TexSubImage2D& cmd = *GetBufferAs<TexSubImage2D>();
+  cmds::TexSubImage2D& cmd = *GetBufferAs<cmds::TexSubImage2D>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLint>(14),
       static_cast<GLsizei>(15),
       static_cast<GLsizei>(16),
       static_cast<GLenum>(17),
       static_cast<GLenum>(18),
       static_cast<uint32>(19),
       static_cast<uint32>(20),
       static_cast<GLboolean>(21));
-  EXPECT_EQ(static_cast<uint32>(TexSubImage2D::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TexSubImage2D::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
   EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
   EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
   EXPECT_EQ(static_cast<GLboolean>(21), cmd.internal);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 // TODO(gman): Implement test for TexSubImage2DImmediate
 TEST_F(GLES2FormatTest, Uniform1f) {
-  Uniform1f& cmd = *GetBufferAs<Uniform1f>();
+  cmds::Uniform1f& cmd = *GetBufferAs<cmds::Uniform1f>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLfloat>(12));
-  EXPECT_EQ(static_cast<uint32>(Uniform1f::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform1fv) {
-  Uniform1fv& cmd = *GetBufferAs<Uniform1fv>();
+  cmds::Uniform1fv& cmd = *GetBufferAs<cmds::Uniform1fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(Uniform1fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform1fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
   };
-  Uniform1fvImmediate& cmd = *GetBufferAs<Uniform1fvImmediate>();
+  cmds::Uniform1fvImmediate& cmd = *GetBufferAs<cmds::Uniform1fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 1;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       data);
-  EXPECT_EQ(static_cast<uint32>(Uniform1fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform1i) {
-  Uniform1i& cmd = *GetBufferAs<Uniform1i>();
+  cmds::Uniform1i& cmd = *GetBufferAs<cmds::Uniform1i>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLint>(12));
-  EXPECT_EQ(static_cast<uint32>(Uniform1i::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1i::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform1iv) {
-  Uniform1iv& cmd = *GetBufferAs<Uniform1iv>();
+  cmds::Uniform1iv& cmd = *GetBufferAs<cmds::Uniform1iv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(Uniform1iv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1iv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform1ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLint data[] = {
     static_cast<GLint>(kSomeBaseValueToTestWith + 0),
     static_cast<GLint>(kSomeBaseValueToTestWith + 1),
   };
-  Uniform1ivImmediate& cmd = *GetBufferAs<Uniform1ivImmediate>();
+  cmds::Uniform1ivImmediate& cmd = *GetBufferAs<cmds::Uniform1ivImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLint) * 1;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       data);
-  EXPECT_EQ(static_cast<uint32>(Uniform1ivImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform1ivImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform2f) {
-  Uniform2f& cmd = *GetBufferAs<Uniform2f>();
+  cmds::Uniform2f& cmd = *GetBufferAs<cmds::Uniform2f>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLfloat>(12),
       static_cast<GLfloat>(13));
-  EXPECT_EQ(static_cast<uint32>(Uniform2f::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform2fv) {
-  Uniform2fv& cmd = *GetBufferAs<Uniform2fv>();
+  cmds::Uniform2fv& cmd = *GetBufferAs<cmds::Uniform2fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(Uniform2fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform2fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
   };
-  Uniform2fvImmediate& cmd = *GetBufferAs<Uniform2fvImmediate>();
+  cmds::Uniform2fvImmediate& cmd = *GetBufferAs<cmds::Uniform2fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 2;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       data);
-  EXPECT_EQ(static_cast<uint32>(Uniform2fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform2i) {
-  Uniform2i& cmd = *GetBufferAs<Uniform2i>();
+  cmds::Uniform2i& cmd = *GetBufferAs<cmds::Uniform2i>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13));
-  EXPECT_EQ(static_cast<uint32>(Uniform2i::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2i::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
   EXPECT_EQ(static_cast<GLint>(13), cmd.y);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform2iv) {
-  Uniform2iv& cmd = *GetBufferAs<Uniform2iv>();
+  cmds::Uniform2iv& cmd = *GetBufferAs<cmds::Uniform2iv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(Uniform2iv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2iv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform2ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLint data[] = {
     static_cast<GLint>(kSomeBaseValueToTestWith + 0),
     static_cast<GLint>(kSomeBaseValueToTestWith + 1),
     static_cast<GLint>(kSomeBaseValueToTestWith + 2),
     static_cast<GLint>(kSomeBaseValueToTestWith + 3),
   };
-  Uniform2ivImmediate& cmd = *GetBufferAs<Uniform2ivImmediate>();
+  cmds::Uniform2ivImmediate& cmd = *GetBufferAs<cmds::Uniform2ivImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLint) * 2;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       data);
-  EXPECT_EQ(static_cast<uint32>(Uniform2ivImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform2ivImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform3f) {
-  Uniform3f& cmd = *GetBufferAs<Uniform3f>();
+  cmds::Uniform3f& cmd = *GetBufferAs<cmds::Uniform3f>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLfloat>(12),
       static_cast<GLfloat>(13),
       static_cast<GLfloat>(14));
-  EXPECT_EQ(static_cast<uint32>(Uniform3f::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform3fv) {
-  Uniform3fv& cmd = *GetBufferAs<Uniform3fv>();
+  cmds::Uniform3fv& cmd = *GetBufferAs<cmds::Uniform3fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(Uniform3fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform3fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
   };
-  Uniform3fvImmediate& cmd = *GetBufferAs<Uniform3fvImmediate>();
+  cmds::Uniform3fvImmediate& cmd = *GetBufferAs<cmds::Uniform3fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 3;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       data);
-  EXPECT_EQ(static_cast<uint32>(Uniform3fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform3i) {
-  Uniform3i& cmd = *GetBufferAs<Uniform3i>();
+  cmds::Uniform3i& cmd = *GetBufferAs<cmds::Uniform3i>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLint>(14));
-  EXPECT_EQ(static_cast<uint32>(Uniform3i::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3i::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
   EXPECT_EQ(static_cast<GLint>(13), cmd.y);
   EXPECT_EQ(static_cast<GLint>(14), cmd.z);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform3iv) {
-  Uniform3iv& cmd = *GetBufferAs<Uniform3iv>();
+  cmds::Uniform3iv& cmd = *GetBufferAs<cmds::Uniform3iv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(Uniform3iv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3iv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform3ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLint data[] = {
     static_cast<GLint>(kSomeBaseValueToTestWith + 0),
     static_cast<GLint>(kSomeBaseValueToTestWith + 1),
     static_cast<GLint>(kSomeBaseValueToTestWith + 2),
     static_cast<GLint>(kSomeBaseValueToTestWith + 3),
     static_cast<GLint>(kSomeBaseValueToTestWith + 4),
     static_cast<GLint>(kSomeBaseValueToTestWith + 5),
   };
-  Uniform3ivImmediate& cmd = *GetBufferAs<Uniform3ivImmediate>();
+  cmds::Uniform3ivImmediate& cmd = *GetBufferAs<cmds::Uniform3ivImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLint) * 3;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       data);
-  EXPECT_EQ(static_cast<uint32>(Uniform3ivImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform3ivImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform4f) {
-  Uniform4f& cmd = *GetBufferAs<Uniform4f>();
+  cmds::Uniform4f& cmd = *GetBufferAs<cmds::Uniform4f>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLfloat>(12),
       static_cast<GLfloat>(13),
       static_cast<GLfloat>(14),
       static_cast<GLfloat>(15));
-  EXPECT_EQ(static_cast<uint32>(Uniform4f::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
   EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform4fv) {
-  Uniform4fv& cmd = *GetBufferAs<Uniform4fv>();
+  cmds::Uniform4fv& cmd = *GetBufferAs<cmds::Uniform4fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(Uniform4fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform4fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
   };
-  Uniform4fvImmediate& cmd = *GetBufferAs<Uniform4fvImmediate>();
+  cmds::Uniform4fvImmediate& cmd = *GetBufferAs<cmds::Uniform4fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       data);
-  EXPECT_EQ(static_cast<uint32>(Uniform4fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, Uniform4i) {
-  Uniform4i& cmd = *GetBufferAs<Uniform4i>();
+  cmds::Uniform4i& cmd = *GetBufferAs<cmds::Uniform4i>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLint>(14),
       static_cast<GLint>(15));
-  EXPECT_EQ(static_cast<uint32>(Uniform4i::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4i::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
   EXPECT_EQ(static_cast<GLint>(13), cmd.y);
   EXPECT_EQ(static_cast<GLint>(14), cmd.z);
   EXPECT_EQ(static_cast<GLint>(15), cmd.w);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform4iv) {
-  Uniform4iv& cmd = *GetBufferAs<Uniform4iv>();
+  cmds::Uniform4iv& cmd = *GetBufferAs<cmds::Uniform4iv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(Uniform4iv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4iv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Uniform4ivImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLint data[] = {
     static_cast<GLint>(kSomeBaseValueToTestWith + 0),
     static_cast<GLint>(kSomeBaseValueToTestWith + 1),
     static_cast<GLint>(kSomeBaseValueToTestWith + 2),
     static_cast<GLint>(kSomeBaseValueToTestWith + 3),
     static_cast<GLint>(kSomeBaseValueToTestWith + 4),
     static_cast<GLint>(kSomeBaseValueToTestWith + 5),
     static_cast<GLint>(kSomeBaseValueToTestWith + 6),
     static_cast<GLint>(kSomeBaseValueToTestWith + 7),
   };
-  Uniform4ivImmediate& cmd = *GetBufferAs<Uniform4ivImmediate>();
+  cmds::Uniform4ivImmediate& cmd = *GetBufferAs<cmds::Uniform4ivImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLint) * 4;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       data);
-  EXPECT_EQ(static_cast<uint32>(Uniform4ivImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Uniform4ivImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, UniformMatrix2fv) {
-  UniformMatrix2fv& cmd = *GetBufferAs<UniformMatrix2fv>();
+  cmds::UniformMatrix2fv& cmd = *GetBufferAs<cmds::UniformMatrix2fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<GLboolean>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(UniformMatrix2fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix2fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
   EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
   EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, UniformMatrix2fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 4),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 5),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 6),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 7),
   };
-  UniformMatrix2fvImmediate& cmd = *GetBufferAs<UniformMatrix2fvImmediate>();
+  cmds::UniformMatrix2fvImmediate& cmd =
+      *GetBufferAs<cmds::UniformMatrix2fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       static_cast<GLboolean>(3),
       data);
-  EXPECT_EQ(static_cast<uint32>(UniformMatrix2fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix2fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, UniformMatrix3fv) {
-  UniformMatrix3fv& cmd = *GetBufferAs<UniformMatrix3fv>();
+  cmds::UniformMatrix3fv& cmd = *GetBufferAs<cmds::UniformMatrix3fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<GLboolean>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(UniformMatrix3fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix3fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
   EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
   EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
@@ skipping 13 matching lines @@
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 9),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 10),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 11),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 12),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 13),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 14),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 15),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 16),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 17),
   };
-  UniformMatrix3fvImmediate& cmd = *GetBufferAs<UniformMatrix3fvImmediate>();
+  cmds::UniformMatrix3fvImmediate& cmd =
+      *GetBufferAs<cmds::UniformMatrix3fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 9;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       static_cast<GLboolean>(3),
       data);
-  EXPECT_EQ(static_cast<uint32>(UniformMatrix3fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix3fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, UniformMatrix4fv) {
-  UniformMatrix4fv& cmd = *GetBufferAs<UniformMatrix4fv>();
+  cmds::UniformMatrix4fv& cmd = *GetBufferAs<cmds::UniformMatrix4fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLsizei>(12),
       static_cast<GLboolean>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(UniformMatrix4fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix4fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
   EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
   EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
@@ skipping 27 matching lines @@
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 23),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 24),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 25),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 26),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 27),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 28),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 29),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 30),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 31),
   };
-  UniformMatrix4fvImmediate& cmd = *GetBufferAs<UniformMatrix4fvImmediate>();
+  cmds::UniformMatrix4fvImmediate& cmd =
+      *GetBufferAs<cmds::UniformMatrix4fvImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 16;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(1),
       static_cast<GLsizei>(2),
       static_cast<GLboolean>(3),
       data);
-  EXPECT_EQ(static_cast<uint32>(UniformMatrix4fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::UniformMatrix4fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, UseProgram) {
-  UseProgram& cmd = *GetBufferAs<UseProgram>();
+  cmds::UseProgram& cmd = *GetBufferAs<cmds::UseProgram>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(UseProgram::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::UseProgram::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ValidateProgram) {
-  ValidateProgram& cmd = *GetBufferAs<ValidateProgram>();
+  cmds::ValidateProgram& cmd = *GetBufferAs<cmds::ValidateProgram>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(ValidateProgram::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ValidateProgram::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib1f) {
-  VertexAttrib1f& cmd = *GetBufferAs<VertexAttrib1f>();
+  cmds::VertexAttrib1f& cmd = *GetBufferAs<cmds::VertexAttrib1f>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLfloat>(12));
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib1f::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib1fv) {
-  VertexAttrib1fv& cmd = *GetBufferAs<VertexAttrib1fv>();
+  cmds::VertexAttrib1fv& cmd = *GetBufferAs<cmds::VertexAttrib1fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib1fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib1fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
   };
-  VertexAttrib1fvImmediate& cmd = *GetBufferAs<VertexAttrib1fvImmediate>();
+  cmds::VertexAttrib1fvImmediate& cmd =
+      *GetBufferAs<cmds::VertexAttrib1fvImmediate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       data);
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib1fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib1fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib2f) {
-  VertexAttrib2f& cmd = *GetBufferAs<VertexAttrib2f>();
+  cmds::VertexAttrib2f& cmd = *GetBufferAs<cmds::VertexAttrib2f>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLfloat>(12),
       static_cast<GLfloat>(13));
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib2f::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib2fv) {
-  VertexAttrib2fv& cmd = *GetBufferAs<VertexAttrib2fv>();
+  cmds::VertexAttrib2fv& cmd = *GetBufferAs<cmds::VertexAttrib2fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib2fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib2fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
   };
-  VertexAttrib2fvImmediate& cmd = *GetBufferAs<VertexAttrib2fvImmediate>();
+  cmds::VertexAttrib2fvImmediate& cmd =
+      *GetBufferAs<cmds::VertexAttrib2fvImmediate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       data);
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib2fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib2fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib3f) {
-  VertexAttrib3f& cmd = *GetBufferAs<VertexAttrib3f>();
+  cmds::VertexAttrib3f& cmd = *GetBufferAs<cmds::VertexAttrib3f>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLfloat>(12),
       static_cast<GLfloat>(13),
       static_cast<GLfloat>(14));
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib3f::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib3fv) {
-  VertexAttrib3fv& cmd = *GetBufferAs<VertexAttrib3fv>();
+  cmds::VertexAttrib3fv& cmd = *GetBufferAs<cmds::VertexAttrib3fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib3fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib3fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
   };
-  VertexAttrib3fvImmediate& cmd = *GetBufferAs<VertexAttrib3fvImmediate>();
+  cmds::VertexAttrib3fvImmediate& cmd =
+      *GetBufferAs<cmds::VertexAttrib3fvImmediate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       data);
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib3fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib3fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib4f) {
-  VertexAttrib4f& cmd = *GetBufferAs<VertexAttrib4f>();
+  cmds::VertexAttrib4f& cmd = *GetBufferAs<cmds::VertexAttrib4f>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLfloat>(12),
       static_cast<GLfloat>(13),
       static_cast<GLfloat>(14),
       static_cast<GLfloat>(15));
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib4f::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4f::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
   EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib4fv) {
-  VertexAttrib4fv& cmd = *GetBufferAs<VertexAttrib4fv>();
+  cmds::VertexAttrib4fv& cmd = *GetBufferAs<cmds::VertexAttrib4fv>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib4fv::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4fv::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttrib4fvImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLfloat data[] = {
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 0),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 1),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 2),
     static_cast<GLfloat>(kSomeBaseValueToTestWith + 3),
   };
-  VertexAttrib4fvImmediate& cmd = *GetBufferAs<VertexAttrib4fvImmediate>();
+  cmds::VertexAttrib4fvImmediate& cmd =
+      *GetBufferAs<cmds::VertexAttrib4fvImmediate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       data);
-  EXPECT_EQ(static_cast<uint32>(VertexAttrib4fvImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttrib4fvImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, VertexAttribPointer) {
-  VertexAttribPointer& cmd = *GetBufferAs<VertexAttribPointer>();
+  cmds::VertexAttribPointer& cmd = *GetBufferAs<cmds::VertexAttribPointer>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLint>(12),
       static_cast<GLenum>(13),
       static_cast<GLboolean>(14),
       static_cast<GLsizei>(15),
       static_cast<GLuint>(16));
-  EXPECT_EQ(static_cast<uint32>(VertexAttribPointer::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttribPointer::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
   EXPECT_EQ(static_cast<GLint>(12), cmd.size);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
   EXPECT_EQ(static_cast<GLboolean>(14), cmd.normalized);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.stride);
   EXPECT_EQ(static_cast<GLuint>(16), cmd.offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, Viewport) {
-  Viewport& cmd = *GetBufferAs<Viewport>();
+  cmds::Viewport& cmd = *GetBufferAs<cmds::Viewport>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLint>(12),
       static_cast<GLsizei>(13),
       static_cast<GLsizei>(14));
-  EXPECT_EQ(static_cast<uint32>(Viewport::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::Viewport::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BlitFramebufferEXT) {
-  BlitFramebufferEXT& cmd = *GetBufferAs<BlitFramebufferEXT>();
+  cmds::BlitFramebufferEXT& cmd = *GetBufferAs<cmds::BlitFramebufferEXT>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLint>(14),
       static_cast<GLint>(15),
       static_cast<GLint>(16),
       static_cast<GLint>(17),
       static_cast<GLint>(18),
       static_cast<GLbitfield>(19),
       static_cast<GLenum>(20));
-  EXPECT_EQ(static_cast<uint32>(BlitFramebufferEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BlitFramebufferEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.srcX0);
   EXPECT_EQ(static_cast<GLint>(12), cmd.srcY0);
   EXPECT_EQ(static_cast<GLint>(13), cmd.srcX1);
   EXPECT_EQ(static_cast<GLint>(14), cmd.srcY1);
   EXPECT_EQ(static_cast<GLint>(15), cmd.dstX0);
   EXPECT_EQ(static_cast<GLint>(16), cmd.dstY0);
   EXPECT_EQ(static_cast<GLint>(17), cmd.dstX1);
   EXPECT_EQ(static_cast<GLint>(18), cmd.dstY1);
   EXPECT_EQ(static_cast<GLbitfield>(19), cmd.mask);
   EXPECT_EQ(static_cast<GLenum>(20), cmd.filter);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, RenderbufferStorageMultisampleEXT) {
-  RenderbufferStorageMultisampleEXT& cmd =
-      *GetBufferAs<RenderbufferStorageMultisampleEXT>();
+  cmds::RenderbufferStorageMultisampleEXT& cmd =
+      *GetBufferAs<cmds::RenderbufferStorageMultisampleEXT>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLsizei>(12),
       static_cast<GLenum>(13),
       static_cast<GLsizei>(14),
       static_cast<GLsizei>(15));
-  EXPECT_EQ(static_cast<uint32>(RenderbufferStorageMultisampleEXT::kCmdId),
+  EXPECT_EQ(
+      static_cast<uint32>(cmds::RenderbufferStorageMultisampleEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.samples);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexStorage2DEXT) {
-  TexStorage2DEXT& cmd = *GetBufferAs<TexStorage2DEXT>();
+  cmds::TexStorage2DEXT& cmd = *GetBufferAs<cmds::TexStorage2DEXT>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLsizei>(12),
       static_cast<GLenum>(13),
       static_cast<GLsizei>(14),
       static_cast<GLsizei>(15));
-  EXPECT_EQ(static_cast<uint32>(TexStorage2DEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TexStorage2DEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.levels);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalFormat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenQueriesEXT) {
-  GenQueriesEXT& cmd = *GetBufferAs<GenQueriesEXT>();
+  cmds::GenQueriesEXT& cmd = *GetBufferAs<cmds::GenQueriesEXT>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(GenQueriesEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenQueriesEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.queries_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.queries_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenQueriesEXTImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  GenQueriesEXTImmediate& cmd = *GetBufferAs<GenQueriesEXTImmediate>();
+  cmds::GenQueriesEXTImmediate& cmd =
+      *GetBufferAs<cmds::GenQueriesEXTImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(GenQueriesEXTImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenQueriesEXTImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, DeleteQueriesEXT) {
-  DeleteQueriesEXT& cmd = *GetBufferAs<DeleteQueriesEXT>();
+  cmds::DeleteQueriesEXT& cmd = *GetBufferAs<cmds::DeleteQueriesEXT>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(DeleteQueriesEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteQueriesEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.queries_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.queries_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteQueriesEXTImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  DeleteQueriesEXTImmediate& cmd = *GetBufferAs<DeleteQueriesEXTImmediate>();
+  cmds::DeleteQueriesEXTImmediate& cmd =
+      *GetBufferAs<cmds::DeleteQueriesEXTImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(DeleteQueriesEXTImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteQueriesEXTImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, BeginQueryEXT) {
-  BeginQueryEXT& cmd = *GetBufferAs<BeginQueryEXT>();
+  cmds::BeginQueryEXT& cmd = *GetBufferAs<cmds::BeginQueryEXT>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLuint>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(BeginQueryEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BeginQueryEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.sync_data_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.sync_data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, EndQueryEXT) {
-  EndQueryEXT& cmd = *GetBufferAs<EndQueryEXT>();
+  cmds::EndQueryEXT& cmd = *GetBufferAs<cmds::EndQueryEXT>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(EndQueryEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::EndQueryEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.submit_count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, InsertEventMarkerEXT) {
-  InsertEventMarkerEXT& cmd = *GetBufferAs<InsertEventMarkerEXT>();
+  cmds::InsertEventMarkerEXT& cmd = *GetBufferAs<cmds::InsertEventMarkerEXT>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(InsertEventMarkerEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::InsertEventMarkerEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, PushGroupMarkerEXT) {
-  PushGroupMarkerEXT& cmd = *GetBufferAs<PushGroupMarkerEXT>();
+  cmds::PushGroupMarkerEXT& cmd = *GetBufferAs<cmds::PushGroupMarkerEXT>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(PushGroupMarkerEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::PushGroupMarkerEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, PopGroupMarkerEXT) {
-  PopGroupMarkerEXT& cmd = *GetBufferAs<PopGroupMarkerEXT>();
+  cmds::PopGroupMarkerEXT& cmd = *GetBufferAs<cmds::PopGroupMarkerEXT>();
   void* next_cmd = cmd.Set(
       &cmd);
-  EXPECT_EQ(static_cast<uint32>(PopGroupMarkerEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::PopGroupMarkerEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenVertexArraysOES) {
-  GenVertexArraysOES& cmd = *GetBufferAs<GenVertexArraysOES>();
+  cmds::GenVertexArraysOES& cmd = *GetBufferAs<cmds::GenVertexArraysOES>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(GenVertexArraysOES::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenVertexArraysOES::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.arrays_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.arrays_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenVertexArraysOESImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  GenVertexArraysOESImmediate& cmd =
-      *GetBufferAs<GenVertexArraysOESImmediate>();
+  cmds::GenVertexArraysOESImmediate& cmd =
+      *GetBufferAs<cmds::GenVertexArraysOESImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(GenVertexArraysOESImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenVertexArraysOESImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, DeleteVertexArraysOES) {
-  DeleteVertexArraysOES& cmd = *GetBufferAs<DeleteVertexArraysOES>();
+  cmds::DeleteVertexArraysOES& cmd =
+      *GetBufferAs<cmds::DeleteVertexArraysOES>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLsizei>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(DeleteVertexArraysOES::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteVertexArraysOES::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
   EXPECT_EQ(static_cast<uint32>(12), cmd.arrays_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.arrays_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteVertexArraysOESImmediate) {
   static GLuint ids[] = { 12, 23, 34, };
-  DeleteVertexArraysOESImmediate& cmd =
-      *GetBufferAs<DeleteVertexArraysOESImmediate>();
+  cmds::DeleteVertexArraysOESImmediate& cmd =
+      *GetBufferAs<cmds::DeleteVertexArraysOESImmediate>();
   void* next_cmd = cmd.Set(
       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
-  EXPECT_EQ(static_cast<uint32>(DeleteVertexArraysOESImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteVertexArraysOESImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(cmd.n * 4u),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(arraysize(ids) * 4u));
   // TODO(gman): Check that ids were inserted;
 }
 
 TEST_F(GLES2FormatTest, IsVertexArrayOES) {
-  IsVertexArrayOES& cmd = *GetBufferAs<IsVertexArrayOES>();
+  cmds::IsVertexArrayOES& cmd = *GetBufferAs<cmds::IsVertexArrayOES>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(IsVertexArrayOES::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::IsVertexArrayOES::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.array);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BindVertexArrayOES) {
-  BindVertexArrayOES& cmd = *GetBufferAs<BindVertexArrayOES>();
+  cmds::BindVertexArrayOES& cmd = *GetBufferAs<cmds::BindVertexArrayOES>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(BindVertexArrayOES::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BindVertexArrayOES::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.array);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, SwapBuffers) {
-  SwapBuffers& cmd = *GetBufferAs<SwapBuffers>();
+  cmds::SwapBuffers& cmd = *GetBufferAs<cmds::SwapBuffers>();
   void* next_cmd = cmd.Set(
       &cmd);
-  EXPECT_EQ(static_cast<uint32>(SwapBuffers::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::SwapBuffers::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetMaxValueInBufferCHROMIUM) {
-  GetMaxValueInBufferCHROMIUM& cmd =
-      *GetBufferAs<GetMaxValueInBufferCHROMIUM>();
+  cmds::GetMaxValueInBufferCHROMIUM& cmd =
+      *GetBufferAs<cmds::GetMaxValueInBufferCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLsizei>(12),
       static_cast<GLenum>(13),
       static_cast<GLuint>(14),
       static_cast<uint32>(15),
       static_cast<uint32>(16));
-  EXPECT_EQ(static_cast<uint32>(GetMaxValueInBufferCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetMaxValueInBufferCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer_id);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.offset);
   EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(16), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenSharedIdsCHROMIUM) {
-  GenSharedIdsCHROMIUM& cmd = *GetBufferAs<GenSharedIdsCHROMIUM>();
+  cmds::GenSharedIdsCHROMIUM& cmd = *GetBufferAs<cmds::GenSharedIdsCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLuint>(12),
       static_cast<GLsizei>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(GenSharedIdsCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenSharedIdsCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.id_offset);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.n);
   EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_id);
   EXPECT_EQ(static_cast<uint32>(15), cmd.ids_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DeleteSharedIdsCHROMIUM) {
-  DeleteSharedIdsCHROMIUM& cmd = *GetBufferAs<DeleteSharedIdsCHROMIUM>();
+  cmds::DeleteSharedIdsCHROMIUM& cmd =
+      *GetBufferAs<cmds::DeleteSharedIdsCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(DeleteSharedIdsCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DeleteSharedIdsCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
   EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, RegisterSharedIdsCHROMIUM) {
-  RegisterSharedIdsCHROMIUM& cmd = *GetBufferAs<RegisterSharedIdsCHROMIUM>();
+  cmds::RegisterSharedIdsCHROMIUM& cmd =
+      *GetBufferAs<cmds::RegisterSharedIdsCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(RegisterSharedIdsCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::RegisterSharedIdsCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
   EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, EnableFeatureCHROMIUM) {
-  EnableFeatureCHROMIUM& cmd = *GetBufferAs<EnableFeatureCHROMIUM>();
+  cmds::EnableFeatureCHROMIUM& cmd =
+      *GetBufferAs<cmds::EnableFeatureCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(EnableFeatureCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::EnableFeatureCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ResizeCHROMIUM) {
-  ResizeCHROMIUM& cmd = *GetBufferAs<ResizeCHROMIUM>();
+  cmds::ResizeCHROMIUM& cmd = *GetBufferAs<cmds::ResizeCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(ResizeCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ResizeCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.width);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetRequestableExtensionsCHROMIUM) {
-  GetRequestableExtensionsCHROMIUM& cmd =
-      *GetBufferAs<GetRequestableExtensionsCHROMIUM>();
+  cmds::GetRequestableExtensionsCHROMIUM& cmd =
+      *GetBufferAs<cmds::GetRequestableExtensionsCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<uint32>(11));
-  EXPECT_EQ(static_cast<uint32>(GetRequestableExtensionsCHROMIUM::kCmdId),
+  EXPECT_EQ(
+      static_cast<uint32>(cmds::GetRequestableExtensionsCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, RequestExtensionCHROMIUM) {
-  RequestExtensionCHROMIUM& cmd = *GetBufferAs<RequestExtensionCHROMIUM>();
+  cmds::RequestExtensionCHROMIUM& cmd =
+      *GetBufferAs<cmds::RequestExtensionCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<uint32>(11));
-  EXPECT_EQ(static_cast<uint32>(RequestExtensionCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::RequestExtensionCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetMultipleIntegervCHROMIUM) {
-  GetMultipleIntegervCHROMIUM& cmd =
-      *GetBufferAs<GetMultipleIntegervCHROMIUM>();
+  cmds::GetMultipleIntegervCHROMIUM& cmd =
+      *GetBufferAs<cmds::GetMultipleIntegervCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<uint32>(11),
       static_cast<uint32>(12),
       static_cast<GLuint>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15),
       static_cast<GLsizeiptr>(16));
-  EXPECT_EQ(static_cast<uint32>(GetMultipleIntegervCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetMultipleIntegervCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<uint32>(11), cmd.pnames_shm_id);
   EXPECT_EQ(static_cast<uint32>(12), cmd.pnames_shm_offset);
   EXPECT_EQ(static_cast<GLuint>(13), cmd.count);
   EXPECT_EQ(static_cast<uint32>(14), cmd.results_shm_id);
   EXPECT_EQ(static_cast<uint32>(15), cmd.results_shm_offset);
   EXPECT_EQ(static_cast<GLsizeiptr>(16), cmd.size);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetProgramInfoCHROMIUM) {
-  GetProgramInfoCHROMIUM& cmd = *GetBufferAs<GetProgramInfoCHROMIUM>();
+  cmds::GetProgramInfoCHROMIUM& cmd =
+      *GetBufferAs<cmds::GetProgramInfoCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(GetProgramInfoCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetProgramInfoCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CreateStreamTextureCHROMIUM) {
-  CreateStreamTextureCHROMIUM& cmd =
-      *GetBufferAs<CreateStreamTextureCHROMIUM>();
+  cmds::CreateStreamTextureCHROMIUM& cmd =
+      *GetBufferAs<cmds::CreateStreamTextureCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(CreateStreamTextureCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CreateStreamTextureCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.client_id);
   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DestroyStreamTextureCHROMIUM) {
-  DestroyStreamTextureCHROMIUM& cmd =
-      *GetBufferAs<DestroyStreamTextureCHROMIUM>();
+  cmds::DestroyStreamTextureCHROMIUM& cmd =
+      *GetBufferAs<cmds::DestroyStreamTextureCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(DestroyStreamTextureCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DestroyStreamTextureCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.texture);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GetTranslatedShaderSourceANGLE) {
-  GetTranslatedShaderSourceANGLE& cmd =
-      *GetBufferAs<GetTranslatedShaderSourceANGLE>();
+  cmds::GetTranslatedShaderSourceANGLE& cmd =
+      *GetBufferAs<cmds::GetTranslatedShaderSourceANGLE>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<uint32>(12));
-  EXPECT_EQ(static_cast<uint32>(GetTranslatedShaderSourceANGLE::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GetTranslatedShaderSourceANGLE::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, PostSubBufferCHROMIUM) {
-  PostSubBufferCHROMIUM& cmd = *GetBufferAs<PostSubBufferCHROMIUM>();
+  cmds::PostSubBufferCHROMIUM& cmd =
+      *GetBufferAs<cmds::PostSubBufferCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLint>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLint>(14));
-  EXPECT_EQ(static_cast<uint32>(PostSubBufferCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::PostSubBufferCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
   EXPECT_EQ(static_cast<GLint>(13), cmd.width);
   EXPECT_EQ(static_cast<GLint>(14), cmd.height);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TexImageIOSurface2DCHROMIUM) {
-  TexImageIOSurface2DCHROMIUM& cmd =
-      *GetBufferAs<TexImageIOSurface2DCHROMIUM>();
+  cmds::TexImageIOSurface2DCHROMIUM& cmd =
+      *GetBufferAs<cmds::TexImageIOSurface2DCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLsizei>(12),
       static_cast<GLsizei>(13),
       static_cast<GLuint>(14),
       static_cast<GLuint>(15));
-  EXPECT_EQ(static_cast<uint32>(TexImageIOSurface2DCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TexImageIOSurface2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.height);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.ioSurfaceId);
   EXPECT_EQ(static_cast<GLuint>(15), cmd.plane);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, CopyTextureCHROMIUM) {
-  CopyTextureCHROMIUM& cmd = *GetBufferAs<CopyTextureCHROMIUM>();
+  cmds::CopyTextureCHROMIUM& cmd = *GetBufferAs<cmds::CopyTextureCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12),
       static_cast<GLenum>(13),
       static_cast<GLint>(14),
       static_cast<GLint>(15));
-  EXPECT_EQ(static_cast<uint32>(CopyTextureCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::CopyTextureCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.source_id);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.dest_id);
   EXPECT_EQ(static_cast<GLint>(14), cmd.level);
   EXPECT_EQ(static_cast<GLint>(15), cmd.internalformat);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DrawArraysInstancedANGLE) {
-  DrawArraysInstancedANGLE& cmd = *GetBufferAs<DrawArraysInstancedANGLE>();
+  cmds::DrawArraysInstancedANGLE& cmd =
+      *GetBufferAs<cmds::DrawArraysInstancedANGLE>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLsizei>(13),
       static_cast<GLsizei>(14));
-  EXPECT_EQ(static_cast<uint32>(DrawArraysInstancedANGLE::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DrawArraysInstancedANGLE::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
   EXPECT_EQ(static_cast<GLint>(12), cmd.first);
   EXPECT_EQ(static_cast<GLsizei>(13), cmd.count);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.primcount);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DrawElementsInstancedANGLE) {
-  DrawElementsInstancedANGLE& cmd = *GetBufferAs<DrawElementsInstancedANGLE>();
+  cmds::DrawElementsInstancedANGLE& cmd =
+      *GetBufferAs<cmds::DrawElementsInstancedANGLE>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLsizei>(12),
       static_cast<GLenum>(13),
       static_cast<GLuint>(14),
       static_cast<GLsizei>(15));
-  EXPECT_EQ(static_cast<uint32>(DrawElementsInstancedANGLE::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DrawElementsInstancedANGLE::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
   EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.primcount);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, VertexAttribDivisorANGLE) {
-  VertexAttribDivisorANGLE& cmd = *GetBufferAs<VertexAttribDivisorANGLE>();
+  cmds::VertexAttribDivisorANGLE& cmd =
+      *GetBufferAs<cmds::VertexAttribDivisorANGLE>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLuint>(12));
-  EXPECT_EQ(static_cast<uint32>(VertexAttribDivisorANGLE::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::VertexAttribDivisorANGLE::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
   EXPECT_EQ(static_cast<GLuint>(12), cmd.divisor);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, GenMailboxCHROMIUM) {
-  GenMailboxCHROMIUM& cmd = *GetBufferAs<GenMailboxCHROMIUM>();
+  cmds::GenMailboxCHROMIUM& cmd = *GetBufferAs<cmds::GenMailboxCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(GenMailboxCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::GenMailboxCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ProduceTextureCHROMIUM) {
-  ProduceTextureCHROMIUM& cmd = *GetBufferAs<ProduceTextureCHROMIUM>();
+  cmds::ProduceTextureCHROMIUM& cmd =
+      *GetBufferAs<cmds::ProduceTextureCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(ProduceTextureCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ProduceTextureCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<uint32>(12), cmd.mailbox_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.mailbox_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ProduceTextureCHROMIUMImmediate) {
@@ skipping 57 matching lines @@
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 55),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 56),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 57),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 58),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 59),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 60),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 61),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 62),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 63),
   };
-  ProduceTextureCHROMIUMImmediate& cmd =
-      *GetBufferAs<ProduceTextureCHROMIUMImmediate>();
+  cmds::ProduceTextureCHROMIUMImmediate& cmd =
+      *GetBufferAs<cmds::ProduceTextureCHROMIUMImmediate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       data);
-  EXPECT_EQ(static_cast<uint32>(ProduceTextureCHROMIUMImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ProduceTextureCHROMIUMImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, ConsumeTextureCHROMIUM) {
-  ConsumeTextureCHROMIUM& cmd = *GetBufferAs<ConsumeTextureCHROMIUM>();
+  cmds::ConsumeTextureCHROMIUM& cmd =
+      *GetBufferAs<cmds::ConsumeTextureCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<uint32>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(ConsumeTextureCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ConsumeTextureCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<uint32>(12), cmd.mailbox_shm_id);
   EXPECT_EQ(static_cast<uint32>(13), cmd.mailbox_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ConsumeTextureCHROMIUMImmediate) {
@@ skipping 57 matching lines @@
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 55),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 56),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 57),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 58),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 59),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 60),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 61),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 62),
     static_cast<GLbyte>(kSomeBaseValueToTestWith + 63),
   };
-  ConsumeTextureCHROMIUMImmediate& cmd =
-      *GetBufferAs<ConsumeTextureCHROMIUMImmediate>();
+  cmds::ConsumeTextureCHROMIUMImmediate& cmd =
+      *GetBufferAs<cmds::ConsumeTextureCHROMIUMImmediate>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       data);
-  EXPECT_EQ(static_cast<uint32>(ConsumeTextureCHROMIUMImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ConsumeTextureCHROMIUMImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(sizeof(data)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUM) {
-  BindUniformLocationCHROMIUM& cmd =
-      *GetBufferAs<BindUniformLocationCHROMIUM>();
+  cmds::BindUniformLocationCHROMIUM& cmd =
+      *GetBufferAs<cmds::BindUniformLocationCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLint>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14),
       static_cast<uint32>(15));
-  EXPECT_EQ(static_cast<uint32>(BindUniformLocationCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BindUniformLocationCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
   EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset);
   EXPECT_EQ(static_cast<uint32>(15), cmd.data_size);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 
 TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUMImmediate) {
-  BindUniformLocationCHROMIUMImmediate& cmd =
-      *GetBufferAs<BindUniformLocationCHROMIUMImmediate>();
+  cmds::BindUniformLocationCHROMIUMImmediate& cmd =
+      *GetBufferAs<cmds::BindUniformLocationCHROMIUMImmediate>();
   static const char* const test_str = "test string";
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLint>(12),
       test_str,
       strlen(test_str));
-  EXPECT_EQ(static_cast<uint32>(BindUniformLocationCHROMIUMImmediate::kCmdId),
+  EXPECT_EQ(
+      static_cast<uint32>(cmds::BindUniformLocationCHROMIUMImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd) +
             RoundSizeToMultipleOfEntries(strlen(test_str)),
             cmd.header.size * 4u);
   EXPECT_EQ(static_cast<char*>(next_cmd),
             reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
                 RoundSizeToMultipleOfEntries(strlen(test_str)));
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
   EXPECT_EQ(static_cast<uint32>(strlen(test_str)), cmd.data_size);
   EXPECT_EQ(0, memcmp(test_str, ImmediateDataAddress(&cmd), strlen(test_str)));
   CheckBytesWritten(
       next_cmd,
       sizeof(cmd) + RoundSizeToMultipleOfEntries(strlen(test_str)),
       sizeof(cmd) + strlen(test_str));
 }
 
 TEST_F(GLES2FormatTest, BindUniformLocationCHROMIUMBucket) {
-  BindUniformLocationCHROMIUMBucket& cmd =
-      *GetBufferAs<BindUniformLocationCHROMIUMBucket>();
+  cmds::BindUniformLocationCHROMIUMBucket& cmd =
+      *GetBufferAs<cmds::BindUniformLocationCHROMIUMBucket>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11),
       static_cast<GLint>(12),
       static_cast<uint32>(13));
-  EXPECT_EQ(static_cast<uint32>(BindUniformLocationCHROMIUMBucket::kCmdId),
+  EXPECT_EQ(
+      static_cast<uint32>(cmds::BindUniformLocationCHROMIUMBucket::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
   EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, BindTexImage2DCHROMIUM) {
-  BindTexImage2DCHROMIUM& cmd = *GetBufferAs<BindTexImage2DCHROMIUM>();
+  cmds::BindTexImage2DCHROMIUM& cmd =
+      *GetBufferAs<cmds::BindTexImage2DCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12));
-  EXPECT_EQ(static_cast<uint32>(BindTexImage2DCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::BindTexImage2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.imageId);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, ReleaseTexImage2DCHROMIUM) {
-  ReleaseTexImage2DCHROMIUM& cmd = *GetBufferAs<ReleaseTexImage2DCHROMIUM>();
+  cmds::ReleaseTexImage2DCHROMIUM& cmd =
+      *GetBufferAs<cmds::ReleaseTexImage2DCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12));
-  EXPECT_EQ(static_cast<uint32>(ReleaseTexImage2DCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::ReleaseTexImage2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.imageId);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TraceBeginCHROMIUM) {
-  TraceBeginCHROMIUM& cmd = *GetBufferAs<TraceBeginCHROMIUM>();
+  cmds::TraceBeginCHROMIUM& cmd = *GetBufferAs<cmds::TraceBeginCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(TraceBeginCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TraceBeginCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, TraceEndCHROMIUM) {
-  TraceEndCHROMIUM& cmd = *GetBufferAs<TraceEndCHROMIUM>();
+  cmds::TraceEndCHROMIUM& cmd = *GetBufferAs<cmds::TraceEndCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd);
-  EXPECT_EQ(static_cast<uint32>(TraceEndCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::TraceEndCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, AsyncTexSubImage2DCHROMIUM) {
-  AsyncTexSubImage2DCHROMIUM& cmd = *GetBufferAs<AsyncTexSubImage2DCHROMIUM>();
+  cmds::AsyncTexSubImage2DCHROMIUM& cmd =
+      *GetBufferAs<cmds::AsyncTexSubImage2DCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLint>(14),
       static_cast<GLsizei>(15),
       static_cast<GLsizei>(16),
       static_cast<GLenum>(17),
       static_cast<GLenum>(18),
       static_cast<uint32>(19),
       static_cast<uint32>(20));
-  EXPECT_EQ(static_cast<uint32>(AsyncTexSubImage2DCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::AsyncTexSubImage2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
   EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id);
   EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, AsyncTexImage2DCHROMIUM) {
-  AsyncTexImage2DCHROMIUM& cmd = *GetBufferAs<AsyncTexImage2DCHROMIUM>();
+  cmds::AsyncTexImage2DCHROMIUM& cmd =
+      *GetBufferAs<cmds::AsyncTexImage2DCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLint>(12),
       static_cast<GLint>(13),
       static_cast<GLsizei>(14),
       static_cast<GLsizei>(15),
       static_cast<GLint>(16),
       static_cast<GLenum>(17),
       static_cast<GLenum>(18),
       static_cast<uint32>(19),
       static_cast<uint32>(20));
-  EXPECT_EQ(static_cast<uint32>(AsyncTexImage2DCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::AsyncTexImage2DCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
   EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
   EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
   EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DiscardFramebufferEXT) {
-  DiscardFramebufferEXT& cmd = *GetBufferAs<DiscardFramebufferEXT>();
+  cmds::DiscardFramebufferEXT& cmd =
+      *GetBufferAs<cmds::DiscardFramebufferEXT>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLsizei>(12),
       static_cast<uint32>(13),
       static_cast<uint32>(14));
-  EXPECT_EQ(static_cast<uint32>(DiscardFramebufferEXT::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DiscardFramebufferEXT::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
   EXPECT_EQ(static_cast<uint32>(13), cmd.attachments_shm_id);
   EXPECT_EQ(static_cast<uint32>(14), cmd.attachments_shm_offset);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, DiscardFramebufferEXTImmediate) {
   const int kSomeBaseValueToTestWith = 51;
   static GLenum data[] = {
     static_cast<GLenum>(kSomeBaseValueToTestWith + 0),
     static_cast<GLenum>(kSomeBaseValueToTestWith + 1),
   };
-  DiscardFramebufferEXTImmediate& cmd =
-      *GetBufferAs<DiscardFramebufferEXTImmediate>();
+  cmds::DiscardFramebufferEXTImmediate& cmd =
+      *GetBufferAs<cmds::DiscardFramebufferEXTImmediate>();
   const GLsizei kNumElements = 2;
   const size_t kExpectedCmdSize =
       sizeof(cmd) + kNumElements * sizeof(GLenum) * 1;
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(1),
       static_cast<GLsizei>(2),
       data);
-  EXPECT_EQ(static_cast<uint32>(DiscardFramebufferEXTImmediate::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::DiscardFramebufferEXTImmediate::kCmdId),
             cmd.header.command);
   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(1), cmd.target);
   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd) +
       RoundSizeToMultipleOfEntries(sizeof(data)));
   // TODO(gman): Check that data was inserted;
 }
 
 TEST_F(GLES2FormatTest, LoseContextCHROMIUM) {
-  LoseContextCHROMIUM& cmd = *GetBufferAs<LoseContextCHROMIUM>();
+  cmds::LoseContextCHROMIUM& cmd = *GetBufferAs<cmds::LoseContextCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLenum>(11),
       static_cast<GLenum>(12));
-  EXPECT_EQ(static_cast<uint32>(LoseContextCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::LoseContextCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLenum>(11), cmd.current);
   EXPECT_EQ(static_cast<GLenum>(12), cmd.other);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 TEST_F(GLES2FormatTest, WaitSyncPointCHROMIUM) {
-  WaitSyncPointCHROMIUM& cmd = *GetBufferAs<WaitSyncPointCHROMIUM>();
+  cmds::WaitSyncPointCHROMIUM& cmd =
+      *GetBufferAs<cmds::WaitSyncPointCHROMIUM>();
   void* next_cmd = cmd.Set(
       &cmd,
       static_cast<GLuint>(11));
-  EXPECT_EQ(static_cast<uint32>(WaitSyncPointCHROMIUM::kCmdId),
+  EXPECT_EQ(static_cast<uint32>(cmds::WaitSyncPointCHROMIUM::kCmdId),
             cmd.header.command);
   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
   EXPECT_EQ(static_cast<GLuint>(11), cmd.sync_point);
   CheckBytesWrittenMatchesExpectedSize(
       next_cmd, sizeof(cmd));
 }
 
 #endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_TEST_AUTOGEN_H_