Refactor/Rename a bunch of GPU stuff

gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.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.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 68 matching lines @@
 
 void GLES2DecoderTestBase::InitDecoder(
     const char* extensions,
     bool has_alpha,
     bool has_depth,
     bool has_stencil,
     bool request_alpha,
     bool request_depth,
     bool request_stencil,
     bool bind_generates_resource) {
-  FramebufferManager::FramebufferInfo::ClearFramebufferCompleteComboMap();
+  Framebuffer::ClearFramebufferCompleteComboMap();
   gl_.reset(new StrictMock<MockGLInterface>());
   ::gfx::GLInterface::SetGLInterface(gl_.get());
-  group_ = ContextGroup::Ref(new ContextGroup(NULL,
-                                              NULL,
-                                              memory_tracker_,
-                                              bind_generates_resource));
+  group_ = scoped_refptr<ContextGroup>(new ContextGroup(
+      NULL,
+      NULL,
+      memory_tracker_,
+      bind_generates_resource));
 
   InSequence sequence;
 
   TestHelper::SetupContextGroupInitExpectations(gl_.get(),
       DisallowedFeatures(), extensions);
 
   // We initialize the ContextGroup with a MockGLES2Decoder so that
   // we can use the ContextGroup to figure out how the real GLES2Decoder
   // will initialize itself.
   mock_decoder_.reset(new MockGLES2Decoder());
@@ skipping 150 matching lines @@
   decoder_->set_log_synthesized_gl_errors(false);
   decoder_->Initialize(
       surface_, context_, false, surface_->GetSize(), DisallowedFeatures(),
       NULL, attribs);
   decoder_->MakeCurrent();
   decoder_->set_engine(engine_.get());
 
   EXPECT_CALL(*gl_, GenBuffersARB(_, _))
       .WillOnce(SetArgumentPointee<1>(kServiceBufferId))
       .RetiresOnSaturation();
-  GenHelper<GenBuffersImmediate>(client_buffer_id_);
+  GenHelper<cmds::GenBuffersImmediate>(client_buffer_id_);
   EXPECT_CALL(*gl_, GenFramebuffersEXT(_, _))
       .WillOnce(SetArgumentPointee<1>(kServiceFramebufferId))
       .RetiresOnSaturation();
-  GenHelper<GenFramebuffersImmediate>(client_framebuffer_id_);
+  GenHelper<cmds::GenFramebuffersImmediate>(client_framebuffer_id_);
   EXPECT_CALL(*gl_, GenRenderbuffersEXT(_, _))
       .WillOnce(SetArgumentPointee<1>(kServiceRenderbufferId))
       .RetiresOnSaturation();
-  GenHelper<GenRenderbuffersImmediate>(client_renderbuffer_id_);
+  GenHelper<cmds::GenRenderbuffersImmediate>(client_renderbuffer_id_);
   EXPECT_CALL(*gl_, GenTextures(_, _))
       .WillOnce(SetArgumentPointee<1>(kServiceTextureId))
       .RetiresOnSaturation();
-  GenHelper<GenTexturesImmediate>(client_texture_id_);
+  GenHelper<cmds::GenTexturesImmediate>(client_texture_id_);
   EXPECT_CALL(*gl_, GenBuffersARB(_, _))
       .WillOnce(SetArgumentPointee<1>(kServiceElementBufferId))
       .RetiresOnSaturation();
-  GenHelper<GenBuffersImmediate>(client_element_buffer_id_);
+  GenHelper<cmds::GenBuffersImmediate>(client_element_buffer_id_);
 
   DoCreateProgram(client_program_id_, kServiceProgramId);
   DoCreateShader(GL_VERTEX_SHADER, client_shader_id_, kServiceShaderId);
 
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 void GLES2DecoderTestBase::TearDown() {
   // All Tests should have read all their GLErrors before getting here.
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
@@ skipping 20 matching lines @@
         .Times(1)
         .RetiresOnSaturation();
   }
 }
 
 
 GLint GLES2DecoderTestBase::GetGLError() {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
-  GetError cmd;
+  cmds::GetError cmd;
   cmd.Init(shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   return static_cast<GLint>(*GetSharedMemoryAs<GLenum*>());
 }
 
 void GLES2DecoderTestBase::DoCreateShader(
     GLenum shader_type, GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, CreateShader(shader_type))
       .Times(1)
       .WillOnce(Return(service_id))
       .RetiresOnSaturation();
-  CreateShader cmd;
+  cmds::CreateShader cmd;
   cmd.Init(shader_type, client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 bool GLES2DecoderTestBase::DoIsShader(GLuint client_id) {
-  return IsObjectHelper<IsShader, IsShader::Result>(client_id);
+  return IsObjectHelper<cmds::IsShader, cmds::IsShader::Result>(client_id);
 }
 
 void GLES2DecoderTestBase::DoDeleteShader(
     GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, DeleteShader(service_id))
       .Times(1)
       .RetiresOnSaturation();
-  DeleteShader cmd;
+  cmds::DeleteShader cmd;
   cmd.Init(client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoCreateProgram(
     GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, CreateProgram())
       .Times(1)
       .WillOnce(Return(service_id))
       .RetiresOnSaturation();
-  CreateProgram cmd;
+  cmds::CreateProgram cmd;
   cmd.Init(client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 bool GLES2DecoderTestBase::DoIsProgram(GLuint client_id) {
-  return IsObjectHelper<IsProgram, IsProgram::Result>(client_id);
+  return IsObjectHelper<cmds::IsProgram, cmds::IsProgram::Result>(client_id);
 }
 
 void GLES2DecoderTestBase::DoDeleteProgram(
     GLuint client_id, GLuint /* service_id */) {
-  DeleteProgram cmd;
+  cmds::DeleteProgram cmd;
   cmd.Init(client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::SetBucketAsCString(
     uint32 bucket_id, const char* str) {
   uint32 size = str ? (strlen(str) + 1) : 0;
   cmd::SetBucketSize cmd1;
   cmd1.Init(bucket_id, size);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
@@ skipping 162 matching lines @@
   const GLuint kClientFragmentShaderId = 5002;
   const GLuint kServiceFragmentShaderId = 6002;
   SetupShader(attribs, arraysize(attribs), uniforms, arraysize(uniforms),
               client_program_id_, kServiceProgramId,
               kClientVertexShaderId, kServiceVertexShaderId,
               kClientFragmentShaderId, kServiceFragmentShaderId);
 
   EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
       .Times(1)
       .RetiresOnSaturation();
-  UseProgram cmd;
+  cmds::UseProgram cmd;
   cmd.Init(client_program_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoBindBuffer(
     GLenum target, GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, BindBuffer(target, service_id))
       .Times(1)
       .RetiresOnSaturation();
-  BindBuffer cmd;
+  cmds::BindBuffer cmd;
   cmd.Init(target, client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 bool GLES2DecoderTestBase::DoIsBuffer(GLuint client_id) {
-  return IsObjectHelper<IsBuffer, IsBuffer::Result>(client_id);
+  return IsObjectHelper<cmds::IsBuffer, cmds::IsBuffer::Result>(client_id);
 }
 
 void GLES2DecoderTestBase::DoDeleteBuffer(
     GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, DeleteBuffersARB(1, Pointee(service_id)))
       .Times(1)
       .RetiresOnSaturation();
-  DeleteBuffers cmd;
+  cmds::DeleteBuffers cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
   memcpy(shared_memory_address_, &client_id, sizeof(client_id));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::SetupExpectationsForApplyingDirtyState(
     bool framebuffer_is_rgb,
     bool framebuffer_has_depth,
     bool framebuffer_has_stencil,
     GLuint color_bits,
@@ skipping 82 matching lines @@
       false,   // cull_face_enabled
       false,   // scissor_test_enabled
       false);  // blend_enabled
 }
 
 void GLES2DecoderTestBase::DoBindFramebuffer(
     GLenum target, GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, BindFramebufferEXT(target, service_id))
       .Times(1)
       .RetiresOnSaturation();
-  BindFramebuffer cmd;
+  cmds::BindFramebuffer cmd;
   cmd.Init(target, client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 bool GLES2DecoderTestBase::DoIsFramebuffer(GLuint client_id) {
-  return IsObjectHelper<IsFramebuffer, IsFramebuffer::Result>(client_id);
+  return IsObjectHelper<cmds::IsFramebuffer, cmds::IsFramebuffer::Result>(
+      client_id);
 }
 
 void GLES2DecoderTestBase::DoDeleteFramebuffer(
     GLuint client_id, GLuint service_id,
     bool reset_draw, GLenum draw_target, GLuint draw_id,
     bool reset_read, GLenum read_target, GLuint read_id) {
   if (reset_draw) {
     EXPECT_CALL(*gl_, BindFramebufferEXT(draw_target, draw_id))
         .Times(1)
         .RetiresOnSaturation();
   }
   if (reset_read) {
     EXPECT_CALL(*gl_, BindFramebufferEXT(read_target, read_id))
         .Times(1)
         .RetiresOnSaturation();
   }
   EXPECT_CALL(*gl_, DeleteFramebuffersEXT(1, Pointee(service_id)))
       .Times(1)
       .RetiresOnSaturation();
-  DeleteFramebuffers cmd;
+  cmds::DeleteFramebuffers cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
   memcpy(shared_memory_address_, &client_id, sizeof(client_id));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoBindRenderbuffer(
     GLenum target, GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, BindRenderbufferEXT(target, service_id))
       .Times(1)
       .RetiresOnSaturation();
-  BindRenderbuffer cmd;
+  cmds::BindRenderbuffer cmd;
   cmd.Init(target, client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 bool GLES2DecoderTestBase::DoIsRenderbuffer(GLuint client_id) {
-  return IsObjectHelper<IsRenderbuffer, IsRenderbuffer::Result>(client_id);
+  return IsObjectHelper<cmds::IsRenderbuffer, cmds::IsRenderbuffer::Result>(
+      client_id);
 }
 
 void GLES2DecoderTestBase::DoDeleteRenderbuffer(
     GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, DeleteRenderbuffersEXT(1, Pointee(service_id)))
       .Times(1)
       .RetiresOnSaturation();
-  DeleteRenderbuffers cmd;
+  cmds::DeleteRenderbuffers cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
   memcpy(shared_memory_address_, &client_id, sizeof(client_id));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoBindTexture(
     GLenum target, GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, BindTexture(target, service_id))
       .Times(1)
       .RetiresOnSaturation();
-  BindTexture cmd;
+  cmds::BindTexture cmd;
   cmd.Init(target, client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 bool GLES2DecoderTestBase::DoIsTexture(GLuint client_id) {
-  return IsObjectHelper<IsTexture, IsTexture::Result>(client_id);
+  return IsObjectHelper<cmds::IsTexture, cmds::IsTexture::Result>(client_id);
 }
 
 void GLES2DecoderTestBase::DoDeleteTexture(
     GLuint client_id, GLuint service_id) {
   EXPECT_CALL(*gl_, DeleteTextures(1, Pointee(service_id)))
       .Times(1)
       .RetiresOnSaturation();
-  DeleteTextures cmd;
+  cmds::DeleteTextures cmd;
   cmd.Init(1, shared_memory_id_, shared_memory_offset_);
   memcpy(shared_memory_address_, &client_id, sizeof(client_id));
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoTexImage2D(
     GLenum target, GLint level, GLenum internal_format,
     GLsizei width, GLsizei height, GLint border,
     GLenum format, GLenum type,
     uint32 shared_memory_id, uint32 shared_memory_offset) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, TexImage2D(target, level, internal_format,
                                width, height, border, format, type, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
-  TexImage2D cmd;
+  cmds::TexImage2D cmd;
   cmd.Init(target, level, internal_format, width, height, border, format,
            type, shared_memory_id, shared_memory_offset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoCompressedTexImage2D(
     GLenum target, GLint level, GLenum format,
     GLsizei width, GLsizei height, GLint border,
     GLsizei size, uint32 bucket_id) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, CompressedTexImage2D(
       target, level, format, width, height, border, size, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(bucket_id);
   bucket->SetSize(size);
-  CompressedTexImage2DBucket cmd;
+  cmds::CompressedTexImage2DBucket cmd;
   cmd.Init(
       target, level, format, width, height, border,
       bucket_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoTexImage2DSameSize(
     GLenum target, GLint level, GLenum internal_format,
     GLsizei width, GLsizei height, GLint border,
     GLenum format, GLenum type,
     uint32 shared_memory_id, uint32 shared_memory_offset) {
   if (GLES2Decoder::IsAngle()) {
     EXPECT_CALL(*gl_, TexSubImage2D(
         target, level, 0, 0, width, height, format, type, _))
         .Times(1)
         .RetiresOnSaturation();
   } else {
     EXPECT_CALL(*gl_, GetError())
         .WillOnce(Return(GL_NO_ERROR))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, TexImage2D(target, level, internal_format,
                                  width, height, border, format, type, _))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, GetError())
         .WillOnce(Return(GL_NO_ERROR))
         .RetiresOnSaturation();
   }
-  TexImage2D cmd;
+  cmds::TexImage2D cmd;
   cmd.Init(target, level, internal_format, width, height, border, format,
            type, shared_memory_id, shared_memory_offset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoRenderbufferStorage(
     GLenum target, GLenum internal_format, GLenum actual_format,
     GLsizei width, GLsizei height,  GLenum error) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, RenderbufferStorageEXT(
       target, actual_format, width, height))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(error))
       .RetiresOnSaturation();
-  RenderbufferStorage cmd;
+  cmds::RenderbufferStorage cmd;
   cmd.Init(target, internal_format, width, height);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoFramebufferTexture2D(
     GLenum target, GLenum attachment, GLenum textarget,
     GLuint texture_client_id, GLuint texture_service_id, GLint level,
     GLenum error) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, FramebufferTexture2DEXT(
       target, attachment, textarget, texture_service_id, level))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(error))
       .RetiresOnSaturation();
-  FramebufferTexture2D cmd;
+  cmds::FramebufferTexture2D cmd;
   cmd.Init(target, attachment, textarget, texture_client_id, level);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoFramebufferRenderbuffer(
     GLenum target,
     GLenum attachment,
     GLenum renderbuffer_target,
     GLuint renderbuffer_client_id,
     GLuint renderbuffer_service_id,
     GLenum error) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, FramebufferRenderbufferEXT(
       target, attachment, renderbuffer_target, renderbuffer_service_id))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(error))
       .RetiresOnSaturation();
-  FramebufferRenderbuffer cmd;
+  cmds::FramebufferRenderbuffer cmd;
   cmd.Init(target, attachment, renderbuffer_target, renderbuffer_client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoVertexAttribPointer(
     GLuint index, GLint size, GLenum type, GLsizei stride, GLuint offset) {
   EXPECT_CALL(*gl_,
               VertexAttribPointer(index, size, type, GL_FALSE, stride,
                                   BufferOffset(offset)))
       .Times(1)
       .RetiresOnSaturation();
-  VertexAttribPointer cmd;
+  cmds::VertexAttribPointer cmd;
   cmd.Init(index, size, GL_FLOAT, GL_FALSE, stride, offset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoVertexAttribDivisorANGLE(
     GLuint index, GLuint divisor) {
   EXPECT_CALL(*gl_,
               VertexAttribDivisorANGLE(index, divisor))
       .Times(1)
       .RetiresOnSaturation();
-  VertexAttribDivisorANGLE cmd;
+  cmds::VertexAttribDivisorANGLE cmd;
   cmd.Init(index, divisor);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::AddExpectationsForGenVertexArraysOES(){
   if (group_->feature_info()->feature_flags().native_vertex_array_object) {
       EXPECT_CALL(*gl_, GenVertexArraysOES(1, _))
           .WillOnce(SetArgumentPointee<1>(kServiceVertexArrayId))
           .RetiresOnSaturation();
   }
@@ skipping 188 matching lines @@
     SetupShader(attribs, arraysize(attribs), uniforms, arraysize(uniforms),
                 client_program_id_, kServiceProgramId,
                 client_vertex_shader_id_, kServiceVertexShaderId,
                 client_fragment_shader_id_, kServiceFragmentShaderId);
   }
 
   {
     EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
         .Times(1)
         .RetiresOnSaturation();
-    UseProgram cmd;
+    cmds::UseProgram cmd;
     cmd.Init(client_program_id_);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   }
 }
 
 void GLES2DecoderTestBase::SetupCubemapProgram() {
   {
     static AttribInfo attribs[] = {
       { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
       { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
@@ skipping 13 matching lines @@
     SetupShader(attribs, arraysize(attribs), uniforms, arraysize(uniforms),
                 client_program_id_, kServiceProgramId,
                 client_vertex_shader_id_, kServiceVertexShaderId,
                 client_fragment_shader_id_, kServiceFragmentShaderId);
   }
 
   {
     EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
         .Times(1)
         .RetiresOnSaturation();
-    UseProgram cmd;
+    cmds::UseProgram cmd;
     cmd.Init(client_program_id_);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   }
 }
 
 void GLES2DecoderWithShaderTestBase::TearDown() {
   GLES2DecoderTestBase::TearDown();
 }
 
 void GLES2DecoderTestBase::SetupShader(
@@ skipping 17 matching lines @@
         gl_.get(), attribs, num_attribs, uniforms, num_uniforms,
         program_service_id);
   }
 
   DoCreateShader(
       GL_VERTEX_SHADER, vertex_shader_client_id, vertex_shader_service_id);
   DoCreateShader(
       GL_FRAGMENT_SHADER, fragment_shader_client_id,
       fragment_shader_service_id);
 
-  GetShaderInfo(vertex_shader_client_id)->SetStatus(true, "", NULL);
-  GetShaderInfo(fragment_shader_client_id)->SetStatus(true, "", NULL);
+  GetShader(vertex_shader_client_id)->SetStatus(true, "", NULL);
+  GetShader(fragment_shader_client_id)->SetStatus(true, "", NULL);
 
-  AttachShader attach_cmd;
+  cmds::AttachShader attach_cmd;
   attach_cmd.Init(program_client_id, vertex_shader_client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
 
   attach_cmd.Init(program_client_id, fragment_shader_client_id);
   EXPECT_EQ(error::kNoError, ExecuteCmd(attach_cmd));
 
-  LinkProgram link_cmd;
+  cmds::LinkProgram link_cmd;
   link_cmd.Init(program_client_id);
 
   EXPECT_EQ(error::kNoError, ExecuteCmd(link_cmd));
 
   // Assume the next command will be UseProgram.
   SetupExpectationsForClearingUniforms(uniforms, num_uniforms);
 }
 
 void GLES2DecoderTestBase::DoEnableVertexAttribArray(GLint index) {
   EXPECT_CALL(*gl_, EnableVertexAttribArray(index))
       .Times(1)
       .RetiresOnSaturation();
-  EnableVertexAttribArray cmd;
+  cmds::EnableVertexAttribArray cmd;
   cmd.Init(index);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoBufferData(GLenum target, GLsizei size) {
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, BufferData(target, size, _, GL_STREAM_DRAW))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
-  BufferData cmd;
+  cmds::BufferData cmd;
   cmd.Init(target, size, 0, 0, GL_STREAM_DRAW);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::DoBufferSubData(
     GLenum target, GLint offset, GLsizei size, const void* data) {
   EXPECT_CALL(*gl_, BufferSubData(target, offset, size,
                                   shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   memcpy(shared_memory_address_, data, size);
-  BufferSubData cmd;
+  cmds::BufferSubData cmd;
   cmd.Init(target, offset, size, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 void GLES2DecoderTestBase::SetupVertexBuffer() {
   DoEnableVertexAttribArray(1);
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
   GLfloat f = 0;
   DoBufferData(GL_ARRAY_BUFFER, kNumVertices * 2 * sizeof(f));
 }
@@ skipping 122 matching lines @@
   SetupDefaultProgram();
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_0_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu