Refactor/Rename a bunch of GPU stuff

gpu/command_buffer/client/gles2_implementation_unittest.cc

 // 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.
 
 // Tests for GLES2Implementation.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
@@ skipping 439 matching lines @@
   }
 
   // Sets the ProgramInfoManager. The manager will be owned
   // by the ShareGroup.
   void SetProgramInfoManager(ProgramInfoManager* manager) {
     gl_->share_group()->set_program_info_manager(manager);
   }
 
   int CheckError() {
     ExpectedMemoryInfo result =
-        GetExpectedResultMemory(sizeof(GetError::Result));
+        GetExpectedResultMemory(sizeof(cmds::GetError::Result));
     EXPECT_CALL(*command_buffer(), OnFlush())
         .WillOnce(SetMemory(result.ptr, GLuint(GL_NO_ERROR)))
         .RetiresOnSaturation();
     return gl_->GetError();
   }
 
   bool GetBucketContents(uint32 bucket_id, std::vector<int8>* data) {
     return gl_->GetBucketContents(bucket_id, data);
   }
 
@@ skipping 127 matching lines @@
   const size_t kPaddedString3Size =
       transfer_buffer_->RoundToAlignment(kString3Size);
   struct Cmds {
     cmd::SetBucketSize set_bucket_size;
     cmd::SetBucketData set_bucket_data1;
     cmd::SetToken set_token1;
     cmd::SetBucketData set_bucket_data2;
     cmd::SetToken set_token2;
     cmd::SetBucketData set_bucket_data3;
     cmd::SetToken set_token3;
-    ShaderSourceBucket shader_source_bucket;
+    cmds::ShaderSourceBucket shader_source_bucket;
     cmd::SetBucketSize clear_bucket_size;
   };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(kPaddedString1Size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(kPaddedString2Size);
   ExpectedMemoryInfo mem3 = GetExpectedMemory(kPaddedString3Size);
 
   Cmds expected;
   expected.set_bucket_size.Init(kBucketId, kSourceSize);
   expected.set_bucket_data1.Init(
@@ skipping 16 matching lines @@
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, GetShaderSource) {
   const uint32 kBucketId = GLES2Implementation::kResultBucketId;
   const GLuint kShaderId = 456;
   const Str7 kString = {"foobar"};
   const char kBad = 0x12;
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
-    GetShaderSource get_shader_source;
+    cmds::GetShaderSource get_shader_source;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 = GetExpectedResultMemory(sizeof(uint32));
 
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
@@ skipping 21 matching lines @@
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 
 TEST_F(GLES2ImplementationTest, DrawArraysClientSideBuffers) {
   static const float verts[][4] = {
     { 12.0f, 23.0f, 34.0f, 45.0f, },
     { 56.0f, 67.0f, 78.0f, 89.0f, },
     { 13.0f, 24.0f, 35.0f, 46.0f, },
   };
   struct Cmds {
-    EnableVertexAttribArray enable1;
-    EnableVertexAttribArray enable2;
-    BindBuffer bind_to_emu;
-    BufferData set_size;
-    BufferSubData copy_data1;
+    cmds::EnableVertexAttribArray enable1;
+    cmds::EnableVertexAttribArray enable2;
+    cmds::BindBuffer bind_to_emu;
+    cmds::BufferData set_size;
+    cmds::BufferSubData copy_data1;
     cmd::SetToken set_token1;
-    VertexAttribPointer set_pointer1;
-    BufferSubData copy_data2;
+    cmds::VertexAttribPointer set_pointer1;
+    cmds::BufferSubData copy_data2;
     cmd::SetToken set_token2;
-    VertexAttribPointer set_pointer2;
-    DrawArrays draw;
-    BindBuffer restore;
+    cmds::VertexAttribPointer set_pointer2;
+    cmds::DrawArrays draw;
+    cmds::BindBuffer restore;
   };
   const GLuint kEmuBufferId = GLES2Implementation::kClientSideArrayId;
   const GLuint kAttribIndex1 = 1;
   const GLuint kAttribIndex2 = 3;
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kClientStride = sizeof(verts[0]);
   const GLint kFirst = 1;
   const GLsizei kCount = 2;
   const GLsizei kSize1 =
@@ skipping 34 matching lines @@
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, DrawArraysInstancedANGLEClientSideBuffers) {
   static const float verts[][4] = {
     { 12.0f, 23.0f, 34.0f, 45.0f, },
     { 56.0f, 67.0f, 78.0f, 89.0f, },
     { 13.0f, 24.0f, 35.0f, 46.0f, },
   };
   struct Cmds {
-    EnableVertexAttribArray enable1;
-    EnableVertexAttribArray enable2;
-    VertexAttribDivisorANGLE divisor;
-    BindBuffer bind_to_emu;
-    BufferData set_size;
-    BufferSubData copy_data1;
+    cmds::EnableVertexAttribArray enable1;
+    cmds::EnableVertexAttribArray enable2;
+    cmds::VertexAttribDivisorANGLE divisor;
+    cmds::BindBuffer bind_to_emu;
+    cmds::BufferData set_size;
+    cmds::BufferSubData copy_data1;
     cmd::SetToken set_token1;
-    VertexAttribPointer set_pointer1;
-    BufferSubData copy_data2;
+    cmds::VertexAttribPointer set_pointer1;
+    cmds::BufferSubData copy_data2;
     cmd::SetToken set_token2;
-    VertexAttribPointer set_pointer2;
-    DrawArraysInstancedANGLE draw;
-    BindBuffer restore;
+    cmds::VertexAttribPointer set_pointer2;
+    cmds::DrawArraysInstancedANGLE draw;
+    cmds::BindBuffer restore;
   };
   const GLuint kEmuBufferId = GLES2Implementation::kClientSideArrayId;
   const GLuint kAttribIndex1 = 1;
   const GLuint kAttribIndex2 = 3;
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kClientStride = sizeof(verts[0]);
   const GLint kFirst = 1;
   const GLsizei kCount = 2;
   const GLuint kDivisor = 1;
@@ skipping 40 matching lines @@
 TEST_F(GLES2ImplementationTest, DrawElementsClientSideBuffers) {
   static const float verts[][4] = {
     { 12.0f, 23.0f, 34.0f, 45.0f, },
     { 56.0f, 67.0f, 78.0f, 89.0f, },
     { 13.0f, 24.0f, 35.0f, 46.0f, },
   };
   static const uint16 indices[] = {
     1, 2,
   };
   struct Cmds {
-    EnableVertexAttribArray enable1;
-    EnableVertexAttribArray enable2;
-    BindBuffer bind_to_index_emu;
-    BufferData set_index_size;
-    BufferSubData copy_data0;
+    cmds::EnableVertexAttribArray enable1;
+    cmds::EnableVertexAttribArray enable2;
+    cmds::BindBuffer bind_to_index_emu;
+    cmds::BufferData set_index_size;
+    cmds::BufferSubData copy_data0;
     cmd::SetToken set_token0;
-    BindBuffer bind_to_emu;
-    BufferData set_size;
-    BufferSubData copy_data1;
+    cmds::BindBuffer bind_to_emu;
+    cmds::BufferData set_size;
+    cmds::BufferSubData copy_data1;
     cmd::SetToken set_token1;
-    VertexAttribPointer set_pointer1;
-    BufferSubData copy_data2;
+    cmds::VertexAttribPointer set_pointer1;
+    cmds::BufferSubData copy_data2;
     cmd::SetToken set_token2;
-    VertexAttribPointer set_pointer2;
-    DrawElements draw;
-    BindBuffer restore;
-    BindBuffer restore_element;
+    cmds::VertexAttribPointer set_pointer2;
+    cmds::DrawElements draw;
+    cmds::BindBuffer restore;
+    cmds::BindBuffer restore_element;
   };
   const GLsizei kIndexSize = sizeof(indices);
   const GLuint kEmuBufferId = GLES2Implementation::kClientSideArrayId;
   const GLuint kEmuIndexBufferId =
       GLES2Implementation::kClientSideElementArrayId;
   const GLuint kAttribIndex1 = 1;
   const GLuint kAttribIndex2 = 3;
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kClientStride = sizeof(verts[0]);
@@ skipping 47 matching lines @@
 TEST_F(GLES2ImplementationTest, DrawElementsClientSideBuffersIndexUint) {
   static const float verts[][4] = {
     { 12.0f, 23.0f, 34.0f, 45.0f, },
     { 56.0f, 67.0f, 78.0f, 89.0f, },
     { 13.0f, 24.0f, 35.0f, 46.0f, },
   };
   static const uint32 indices[] = {
     1, 2,
   };
   struct Cmds {
-    EnableVertexAttribArray enable1;
-    EnableVertexAttribArray enable2;
-    BindBuffer bind_to_index_emu;
-    BufferData set_index_size;
-    BufferSubData copy_data0;
+    cmds::EnableVertexAttribArray enable1;
+    cmds::EnableVertexAttribArray enable2;
+    cmds::BindBuffer bind_to_index_emu;
+    cmds::BufferData set_index_size;
+    cmds::BufferSubData copy_data0;
     cmd::SetToken set_token0;
-    BindBuffer bind_to_emu;
-    BufferData set_size;
-    BufferSubData copy_data1;
+    cmds::BindBuffer bind_to_emu;
+    cmds::BufferData set_size;
+    cmds::BufferSubData copy_data1;
     cmd::SetToken set_token1;
-    VertexAttribPointer set_pointer1;
-    BufferSubData copy_data2;
+    cmds::VertexAttribPointer set_pointer1;
+    cmds::BufferSubData copy_data2;
     cmd::SetToken set_token2;
-    VertexAttribPointer set_pointer2;
-    DrawElements draw;
-    BindBuffer restore;
-    BindBuffer restore_element;
+    cmds::VertexAttribPointer set_pointer2;
+    cmds::DrawElements draw;
+    cmds::BindBuffer restore;
+    cmds::BindBuffer restore_element;
   };
   const GLsizei kIndexSize = sizeof(indices);
   const GLuint kEmuBufferId = GLES2Implementation::kClientSideArrayId;
   const GLuint kEmuIndexBufferId =
       GLES2Implementation::kClientSideElementArrayId;
   const GLuint kAttribIndex1 = 1;
   const GLuint kAttribIndex2 = 3;
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kClientStride = sizeof(verts[0]);
@@ skipping 77 matching lines @@
 }
 
 TEST_F(GLES2ImplementationTest,
        DrawElementsClientSideBuffersServiceSideIndices) {
   static const float verts[][4] = {
     { 12.0f, 23.0f, 34.0f, 45.0f, },
     { 56.0f, 67.0f, 78.0f, 89.0f, },
     { 13.0f, 24.0f, 35.0f, 46.0f, },
   };
   struct Cmds {
-    EnableVertexAttribArray enable1;
-    EnableVertexAttribArray enable2;
-    BindBuffer bind_to_index;
-    GetMaxValueInBufferCHROMIUM get_max;
-    BindBuffer bind_to_emu;
-    BufferData set_size;
-    BufferSubData copy_data1;
+    cmds::EnableVertexAttribArray enable1;
+    cmds::EnableVertexAttribArray enable2;
+    cmds::BindBuffer bind_to_index;
+    cmds::GetMaxValueInBufferCHROMIUM get_max;
+    cmds::BindBuffer bind_to_emu;
+    cmds::BufferData set_size;
+    cmds::BufferSubData copy_data1;
     cmd::SetToken set_token1;
-    VertexAttribPointer set_pointer1;
-    BufferSubData copy_data2;
+    cmds::VertexAttribPointer set_pointer1;
+    cmds::BufferSubData copy_data2;
     cmd::SetToken set_token2;
-    VertexAttribPointer set_pointer2;
-    DrawElements draw;
-    BindBuffer restore;
+    cmds::VertexAttribPointer set_pointer2;
+    cmds::DrawElements draw;
+    cmds::BindBuffer restore;
   };
   const GLuint kEmuBufferId = GLES2Implementation::kClientSideArrayId;
   const GLuint kClientIndexBufferId = 0x789;
   const GLuint kIndexOffset = 0x40;
   const GLuint kMaxIndex = 2;
   const GLuint kAttribIndex1 = 1;
   const GLuint kAttribIndex2 = 3;
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kClientStride = sizeof(verts[0]);
@@ skipping 51 matching lines @@
 TEST_F(GLES2ImplementationTest, DrawElementsInstancedANGLEClientSideBuffers) {
   static const float verts[][4] = {
     { 12.0f, 23.0f, 34.0f, 45.0f, },
     { 56.0f, 67.0f, 78.0f, 89.0f, },
     { 13.0f, 24.0f, 35.0f, 46.0f, },
   };
   static const uint16 indices[] = {
     1, 2,
   };
   struct Cmds {
-    EnableVertexAttribArray enable1;
-    EnableVertexAttribArray enable2;
-    VertexAttribDivisorANGLE divisor;
-    BindBuffer bind_to_index_emu;
-    BufferData set_index_size;
-    BufferSubData copy_data0;
+    cmds::EnableVertexAttribArray enable1;
+    cmds::EnableVertexAttribArray enable2;
+    cmds::VertexAttribDivisorANGLE divisor;
+    cmds::BindBuffer bind_to_index_emu;
+    cmds::BufferData set_index_size;
+    cmds::BufferSubData copy_data0;
     cmd::SetToken set_token0;
-    BindBuffer bind_to_emu;
-    BufferData set_size;
-    BufferSubData copy_data1;
+    cmds::BindBuffer bind_to_emu;
+    cmds::BufferData set_size;
+    cmds::BufferSubData copy_data1;
     cmd::SetToken set_token1;
-    VertexAttribPointer set_pointer1;
-    BufferSubData copy_data2;
+    cmds::VertexAttribPointer set_pointer1;
+    cmds::BufferSubData copy_data2;
     cmd::SetToken set_token2;
-    VertexAttribPointer set_pointer2;
-    DrawElementsInstancedANGLE draw;
-    BindBuffer restore;
-    BindBuffer restore_element;
+    cmds::VertexAttribPointer set_pointer2;
+    cmds::DrawElementsInstancedANGLE draw;
+    cmds::BindBuffer restore;
+    cmds::BindBuffer restore_element;
   };
   const GLsizei kIndexSize = sizeof(indices);
   const GLuint kEmuBufferId = GLES2Implementation::kClientSideArrayId;
   const GLuint kEmuIndexBufferId =
       GLES2Implementation::kClientSideElementArrayId;
   const GLuint kAttribIndex1 = 1;
   const GLuint kAttribIndex2 = 3;
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kClientStride = sizeof(verts[0]);
@@ skipping 54 matching lines @@
   const GLuint kAttribIndex2 = 3;
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kStride1 = 12;
   const GLsizei kStride2 = 0;
   const GLuint kBufferId = 0x123;
   const GLint kOffset2 = 0x456;
 
   // It's all cached on the client side so no get commands are issued.
   struct Cmds {
-    BindBuffer bind;
-    VertexAttribPointer set_pointer;
+    cmds::BindBuffer bind;
+    cmds::VertexAttribPointer set_pointer;
   };
 
   Cmds expected;
   expected.bind.Init(GL_ARRAY_BUFFER, kBufferId);
   expected.set_pointer.Init(kAttribIndex2, kNumComponents2, GL_FLOAT, GL_FALSE,
                             kStride2, kOffset2);
 
   // Set one client side buffer.
   gl_->VertexAttribPointer(kAttribIndex1, kNumComponents1,
                            GL_FLOAT, GL_FALSE, kStride1, verts);
@@ skipping 23 matching lines @@
   const GLint kNumComponents1 = 3;
   const GLint kNumComponents2 = 2;
   const GLsizei kStride1 = 12;
   const GLsizei kStride2 = 0;
   const GLuint kBufferId = 0x123;
   const GLint kOffset2 = 0x456;
 
   // Only one set and one get because the client side buffer's info is stored
   // on the client side.
   struct Cmds {
-    EnableVertexAttribArray enable;
-    BindBuffer bind;
-    VertexAttribPointer set_pointer;
-    GetVertexAttribfv get2;  // for getting the value from attrib1
+    cmds::EnableVertexAttribArray enable;
+    cmds::BindBuffer bind;
+    cmds::VertexAttribPointer set_pointer;
+    cmds::GetVertexAttribfv get2;  // for getting the value from attrib1
   };
 
   ExpectedMemoryInfo mem2 = GetExpectedResultMemory(16);
 
   Cmds expected;
   expected.enable.Init(kAttribIndex1);
   expected.bind.Init(GL_ARRAY_BUFFER, kBufferId);
   expected.set_pointer.Init(kAttribIndex2, kNumComponents2, GL_FLOAT, GL_FALSE,
                             kStride2, kOffset2);
   expected.get2.Init(kAttribIndex1,
@@ skipping 52 matching lines @@
   EXPECT_EQ(GL_FLOAT, type);
   EXPECT_EQ(GL_FALSE, normalized);
   EXPECT_EQ(0, memcmp(&current_attrib, &current, sizeof(current_attrib)));
 
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, ReservedIds) {
   // Only the get error command should be issued.
   struct Cmds {
-    GetError get;
+    cmds::GetError get;
   };
   Cmds expected;
 
-  ExpectedMemoryInfo mem1 = GetExpectedResultMemory(sizeof(GetError::Result));
+  ExpectedMemoryInfo mem1 = GetExpectedResultMemory(
+      sizeof(cmds::GetError::Result));
 
   expected.get.Init(mem1.id, mem1.offset);
 
   // One call to flush to wait for GetError
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(mem1.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
 
   gl_->BindBuffer(
       GL_ARRAY_BUFFER,
       GLES2Implementation::kClientSideArrayId);
   gl_->BindBuffer(
       GL_ARRAY_BUFFER,
       GLES2Implementation::kClientSideElementArrayId);
   GLenum err = gl_->GetError();
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), err);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 #endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 
 TEST_F(GLES2ImplementationTest, ReadPixels2Reads) {
   struct Cmds {
-    ReadPixels read1;
+    cmds::ReadPixels read1;
     cmd::SetToken set_token1;
-    ReadPixels read2;
+    cmds::ReadPixels read2;
     cmd::SetToken set_token2;
   };
   const GLint kBytesPerPixel = 4;
   const GLint kWidth =
       (kTransferBufferSize - GLES2Implementation::kStartingOffset) /
       kBytesPerPixel;
   const GLint kHeight = 2;
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
 
   ExpectedMemoryInfo mem1 =
       GetExpectedMemory(kWidth * kHeight / 2 * kBytesPerPixel);
   ExpectedMemoryInfo result1 =
-      GetExpectedResultMemory(sizeof(ReadPixels::Result));
+      GetExpectedResultMemory(sizeof(cmds::ReadPixels::Result));
   ExpectedMemoryInfo mem2 =
       GetExpectedMemory(kWidth * kHeight / 2 * kBytesPerPixel);
   ExpectedMemoryInfo result2 =
-      GetExpectedResultMemory(sizeof(ReadPixels::Result));
+      GetExpectedResultMemory(sizeof(cmds::ReadPixels::Result));
 
   Cmds expected;
   expected.read1.Init(
       0, 0, kWidth, kHeight / 2, kFormat, kType,
       mem1.id, mem1.offset, result1.id, result1.offset);
   expected.set_token1.Init(GetNextToken());
   expected.read2.Init(
       0, kHeight / 2, kWidth, kHeight / 2, kFormat, kType,
       mem2.id, mem2.offset, result2.id, result2.offset);
   expected.set_token2.Init(GetNextToken());
   scoped_array<int8> buffer(new int8[kWidth * kHeight * kBytesPerPixel]);
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, static_cast<uint32>(1)))
       .WillOnce(SetMemory(result2.ptr, static_cast<uint32>(1)))
       .RetiresOnSaturation();
 
   gl_->ReadPixels(0, 0, kWidth, kHeight, kFormat, kType, buffer.get());
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, ReadPixelsBadFormatType) {
   struct Cmds {
-    ReadPixels read;
+    cmds::ReadPixels read;
     cmd::SetToken set_token;
   };
   const GLint kBytesPerPixel = 4;
   const GLint kWidth = 2;
   const GLint kHeight = 2;
   const GLenum kFormat = 0;
   const GLenum kType = 0;
 
   ExpectedMemoryInfo mem1 =
       GetExpectedMemory(kWidth * kHeight * kBytesPerPixel);
   ExpectedMemoryInfo result1 =
-      GetExpectedResultMemory(sizeof(ReadPixels::Result));
+      GetExpectedResultMemory(sizeof(cmds::ReadPixels::Result));
 
   Cmds expected;
   expected.read.Init(
       0, 0, kWidth, kHeight, kFormat, kType,
       mem1.id, mem1.offset, result1.id, result1.offset);
   expected.set_token.Init(GetNextToken());
   scoped_array<int8> buffer(new int8[kWidth * kHeight * kBytesPerPixel]);
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .Times(1)
       .RetiresOnSaturation();
 
   gl_->ReadPixels(0, 0, kWidth, kHeight, kFormat, kType, buffer.get());
 }
 
 TEST_F(GLES2ImplementationTest, FreeUnusedSharedMemory) {
   struct Cmds {
-    BufferSubData buf;
+    cmds::BufferSubData buf;
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLintptr kOffset = 15;
   const GLsizeiptr kSize = 16;
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(kSize);
 
   Cmds expected;
   expected.buf.Init(
     kTarget, kOffset, kSize, mem1.id, mem1.offset);
   expected.set_token.Init(GetNextToken());
 
   void* mem = gl_->MapBufferSubDataCHROMIUM(
       kTarget, kOffset, kSize, GL_WRITE_ONLY);
   ASSERT_TRUE(mem != NULL);
   gl_->UnmapBufferSubDataCHROMIUM(mem);
   EXPECT_CALL(*command_buffer(), DestroyTransferBuffer(_))
       .Times(1)
       .RetiresOnSaturation();
   gl_->FreeUnusedSharedMemory();
 }
 
 TEST_F(GLES2ImplementationTest, MapUnmapBufferSubDataCHROMIUM) {
   struct Cmds {
-    BufferSubData buf;
+    cmds::BufferSubData buf;
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLintptr kOffset = 15;
   const GLsizeiptr kSize = 16;
 
   uint32 offset = 0;
   Cmds expected;
   expected.buf.Init(
       kTarget, kOffset, kSize,
       command_buffer()->GetNextFreeTransferBufferId(), offset);
   expected.set_token.Init(GetNextToken());
 
   void* mem = gl_->MapBufferSubDataCHROMIUM(
       kTarget, kOffset, kSize, GL_WRITE_ONLY);
   ASSERT_TRUE(mem != NULL);
   gl_->UnmapBufferSubDataCHROMIUM(mem);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, MapUnmapBufferSubDataCHROMIUMBadArgs) {
   const GLenum kTarget = GL_ELEMENT_ARRAY_BUFFER;
   const GLintptr kOffset = 15;
   const GLsizeiptr kSize = 16;
 
   ExpectedMemoryInfo result1 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result2 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result3 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result4 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   // Calls to flush to wait for GetError
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result2.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result3.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result4.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
 
   void* mem;
   mem = gl_->MapBufferSubDataCHROMIUM(kTarget, -1, kSize, GL_WRITE_ONLY);
   ASSERT_TRUE(mem == NULL);
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE), gl_->GetError());
   mem = gl_->MapBufferSubDataCHROMIUM(kTarget, kOffset, -1, GL_WRITE_ONLY);
   ASSERT_TRUE(mem == NULL);
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE), gl_->GetError());
   mem = gl_->MapBufferSubDataCHROMIUM(kTarget, kOffset, kSize, GL_READ_ONLY);
   ASSERT_TRUE(mem == NULL);
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_ENUM), gl_->GetError());
   const char* kPtr = "something";
   gl_->UnmapBufferSubDataCHROMIUM(kPtr);
   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE), gl_->GetError());
 }
 
 TEST_F(GLES2ImplementationTest, MapUnmapTexSubImage2DCHROMIUM) {
   struct Cmds {
-    TexSubImage2D tex;
+    cmds::TexSubImage2D tex;
     cmd::SetToken set_token;
   };
   const GLint kLevel = 1;
   const GLint kXOffset = 2;
   const GLint kYOffset = 3;
   const GLint kWidth = 4;
   const GLint kHeight = 5;
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
 
@@ skipping 23 matching lines @@
 TEST_F(GLES2ImplementationTest, MapUnmapTexSubImage2DCHROMIUMBadArgs) {
   const GLint kLevel = 1;
   const GLint kXOffset = 2;
   const GLint kYOffset = 3;
   const GLint kWidth = 4;
   const GLint kHeight = 5;
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
 
   ExpectedMemoryInfo result1 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result2 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result3 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result4 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result5 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result6 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result7 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   // Calls to flush to wait for GetError
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result2.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result3.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result4.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result5.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result6.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result7.ptr, GLuint(GL_NO_ERROR)))
@@ skipping 79 matching lines @@
 
 TEST_F(GLES2ImplementationTest, GetMultipleIntegervCHROMIUMValidArgs) {
   const GLenum pnames[] = {
     GL_DEPTH_WRITEMASK,
     GL_COLOR_WRITEMASK,
     GL_STENCIL_WRITEMASK,
   };
   const GLint num_results = 6;
   GLint results[num_results + 1];
   struct Cmds {
-    GetMultipleIntegervCHROMIUM get_multiple;
+    cmds::GetMultipleIntegervCHROMIUM get_multiple;
     cmd::SetToken set_token;
   };
   const GLsizei kNumPnames = arraysize(pnames);
   const GLsizeiptr kResultsSize = num_results * sizeof(results[0]);
   const size_t kPNamesSize = kNumPnames * sizeof(pnames[0]);
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(kPNamesSize + kResultsSize);
   ExpectedMemoryInfo result1 = GetExpectedResultMemory(
-      sizeof(GetError::Result));
+      sizeof(cmds::GetError::Result));
 
   const uint32 kPnamesOffset = mem1.offset;
   const uint32 kResultsOffset = mem1.offset + kPNamesSize;
   Cmds expected;
   expected.get_multiple.Init(
       mem1.id, kPnamesOffset, kNumPnames,
       mem1.id, kResultsOffset, kResultsSize);
   expected.set_token.Init(GetNextToken());
 
   const GLint kSentinel = 0x12345678;
@@ skipping 22 matching lines @@
     GL_DEPTH_WRITEMASK,
     GL_COLOR_WRITEMASK,
     GL_STENCIL_WRITEMASK,
   };
   const GLint num_results = 6;
   GLint results[num_results + 1];
   const GLsizei kNumPnames = arraysize(pnames);
   const GLsizeiptr kResultsSize = num_results * sizeof(results[0]);
 
   ExpectedMemoryInfo result1 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result2 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result3 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result4 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   // Calls to flush to wait for GetError
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result2.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result3.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result4.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
 
   const GLint kSentinel = 0x12345678;
@@ skipping 41 matching lines @@
   const char kBad = 0x12;
   GLsizei size = 0;
   const Str7 kString = {"foobar"};
   char buf[20];
 
   ExpectedMemoryInfo mem1 =
       GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmd::GetBucketStart::Result));
   ExpectedMemoryInfo result2 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   memset(buf, kBad, sizeof(buf));
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(DoAll(SetMemory(result1.ptr, uint32(sizeof(kString))),
                       SetMemory(mem1.ptr, kString)))
       .WillOnce(SetMemory(result2.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
 
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
-    GetProgramInfoCHROMIUM get_program_info;
+    cmds::GetProgramInfoCHROMIUM get_program_info;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_program_info.Init(kProgramId, kBucketId);
   expected.get_bucket_start.Init(
       kBucketId, result1.id, result1.offset,
       MaxTransferBufferSize(), mem1.id, mem1.offset);
@@ skipping 11 matching lines @@
   const uint32 kBucketId = GLES2Implementation::kResultBucketId;
   const GLuint kProgramId = 123;
   GLsizei size = 0;
   const Str7 kString = {"foobar"};
   char buf[20];
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmd::GetBucketStart::Result));
   ExpectedMemoryInfo result2 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result3 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
   ExpectedMemoryInfo result4 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(DoAll(SetMemory(result1.ptr, uint32(sizeof(kString))),
                       SetMemory(mem1.ptr,  kString)))
       .WillOnce(SetMemory(result2.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result3.ptr, GLuint(GL_NO_ERROR)))
       .WillOnce(SetMemory(result4.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
 
   // try bufsize not big enough.
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
-    GetProgramInfoCHROMIUM get_program_info;
+    cmds::GetProgramInfoCHROMIUM get_program_info;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_program_info.Init(kProgramId, kBucketId);
   expected.get_bucket_start.Init(
       kBucketId, result1.id, result1.offset,
       MaxTransferBufferSize(), mem1.id, mem1.offset);
@@ skipping 45 matching lines @@
   size_t num_pairs = sizeof(pairs) / sizeof(pairs[0]);
   for (size_t ii = 0; ii < num_pairs; ++ii) {
     const PNameValue& pv = pairs[ii];
     GLint v = -1;
     gl_->GetIntegerv(pv.pname, &v);
     EXPECT_TRUE(NoCommandsWritten());
     EXPECT_EQ(pv.expected, v);
   }
 
   ExpectedMemoryInfo result1 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
 }
 
 TEST_F(GLES2ImplementationTest, GetIntegerCacheWrite) {
   struct PNameValue {
     GLenum pname;
@@ skipping 18 matching lines @@
   };
   size_t num_pairs = sizeof(pairs) / sizeof(pairs[0]);
   for (size_t ii = 0; ii < num_pairs; ++ii) {
     const PNameValue& pv = pairs[ii];
     GLint v = -1;
     gl_->GetIntegerv(pv.pname, &v);
     EXPECT_EQ(pv.expected, v);
   }
 
   ExpectedMemoryInfo result1 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
 }
 
 static bool CheckRect(
     int width, int height, GLenum format, GLenum type, int alignment,
     bool flip_y, const uint8* r1, const uint8* r2) {
@@ skipping 23 matching lines @@
 
 ACTION_P8(CheckRectAction, width, height, format, type, alignment, flip_y,
           r1, r2) {
   EXPECT_TRUE(CheckRect(
       width, height, format, type, alignment, flip_y, r1, r2));
 }
 
 // Test TexImage2D with and without flip_y
 TEST_F(GLES2ImplementationTest, TexImage2D) {
   struct Cmds {
-    TexImage2D tex_image_2d;
+    cmds::TexImage2D tex_image_2d;
     cmd::SetToken set_token;
   };
   struct Cmds2 {
-    TexImage2D tex_image_2d;
+    cmds::TexImage2D tex_image_2d;
     cmd::SetToken set_token;
   };
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLint kLevel = 0;
   const GLenum kFormat = GL_RGB;
   const GLsizei kWidth = 3;
   const GLsizei kHeight = 4;
   const GLint kBorder = 0;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLint kPixelStoreUnpackAlignment = 4;
@@ skipping 34 matching lines @@
       pixels);
   EXPECT_EQ(0, memcmp(&expected2, commands2, sizeof(expected2)));
   EXPECT_TRUE(CheckRect(
       kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment, true,
       pixels, mem2.ptr));
 }
 
 // Test TexImage2D with 2 writes
 TEST_F(GLES2ImplementationTest, TexImage2D2Writes) {
   struct Cmds {
-    TexImage2D tex_image_2d;
-    TexSubImage2D tex_sub_image_2d1;
+    cmds::TexImage2D tex_image_2d;
+    cmds::TexSubImage2D tex_sub_image_2d1;
     cmd::SetToken set_token1;
-    TexSubImage2D tex_sub_image_2d2;
+    cmds::TexSubImage2D tex_sub_image_2d2;
     cmd::SetToken set_token2;
   };
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLint kLevel = 0;
   const GLenum kFormat = GL_RGB;
   const GLint kBorder = 0;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLint kPixelStoreUnpackAlignment = 4;
   const GLsizei kWidth = 3;
 
@@ skipping 92 matching lines @@
   const GLint kSubImageXOffset = 1;
   const GLint kSubImageYOffset = 2;
   const GLenum kFormat = GL_RGBA;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLenum kTarget = GL_TEXTURE_2D;
   const GLint kLevel = 0;
   const GLint kBorder = 0;
   const GLint kPixelStoreUnpackAlignment = 4;
 
   struct Cmds {
-    PixelStorei pixel_store_i1;
-    TexImage2D tex_image_2d;
-    PixelStorei pixel_store_i2;
-    TexSubImage2D tex_sub_image_2d1;
+    cmds::PixelStorei pixel_store_i1;
+    cmds::TexImage2D tex_image_2d;
+    cmds::PixelStorei pixel_store_i2;
+    cmds::TexSubImage2D tex_sub_image_2d1;
     cmd::SetToken set_token1;
-    TexSubImage2D tex_sub_image_2d2;
+    cmds::TexSubImage2D tex_sub_image_2d2;
     cmd::SetToken set_token2;
   };
 
   uint32 sub_2_high_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kSubImageWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment,
       &sub_2_high_size, NULL, NULL));
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(sub_2_high_size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(sub_2_high_size);
@@ skipping 53 matching lines @@
   static const GLint kSrcSubImageWidth = kSrcSubImageX1 - kSrcSubImageX0;
   static const GLint kSrcSubImageHeight = kSrcSubImageY1 - kSrcSubImageY0;
 
   // these are only used in the texsubimage tests
   static const GLint kTexWidth = 1023;
   static const GLint kTexHeight = 511;
   static const GLint kTexSubXOffset = 419;
   static const GLint kTexSubYOffset = 103;
 
   struct {
-    PixelStorei pixel_store_i;
-    PixelStorei pixel_store_i2;
-    TexImage2D tex_image_2d;
+    cmds::PixelStorei pixel_store_i;
+    cmds::PixelStorei pixel_store_i2;
+    cmds::TexImage2D tex_image_2d;
   } texImageExpected;
 
   struct  {
-    PixelStorei pixel_store_i;
-    PixelStorei pixel_store_i2;
-    TexImage2D tex_image_2d;
-    TexSubImage2D tex_sub_image_2d;
+    cmds::PixelStorei pixel_store_i;
+    cmds::PixelStorei pixel_store_i2;
+    cmds::TexImage2D tex_image_2d;
+    cmds::TexSubImage2D tex_sub_image_2d;
   } texSubImageExpected;
 
   uint32 src_size;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
       kSrcWidth, kSrcSubImageY1, kFormat, kType, 8, &src_size, NULL, NULL));
   scoped_array<uint8> src_pixels;
   src_pixels.reset(new uint8[src_size]);
   for (size_t i = 0; i < src_size; ++i) {
     src_pixels[i] = static_cast<int8>(i);
   }
@@ skipping 86 matching lines @@
     { GL_FRAMEBUFFER_BINDING, 3, },
     { GL_RENDERBUFFER_BINDING, 4, },
     { GL_ARRAY_BUFFER_BINDING, 5, },
     { GL_ELEMENT_ARRAY_BUFFER_BINDING, 6, },
   };
   size_t num_pairs = sizeof(pairs) / sizeof(pairs[0]);
   for (size_t ii = 0; ii < num_pairs; ++ii) {
     const PNameValue& pv = pairs[ii];
     GLint v = -1;
     ExpectedMemoryInfo result1 =
-        GetExpectedResultMemory(sizeof(GetIntegerv::Result));
+        GetExpectedResultMemory(sizeof(cmds::GetIntegerv::Result));
     EXPECT_CALL(*command_buffer(), OnFlush())
         .WillOnce(SetMemory(result1.ptr,
                             SizedResultHelper<GLuint>(pv.expected)))
         .RetiresOnSaturation();
     gl_->GetIntegerv(pv.pname, &v);
     EXPECT_EQ(pv.expected, v);
   }
 }
 
 TEST_F(GLES2ImplementationTest, CreateStreamTextureCHROMIUM) {
   const GLuint kTextureId = 123;
   const GLuint kResult = 456;
 
   struct Cmds {
-    CreateStreamTextureCHROMIUM create_stream;
+    cmds::CreateStreamTextureCHROMIUM create_stream;
   };
 
   ExpectedMemoryInfo result1 =
-      GetExpectedResultMemory(sizeof(CreateStreamTextureCHROMIUM::Result));
+      GetExpectedResultMemory(
+          sizeof(cmds::CreateStreamTextureCHROMIUM::Result));
   ExpectedMemoryInfo result2 =
-      GetExpectedResultMemory(sizeof(GetError::Result));
+      GetExpectedResultMemory(sizeof(cmds::GetError::Result));
 
   Cmds expected;
   expected.create_stream.Init(kTextureId, result1.id, result1.offset);
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(SetMemory(result1.ptr, kResult))
       .WillOnce(SetMemory(result2.ptr, GLuint(GL_NO_ERROR)))
       .RetiresOnSaturation();
 
   GLuint handle = gl_->CreateStreamTextureCHROMIUM(kTextureId);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(handle, kResult);
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
 }
 
 TEST_F(GLES2ImplementationTest, GetString) {
   const uint32 kBucketId = GLES2Implementation::kResultBucketId;
   const Str7 kString = {"foobar"};
   // GL_CHROMIUM_map_sub GL_CHROMIUM_flipy are hard coded into
   // GLES2Implementation.
   const char* expected_str =
       "foobar "
       "GL_CHROMIUM_flipy "
       "GL_CHROMIUM_map_sub "
       "GL_CHROMIUM_shallow_flush "
       "GL_EXT_unpack_subimage";
   const char kBad = 0x12;
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
-    GetString get_string;
+    cmds::GetString get_string;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
   };
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmd::GetBucketStart::Result));
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_string.Init(GL_EXTENSIONS, kBucketId);
@@ skipping 13 matching lines @@
   const GLubyte* result = gl_->GetString(GL_EXTENSIONS);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_STREQ(expected_str, reinterpret_cast<const char*>(result));
 }
 
 TEST_F(GLES2ImplementationTest, PixelStoreiGLPackReverseRowOrderANGLE) {
   const uint32 kBucketId = GLES2Implementation::kResultBucketId;
   const Str7 kString = {"foobar"};
   struct Cmds {
     cmd::SetBucketSize set_bucket_size1;
-    GetString get_string;
+    cmds::GetString get_string;
     cmd::GetBucketStart get_bucket_start;
     cmd::SetToken set_token1;
     cmd::SetBucketSize set_bucket_size2;
-    PixelStorei pixel_store;
+    cmds::PixelStorei pixel_store;
   };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(MaxTransferBufferSize());
   ExpectedMemoryInfo result1 =
       GetExpectedResultMemory(sizeof(cmd::GetBucketStart::Result));
 
   Cmds expected;
   expected.set_bucket_size1.Init(kBucketId, 0);
   expected.get_string.Init(GL_EXTENSIONS, kBucketId);
   expected.get_bucket_start.Init(
       kBucketId, result1.id, result1.offset,
       MaxTransferBufferSize(), mem1.id, mem1.offset);
   expected.set_token1.Init(GetNextToken());
   expected.set_bucket_size2.Init(kBucketId, 0);
   expected.pixel_store.Init(GL_PACK_REVERSE_ROW_ORDER_ANGLE, 1);
 
   EXPECT_CALL(*command_buffer(), OnFlush())
       .WillOnce(DoAll(SetMemory(result1.ptr, uint32(sizeof(kString))),
                       SetMemory(mem1.ptr, kString)))
       .RetiresOnSaturation();
 
   gl_->PixelStorei(GL_PACK_REVERSE_ROW_ORDER_ANGLE, 1);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
 }
 
 TEST_F(GLES2ImplementationTest, CreateProgram) {
   struct Cmds {
-    CreateProgram cmd;
+    cmds::CreateProgram cmd;
   };
 
   Cmds expected;
   expected.cmd.Init(kProgramsAndShadersStartId);
   GLuint id = gl_->CreateProgram();
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   EXPECT_EQ(kProgramsAndShadersStartId, id);
 }
 
 TEST_F(GLES2ImplementationTest, BufferDataLargerThanTransferBuffer) {
   struct Cmds {
-    BufferData set_size;
-    BufferSubData copy_data1;
+    cmds::BufferData set_size;
+    cmds::BufferSubData copy_data1;
     cmd::SetToken set_token1;
-    BufferSubData copy_data2;
+    cmds::BufferSubData copy_data2;
     cmd::SetToken set_token2;
   };
   const unsigned kUsableSize =
       kTransferBufferSize - GLES2Implementation::kStartingOffset;
   uint8 buf[kUsableSize * 2] = { 0, };
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(kUsableSize);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(kUsableSize);
 
   Cmds expected;
@@ skipping 15 matching lines @@
     GL_BLEND,
     GL_CULL_FACE,
     GL_DEPTH_TEST,
     GL_POLYGON_OFFSET_FILL,
     GL_SAMPLE_ALPHA_TO_COVERAGE,
     GL_SAMPLE_COVERAGE,
     GL_SCISSOR_TEST,
     GL_STENCIL_TEST,
   };
   struct Cmds {
-    Enable enable_cmd;
+    cmds::Enable enable_cmd;
   };
   Cmds expected;
 
   for (size_t ii = 0; ii < arraysize(kStates); ++ii) {
     GLenum state = kStates[ii];
     expected.enable_cmd.Init(state);
     GLboolean result = gl_->IsEnabled(state);
     EXPECT_EQ(static_cast<GLboolean>(ii == 0), result);
     EXPECT_TRUE(NoCommandsWritten());
     const void* commands = GetPut();
     if (!result) {
       gl_->Enable(state);
       EXPECT_EQ(0, memcmp(&expected, commands, sizeof(expected)));
     }
     ClearCommands();
     result = gl_->IsEnabled(state);
     EXPECT_TRUE(result);
     EXPECT_TRUE(NoCommandsWritten());
   }
 }
 
 TEST_F(GLES2ImplementationTest, BindVertexArrayOES) {
   GLuint id = 0;
   gl_->GenVertexArraysOES(1, &id);
   ClearCommands();
 
   struct Cmds {
-    BindVertexArrayOES cmd;
+    cmds::BindVertexArrayOES cmd;
   };
   Cmds expected;
   expected.cmd.Init(id);
 
   const void* commands = GetPut();
   gl_->BindVertexArrayOES(id);
   EXPECT_EQ(0, memcmp(&expected, commands, sizeof(expected)));
   ClearCommands();
   gl_->BindVertexArrayOES(id);
   EXPECT_TRUE(NoCommandsWritten());
 }
 
 TEST_F(GLES2ImplementationTest, BeginEndQueryEXT) {
   // Test GetQueryivEXT returns 0 if no current query.
   GLint param = -1;
   gl_->GetQueryivEXT(GL_ANY_SAMPLES_PASSED_EXT, GL_CURRENT_QUERY_EXT, &param);
   EXPECT_EQ(0, param);
 
   GLuint expected_ids[2] = { 1, 2 }; // These must match what's actually genned.
   struct GenCmds {
-    GenQueriesEXTImmediate gen;
+    cmds::GenQueriesEXTImmediate gen;
     GLuint data[2];
   };
   GenCmds expected_gen_cmds;
   expected_gen_cmds.gen.Init(arraysize(expected_ids), &expected_ids[0]);
   GLuint ids[arraysize(expected_ids)] = { 0, };
   gl_->GenQueriesEXT(arraysize(expected_ids), &ids[0]);
   EXPECT_EQ(0, memcmp(
       &expected_gen_cmds, commands_, sizeof(expected_gen_cmds)));
   GLuint id1 = ids[0];
   GLuint id2 = ids[1];
   ClearCommands();
 
   // Test BeginQueryEXT fails if id = 0.
   gl_->BeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, 0);
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
 
   // Test BeginQueryEXT fails if id not GENed.
   // TODO(gman):
 
   // Test BeginQueryEXT inserts command.
   struct BeginCmds {
-    BeginQueryEXT begin_query;
+    cmds::BeginQueryEXT begin_query;
   };
   BeginCmds expected_begin_cmds;
   const void* commands = GetPut();
   gl_->BeginQueryEXT(GL_ANY_SAMPLES_PASSED_EXT, id1);
   QueryTracker::Query* query = GetQuery(id1);
   ASSERT_TRUE(query != NULL);
   expected_begin_cmds.begin_query.Init(
       GL_ANY_SAMPLES_PASSED_EXT, id1, query->shm_id(), query->shm_offset());
   EXPECT_EQ(0, memcmp(
       &expected_begin_cmds, commands, sizeof(expected_begin_cmds)));
@@ skipping 13 matching lines @@
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
 
   // Test EndQueryEXT fails if target not same as current query.
   ClearCommands();
   gl_->EndQueryEXT(GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT);
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
 
   // Test EndQueryEXT sends command
   struct EndCmds {
-    EndQueryEXT end_query;
+    cmds::EndQueryEXT end_query;
   };
   EndCmds expected_end_cmds;
   expected_end_cmds.end_query.Init(
       GL_ANY_SAMPLES_PASSED_EXT, query->submit_count());
   commands = GetPut();
   gl_->EndQueryEXT(GL_ANY_SAMPLES_PASSED_EXT);
   EXPECT_EQ(0, memcmp(
       &expected_end_cmds, commands, sizeof(expected_end_cmds)));
 
   // Test EndQueryEXT fails if no current query.
@@ skipping 47 matching lines @@
   ClearCommands();
 
   // Test BeginQueryEXT does NOT insert commands.
   gl_->BeginQueryEXT(GL_GET_ERROR_QUERY_CHROMIUM, id);
   EXPECT_TRUE(NoCommandsWritten());
   QueryTracker::Query* query = GetQuery(id);
   ASSERT_TRUE(query != NULL);
 
   // Test EndQueryEXT sends both begin and end command
   struct EndCmds {
-    BeginQueryEXT begin_query;
-    EndQueryEXT end_query;
+    cmds::BeginQueryEXT begin_query;
+    cmds::EndQueryEXT end_query;
   };
   EndCmds expected_end_cmds;
   expected_end_cmds.begin_query.Init(
       GL_GET_ERROR_QUERY_CHROMIUM, id, query->shm_id(), query->shm_offset());
   expected_end_cmds.end_query.Init(
       GL_GET_ERROR_QUERY_CHROMIUM, query->submit_count());
   const void* commands = GetPut();
   gl_->EndQueryEXT(GL_GET_ERROR_QUERY_CHROMIUM);
   EXPECT_EQ(0, memcmp(
       &expected_end_cmds, commands, sizeof(expected_end_cmds)));
@@ skipping 48 matching lines @@
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
 
   gl_->VertexAttribPointer(
       kAttribIndex1, kNumComponents1, GL_FLOAT, GL_FALSE, kClientStride, NULL);
   EXPECT_EQ(GL_NO_ERROR, CheckError());
 }
 #endif
 
 TEST_F(GLES2ImplementationTest, Disable) {
   struct Cmds {
-    Disable cmd;
+    cmds::Disable cmd;
   };
   Cmds expected;
   expected.cmd.Init(GL_DITHER);  // Note: DITHER defaults to enabled.
 
   gl_->Disable(GL_DITHER);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   // Check it's cached and not called again.
   ClearCommands();
   gl_->Disable(GL_DITHER);
   EXPECT_TRUE(NoCommandsWritten());
 }
 
 TEST_F(GLES2ImplementationTest, Enable) {
   struct Cmds {
-    Enable cmd;
+    cmds::Enable cmd;
   };
   Cmds expected;
   expected.cmd.Init(GL_BLEND);  // Note: BLEND defaults to disabled.
 
   gl_->Enable(GL_BLEND);
   EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
   // Check it's cached and not called again.
   ClearCommands();
   gl_->Enable(GL_BLEND);
   EXPECT_TRUE(NoCommandsWritten());
 }
 
 
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu