Refactor/Rename a bunch of GPU stuff

gpu/command_buffer/client/gles2_implementation.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.
 
 // A class to emulate GLES2 over command buffers.
 
 #include "../client/gles2_implementation.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 319 matching lines @@
       break;
     }
   }
   error_bits_ &= ~GLES2Util::GLErrorToErrorBit(error);
   return error;
 }
 
 GLenum GLES2Implementation::GetGLError() {
   TRACE_EVENT0("gpu", "GLES2::GetGLError");
   // Check the GL error first, then our wrapped error.
-  typedef gles2::GetError::Result Result;
+  typedef cmds::GetError::Result Result;
   Result* result = GetResultAs<Result*>();
   // If we couldn't allocate a result the context is lost.
   if (!result) {
     return GL_NO_ERROR;
   }
   *result = GL_NO_ERROR;
   helper_->GetError(GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   GLenum error = *result;
   if (error == GL_NO_ERROR) {
@@ skipping 164 matching lines @@
   }
   CheckGLError();
 }
 
 GLboolean GLES2Implementation::IsEnabled(GLenum cap) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glIsEnabled("
                  << GLES2Util::GetStringCapability(cap) << ")");
   bool state = false;
   if (!state_.GetEnabled(cap, &state)) {
-    typedef IsEnabled::Result Result;
+    typedef cmds::IsEnabled::Result Result;
     Result* result = GetResultAs<Result*>();
     if (!result) {
       return GL_FALSE;
     }
     *result = 0;
     helper_->IsEnabled(cap, GetResultShmId(), GetResultShmOffset());
     WaitForCmd();
     state = (*result) != 0;
   }
 
@@ skipping 114 matching lines @@
   *params = static_cast<GLfloat>(value);
   return true;
 }
 
 bool GLES2Implementation::GetIntegervHelper(GLenum pname, GLint* params) {
   return GetHelper(pname, params);
 }
 
 GLuint GLES2Implementation::GetMaxValueInBufferCHROMIUMHelper(
     GLuint buffer_id, GLsizei count, GLenum type, GLuint offset) {
-  typedef GetMaxValueInBufferCHROMIUM::Result Result;
+  typedef cmds::GetMaxValueInBufferCHROMIUM::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return 0;
   }
   *result = 0;
   helper_->GetMaxValueInBufferCHROMIUM(
       buffer_id, count, type, offset, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   return *result;
 }
@@ skipping 227 matching lines @@
 
 void GLES2Implementation::GetVertexAttribPointerv(
     GLuint index, GLenum pname, void** ptr) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribPointer("
       << index << ", " << GLES2Util::GetStringVertexPointer(pname) << ", "
       << static_cast<void*>(ptr) << ")");
   GPU_CLIENT_LOG_CODE_BLOCK(int32 num_results = 1);
   if (!vertex_array_object_manager_->GetAttribPointer(index, pname, ptr)) {
     TRACE_EVENT0("gpu", "GLES2::GetVertexAttribPointerv");
-    typedef gles2::GetVertexAttribPointerv::Result Result;
+    typedef cmds::GetVertexAttribPointerv::Result Result;
     Result* result = GetResultAs<Result*>();
     if (!result) {
       return;
     }
     result->SetNumResults(0);
     helper_->GetVertexAttribPointerv(
       index, pname, GetResultShmId(), GetResultShmOffset());
     WaitForCmd();
     result->CopyResult(ptr);
     GPU_CLIENT_LOG_CODE_BLOCK(num_results = result->GetNumResults());
@@ skipping 41 matching lines @@
 void GLES2Implementation::DeleteShaderStub(
     GLsizei n, const GLuint* shaders) {
   GPU_DCHECK_EQ(1, n);
   share_group_->program_info_manager()->DeleteInfo(shaders[0]);
   helper_->DeleteShader(shaders[0]);
 }
 
 
 GLint GLES2Implementation::GetAttribLocationHelper(
     GLuint program, const char* name) {
-  typedef GetAttribLocationBucket::Result Result;
+  typedef cmds::GetAttribLocationBucket::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return -1;
   }
   *result = -1;
   SetBucketAsCString(kResultBucketId, name);
   helper_->GetAttribLocationBucket(
       program, kResultBucketId, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
   return *result;
 }
 
 GLint GLES2Implementation::GetAttribLocation(
     GLuint program, const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetAttribLocation(" << program
       << ", " << name << ")");
   TRACE_EVENT0("gpu", "GLES2::GetAttribLocation");
   GLint loc = share_group_->program_info_manager()->GetAttribLocation(
       this, program, name);
   GPU_CLIENT_LOG("returned " << loc);
   CheckGLError();
   return loc;
 }
 
 GLint GLES2Implementation::GetUniformLocationHelper(
     GLuint program, const char* name) {
-  typedef GetUniformLocationBucket::Result Result;
+  typedef cmds::GetUniformLocationBucket::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return -1;
   }
   *result = -1;
   SetBucketAsCString(kResultBucketId, name);
   helper_->GetUniformLocationBucket(program, kResultBucketId,
                                     GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
@@ skipping 734 matching lines @@
     source += num_rows * pixels_padded_row_size;
     height -= num_rows;
   }
 }
 
 bool GLES2Implementation::GetActiveAttribHelper(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
-  typedef gles2::GetActiveAttrib::Result Result;
+  typedef cmds::GetActiveAttrib::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return false;
   }
   // Set as failed so if the command fails we'll recover.
   result->success = false;
   helper_->GetActiveAttrib(program, index, kResultBucketId,
                            GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   if (result->success) {
@@ skipping 50 matching lines @@
     }
   }
   CheckGLError();
 }
 
 bool GLES2Implementation::GetActiveUniformHelper(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
-  typedef gles2::GetActiveUniform::Result Result;
+  typedef cmds::GetActiveUniform::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return false;
   }
   // Set as failed so if the command fails we'll recover.
   result->success = false;
   helper_->GetActiveUniform(program, index, kResultBucketId,
                             GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   if (result->success) {
@@ skipping 57 matching lines @@
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetAttachedShaders("
       << program << ", " << maxcount << ", "
       << static_cast<const void*>(count) << ", "
       << static_cast<const void*>(shaders) << ", ");
   if (maxcount < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetAttachedShaders", "maxcount < 0");
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetAttachedShaders");
-  typedef gles2::GetAttachedShaders::Result Result;
+  typedef cmds::GetAttachedShaders::Result Result;
   uint32 size = Result::ComputeSize(maxcount);
   Result* result = static_cast<Result*>(transfer_buffer_->Alloc(size));
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetAttachedShaders(
     program,
     transfer_buffer_->GetShmId(),
     transfer_buffer_->GetOffset(result),
@@ skipping 15 matching lines @@
 
 void GLES2Implementation::GetShaderPrecisionFormat(
     GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetShaderPrecisionFormat("
       << GLES2Util::GetStringShaderType(shadertype) << ", "
       << GLES2Util::GetStringShaderPrecision(precisiontype) << ", "
       << static_cast<const void*>(range) << ", "
       << static_cast<const void*>(precision) << ", ");
   TRACE_EVENT0("gpu", "GLES2::GetShaderPrecisionFormat");
-  typedef gles2::GetShaderPrecisionFormat::Result Result;
+  typedef cmds::GetShaderPrecisionFormat::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->success = false;
   helper_->GetShaderPrecisionFormat(
     shadertype, precisiontype, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   if (result->success) {
     if (range) {
@@ skipping 66 matching lines @@
   return result;
 }
 
 void GLES2Implementation::GetUniformfv(
     GLuint program, GLint location, GLfloat* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetUniformfv("
       << program << ", " << location << ", "
       << static_cast<const void*>(params) << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformfv");
-  typedef gles2::GetUniformfv::Result Result;
+  typedef cmds::GetUniformfv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetUniformfv(
       program, location, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 void GLES2Implementation::GetUniformiv(
     GLuint program, GLint location, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetUniformiv("
       << program << ", " << location << ", "
       << static_cast<const void*>(params) << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformiv");
-  typedef gles2::GetUniformiv::Result Result;
+  typedef cmds::GetUniformiv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetUniformiv(
       program, location, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
-  GetResultAs<gles2::GetUniformfv::Result*>()->CopyResult(params);
+  GetResultAs<cmds::GetUniformfv::Result*>()->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 void GLES2Implementation::ReadPixels(
     GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format,
@@ skipping 13 matching lines @@
     return;
   }
 
   // glReadPixel pads the size of each row of pixels by an amount specified by
   // glPixelStorei. So, we have to take that into account both in the fact that
   // the pixels returned from the ReadPixel command will include that padding
   // and that when we copy the results to the user's buffer we need to not
   // write those padding bytes but leave them as they are.
 
   TRACE_EVENT0("gpu", "GLES2::ReadPixels");
-  typedef gles2::ReadPixels::Result Result;
+  typedef cmds::ReadPixels::Result Result;
 
   int8* dest = reinterpret_cast<int8*>(pixels);
   uint32 temp_size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
       width, 2, format, type, pack_alignment_, &temp_size, &unpadded_row_size,
       &padded_row_size)) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels", "size too large.");
     return;
@@ skipping 405 matching lines @@
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribfv("
       << index << ", "
       << GLES2Util::GetStringVertexAttribute(pname) << ", "
       << static_cast<const void*>(params) << ")");
   uint32 value = 0;
   if (vertex_array_object_manager_->GetVertexAttrib(index, pname, &value)) {
     *params = static_cast<float>(value);
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetVertexAttribfv");
-  typedef GetVertexAttribfv::Result Result;
+  typedef cmds::GetVertexAttribfv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetVertexAttribfv(
       index, pname, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
@@ skipping 10 matching lines @@
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribiv("
       << index << ", "
       << GLES2Util::GetStringVertexAttribute(pname) << ", "
       << static_cast<const void*>(params) << ")");
   uint32 value = 0;
   if (vertex_array_object_manager_->GetVertexAttrib(index, pname, &value)) {
     *params = value;
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetVertexAttribiv");
-  typedef GetVertexAttribiv::Result Result;
+  typedef cmds::GetVertexAttribiv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetVertexAttribiv(
       index, pname, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   result->CopyResult(params);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   CheckGLError();
 }
 
 GLboolean GLES2Implementation::EnableFeatureCHROMIUM(
     const char* feature) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glEnableFeatureCHROMIUM("
                  << feature << ")");
   TRACE_EVENT0("gpu", "GLES2::EnableFeatureCHROMIUM");
-  typedef EnableFeatureCHROMIUM::Result Result;
+  typedef cmds::EnableFeatureCHROMIUM::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return false;
   }
   *result = 0;
   SetBucketAsCString(kResultBucketId, feature);
   helper_->EnableFeatureCHROMIUM(
       kResultBucketId, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   helper_->SetBucketSize(kResultBucketId, 0);
@@ skipping 315 matching lines @@
     return;
   }
   memcpy(info, &result[0], result.size());
 }
 
 GLuint GLES2Implementation::CreateStreamTextureCHROMIUM(GLuint texture) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG("[" << GetLogPrefix() << "] CreateStreamTextureCHROMIUM("
       << texture << ")");
   TRACE_EVENT0("gpu", "GLES2::CreateStreamTextureCHROMIUM");
-  typedef CreateStreamTextureCHROMIUM::Result Result;
+  typedef cmds::CreateStreamTextureCHROMIUM::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return GL_ZERO;
   }
   *result = GL_ZERO;
 
   helper_->CreateStreamTextureCHROMIUM(texture,
                                        GetResultShmId(),
                                        GetResultShmOffset());
   WaitForCmd();
@@ skipping 517 matching lines @@
   return;
 }
 
 // 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 "../client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu