Remove --enable-gpu-service-logging and --enable-gpu-client-logging

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 "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <algorithm>
 #include <map>
@@ skipping 12 matching lines @@
 #include "gpu/command_buffer/client/vertex_array_object_manager.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/gpu_control.h"
 #include "gpu/command_buffer/common/trace_event.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 #if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
 #endif
 
-#if defined(GPU_CLIENT_DEBUG)
-#include "ui/gl/gl_switches.h"
-#include "base/command_line.h"
-#endif
-
 namespace gpu {
 namespace gles2 {
 
 // A 32-bit and 64-bit compatible way of converting a pointer to a GLuint.
 static GLuint ToGLuint(const void* ptr) {
   return static_cast<GLuint>(reinterpret_cast<size_t>(ptr));
 }
 
 #if !defined(_MSC_VER)
 const size_t GLES2Implementation::kMaxSizeOfSimpleResult;
@@ skipping 52 matching lines @@
       pack_reverse_row_order_(false),
       active_texture_unit_(0),
       bound_framebuffer_(0),
       bound_read_framebuffer_(0),
       bound_renderbuffer_(0),
       current_program_(0),
       bound_array_buffer_id_(0),
       bound_pixel_pack_transfer_buffer_id_(0),
       bound_pixel_unpack_transfer_buffer_id_(0),
       error_bits_(0),
-      debug_(false),
       use_count_(0),
       current_query_(NULL),
       error_message_callback_(NULL),
       gpu_control_(gpu_control),
       weak_ptr_factory_(this) {
   DCHECK(helper);
   DCHECK(transfer_buffer);
   DCHECK(gpu_control);
 
   char temp[128];
   sprintf(temp, "%p", static_cast<void*>(this));
   this_in_hex_ = std::string(temp);
 
-  GPU_CLIENT_LOG_CODE_BLOCK({
-    debug_ = CommandLine::ForCurrentProcess()->HasSwitch(
-        switches::kEnableGPUClientLogging);
-  });
-
   share_group_ =
       (share_group ? share_group : new ShareGroup(bind_generates_resource));
 
   memset(&reserved_ids_, 0, sizeof(reserved_ids_));
 }
 
 bool GLES2Implementation::Initialize(
     unsigned int starting_transfer_buffer_size,
     unsigned int min_transfer_buffer_size,
     unsigned int max_transfer_buffer_size,
@@ skipping 254 matching lines @@
       &chromium_framebuffer_multisample_);
 }
 
 const std::string& GLES2Implementation::GetLogPrefix() const {
   const std::string& prefix(debug_marker_manager_.GetMarker());
   return prefix.empty() ? this_in_hex_ : prefix;
 }
 
 GLenum GLES2Implementation::GetError() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetError()");
   GLenum err = GetGLError();
-  GPU_CLIENT_LOG("returned " << GLES2Util::GetStringError(err));
   return err;
 }
 
 GLenum GLES2Implementation::GetClientSideGLError() {
   if (error_bits_ == 0) {
     return GL_NO_ERROR;
   }
 
   GLenum error = GL_NO_ERROR;
   for (uint32 mask = 1; mask != 0; mask = mask << 1) {
@@ skipping 35 matching lines @@
   }
 }
 // NOTE: Calling GetGLError overwrites data in the result buffer.
 void GLES2Implementation::CheckGLError() {
   FailGLError(GetGLError());
 }
 #endif  // defined(GPU_CLIENT_FAIL_GL_ERRORS)
 
 void GLES2Implementation::SetGLError(
     GLenum error, const char* function_name, const char* msg) {
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] Client Synthesized Error: "
-                 << GLES2Util::GetStringError(error) << ": "
-                 << function_name << ": " << msg);
   FailGLError(error);
   if (msg) {
     last_error_ = msg;
   }
   if (error_message_callback_) {
     std::string temp(GLES2Util::GetStringError(error)  + " : " +
                      function_name + ": " + (msg ? msg : ""));
     error_message_callback_->OnErrorMessage(temp.c_str(), 0);
   }
   error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
@@ skipping 103 matching lines @@
 
 void GLES2Implementation::SetBucketAsString(
     uint32 bucket_id, const std::string& str) {
   // NOTE: strings are passed NULL terminated. That means the empty
   // string will have a size of 1 and no-string will have a size of 0
   SetBucketContents(bucket_id, str.c_str(), str.size() + 1);
 }
 
 void GLES2Implementation::Disable(GLenum cap) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDisable("
-                 << GLES2Util::GetStringCapability(cap) << ")");
   bool changed = false;
   if (!state_.SetCapabilityState(cap, false, &changed) || changed) {
     helper_->Disable(cap);
   }
   CheckGLError();
 }
 
 void GLES2Implementation::Enable(GLenum cap) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glEnable("
-                 << GLES2Util::GetStringCapability(cap) << ")");
   bool changed = false;
   if (!state_.SetCapabilityState(cap, true, &changed) || changed) {
     helper_->Enable(cap);
   }
   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 cmds::IsEnabled::Result Result;
     Result* result = GetResultAs<Result*>();
     if (!result) {
       return GL_FALSE;
     }
     *result = 0;
     helper_->IsEnabled(cap, GetResultShmId(), GetResultShmOffset());
     WaitForCmd();
     state = (*result) != 0;
   }
 
-  GPU_CLIENT_LOG("returned " << state);
   CheckGLError();
   return state;
 }
 
 bool GLES2Implementation::GetHelper(GLenum pname, GLint* params) {
   switch (pname) {
     case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
       *params = static_state_.int_state.max_combined_texture_image_units;
       return true;
     case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
@@ skipping 128 matching lines @@
   *result = 0;
   helper_->GetMaxValueInBufferCHROMIUM(
       buffer_id, count, type, offset, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   return *result;
 }
 
 GLuint GLES2Implementation::GetMaxValueInBufferCHROMIUM(
     GLuint buffer_id, GLsizei count, GLenum type, GLuint offset) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetMaxValueInBufferCHROMIUM("
-                 << buffer_id << ", " << count << ", "
-                 << GLES2Util::GetStringGetMaxIndexType(type)
-                 << ", " << offset << ")");
   GLuint result = GetMaxValueInBufferCHROMIUMHelper(
       buffer_id, count, type, offset);
-  GPU_CLIENT_LOG("returned " << result);
   CheckGLError();
   return result;
 }
 
 void GLES2Implementation::RestoreElementAndArrayBuffers(bool restore) {
   if (restore) {
     RestoreArrayBuffer(restore);
     // Restore the element array binding.
     // We only need to restore it if it wasn't a client side array.
     if (vertex_array_object_manager_->bound_element_array_buffer() == 0) {
       helper_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
     }
   }
 }
 
 void GLES2Implementation::RestoreArrayBuffer(bool restore) {
   if (restore) {
     // Restore the user's current binding.
     helper_->BindBuffer(GL_ARRAY_BUFFER, bound_array_buffer_id_);
   }
 }
 
 void GLES2Implementation::DrawElements(
     GLenum mode, GLsizei count, GLenum type, const void* indices) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDrawElements("
-      << GLES2Util::GetStringDrawMode(mode) << ", "
-      << count << ", "
-      << GLES2Util::GetStringIndexType(type) << ", "
-      << static_cast<const void*>(indices) << ")");
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawElements", "count less than 0.");
     return;
   }
   if (count == 0) {
     return;
   }
   GLuint offset = 0;
   bool simulated = false;
   if (!vertex_array_object_manager_->SetupSimulatedIndexAndClientSideBuffers(
       "glDrawElements", this, helper_, count, type, 0, indices,
       &offset, &simulated)) {
     return;
   }
   helper_->DrawElements(mode, count, type, offset);
   RestoreElementAndArrayBuffers(simulated);
   CheckGLError();
 }
 
 void GLES2Implementation::Flush() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glFlush()");
   // Insert the cmd to call glFlush
   helper_->Flush();
   // Flush our command buffer
   // (tell the service to execute up to the flush cmd.)
   helper_->CommandBufferHelper::Flush();
 }
 
 void GLES2Implementation::ShallowFlushCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glShallowFlushCHROMIUM()");
   // Flush our command buffer
   // (tell the service to execute up to the flush cmd.)
   helper_->CommandBufferHelper::Flush();
 }
 
 void GLES2Implementation::Finish() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   FinishHelper();
 }
 
 void GLES2Implementation::ShallowFinishCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   // Flush our command buffer (tell the service to execute up to the flush cmd
   // and don't return until it completes).
   helper_->CommandBufferHelper::Finish();
 }
 
 bool GLES2Implementation::MustBeContextLost() {
   bool context_lost = helper_->IsContextLost();
   if (!context_lost) {
     WaitForCmd();
     context_lost = helper_->IsContextLost();
   }
   CHECK(context_lost);
   return context_lost;
 }
 
 void GLES2Implementation::FinishHelper() {
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glFinish()");
   TRACE_EVENT0("gpu", "GLES2::Finish");
   // Insert the cmd to call glFinish
   helper_->Finish();
   // Finish our command buffer
   // (tell the service to execute up to the Finish cmd and wait for it to
   // execute.)
   helper_->CommandBufferHelper::Finish();
 }
 
 void GLES2Implementation::SwapBuffers() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glSwapBuffers()");
   // TODO(piman): Strictly speaking we'd want to insert the token after the
   // swap, but the state update with the updated token might not have happened
   // by the time the SwapBuffer callback gets called, forcing us to synchronize
   // with the GPU process more than needed. So instead, make it happen before.
   // All it means is that we could be slightly looser on the kMaxSwapBuffers
   // semantics if the client doesn't use the callback mechanism, and by chance
   // the scheduler yields between the InsertToken and the SwapBuffers.
   swap_buffers_tokens_.push(helper_->InsertToken());
   helper_->SwapBuffers();
   helper_->CommandBufferHelper::Flush();
   // Wait if we added too many swap buffers. Add 1 to kMaxSwapBuffers to
   // compensate for TODO above.
   if (swap_buffers_tokens_.size() > kMaxSwapBuffers + 1) {
     helper_->WaitForToken(swap_buffers_tokens_.front());
     swap_buffers_tokens_.pop();
   }
 }
 
 void GLES2Implementation::GenSharedIdsCHROMIUM(
   GLuint namespace_id, GLuint id_offset, GLsizei n, GLuint* ids) {
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenSharedIdsCHROMIUM("
-      << namespace_id << ", " << id_offset << ", " << n << ", " <<
-      static_cast<void*>(ids) << ")");
   TRACE_EVENT0("gpu", "GLES2::GenSharedIdsCHROMIUM");
   GLsizei num = n;
   GLuint* dst = ids;
   while (num) {
     ScopedTransferBufferArray<GLint> id_buffer(num, helper_, transfer_buffer_);
     if (!id_buffer.valid()) {
       return;
     }
     helper_->GenSharedIdsCHROMIUM(
         namespace_id, id_offset, id_buffer.num_elements(),
         id_buffer.shm_id(), id_buffer.offset());
     WaitForCmd();
     memcpy(dst, id_buffer.address(), sizeof(*dst) * id_buffer.num_elements());
     num -= id_buffer.num_elements();
     dst += id_buffer.num_elements();
   }
-  GPU_CLIENT_LOG_CODE_BLOCK({
-    for (GLsizei i = 0; i < n; ++i) {
-      GPU_CLIENT_LOG("  " << i << ": " << namespace_id << ", " << ids[i]);
-    }
-  });
 }
 
 void GLES2Implementation::DeleteSharedIdsCHROMIUM(
     GLuint namespace_id, GLsizei n, const GLuint* ids) {
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDeleteSharedIdsCHROMIUM("
-      << namespace_id << ", " << n << ", "
-      << static_cast<const void*>(ids) << ")");
-  GPU_CLIENT_LOG_CODE_BLOCK({
-    for (GLsizei i = 0; i < n; ++i) {
-      GPU_CLIENT_LOG("  " << i << ": " << namespace_id << ", "  << ids[i]);
-    }
-  });
   TRACE_EVENT0("gpu", "GLES2::DeleteSharedIdsCHROMIUM");
   while (n) {
     ScopedTransferBufferArray<GLint> id_buffer(n, helper_, transfer_buffer_);
     if (!id_buffer.valid()) {
       return;
     }
     memcpy(id_buffer.address(), ids, sizeof(*ids) * id_buffer.num_elements());
     helper_->DeleteSharedIdsCHROMIUM(
         namespace_id, id_buffer.num_elements(),
         id_buffer.shm_id(), id_buffer.offset());
     WaitForCmd();
     n -= id_buffer.num_elements();
     ids += id_buffer.num_elements();
   }
 }
 
 void GLES2Implementation::RegisterSharedIdsCHROMIUM(
     GLuint namespace_id, GLsizei n, const GLuint* ids) {
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glRegisterSharedIdsCHROMIUM("
-     << namespace_id << ", " << n << ", "
-     << static_cast<const void*>(ids) << ")");
-  GPU_CLIENT_LOG_CODE_BLOCK({
-    for (GLsizei i = 0; i < n; ++i) {
-      GPU_CLIENT_LOG("  " << i << ": "  << namespace_id << ", " << ids[i]);
-    }
-  });
   TRACE_EVENT0("gpu", "GLES2::RegisterSharedIdsCHROMIUM");
   while (n) {
     ScopedTransferBufferArray<GLint> id_buffer(n, helper_, transfer_buffer_);
     if (!id_buffer.valid()) {
       return;
     }
     memcpy(id_buffer.address(), ids, sizeof(*ids) * id_buffer.num_elements());
     helper_->RegisterSharedIdsCHROMIUM(
         namespace_id, id_buffer.num_elements(),
         id_buffer.shm_id(), id_buffer.offset());
     WaitForCmd();
     n -= id_buffer.num_elements();
     ids += id_buffer.num_elements();
   }
 }
 
 void GLES2Implementation::BindAttribLocation(
   GLuint program, GLuint index, const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindAttribLocation("
-      << program << ", " << index << ", " << name << ")");
   SetBucketAsString(kResultBucketId, name);
   helper_->BindAttribLocationBucket(program, index, kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
   CheckGLError();
 }
 
 void GLES2Implementation::BindUniformLocationCHROMIUM(
   GLuint program, GLint location, const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindUniformLocationCHROMIUM("
-      << program << ", " << location << ", " << name << ")");
   SetBucketAsString(kResultBucketId, name);
   helper_->BindUniformLocationCHROMIUMBucket(
       program, location, kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
   CheckGLError();
 }
 
 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 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());
   }
-  GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < num_results; ++i) {
-      GPU_CLIENT_LOG("  " << i << ": " << ptr[i]);
-    }
-  });
   CheckGLError();
 }
 
 bool GLES2Implementation::DeleteProgramHelper(GLuint program) {
   if (!GetIdHandler(id_namespaces::kProgramsAndShaders)->FreeIds(
       this, 1, &program, &GLES2Implementation::DeleteProgramStub)) {
     SetGLError(
         GL_INVALID_VALUE,
         "glDeleteProgram", "id not created by this context.");
     return false;
@@ skipping 42 matching lines @@
   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 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);
   return *result;
 }
 
 GLint GLES2Implementation::GetUniformLocation(
     GLuint program, const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetUniformLocation(" << program
-      << ", " << name << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformLocation");
   GLint loc = share_group_->program_info_manager()->GetUniformLocation(
       this, program, name);
-  GPU_CLIENT_LOG("returned " << loc);
   CheckGLError();
   return loc;
 }
 
 void GLES2Implementation::UseProgram(GLuint program) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUseProgram(" << program << ")");
   if (current_program_ != program) {
     current_program_ = program;
     helper_->UseProgram(program);
   }
   CheckGLError();
 }
 
 bool GLES2Implementation::GetProgramivHelper(
     GLuint program, GLenum pname, GLint* params) {
   bool got_value = share_group_->program_info_manager()->GetProgramiv(
       this, program, pname, params);
-  GPU_CLIENT_LOG_CODE_BLOCK({
-    if (got_value) {
-      GPU_CLIENT_LOG("  0: " << *params);
-    }
-  });
   return got_value;
 }
 
 void GLES2Implementation::LinkProgram(GLuint program) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glLinkProgram(" << program << ")");
   helper_->LinkProgram(program);
   share_group_->program_info_manager()->CreateInfo(program);
   CheckGLError();
 }
 
 void GLES2Implementation::ShaderBinary(
     GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary,
     GLsizei length) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glShaderBinary(" << n << ", "
-      << static_cast<const void*>(shaders) << ", "
-      << GLES2Util::GetStringEnum(binaryformat) << ", "
-      << static_cast<const void*>(binary) << ", "
-      << length << ")");
   if (n < 0) {
     SetGLError(GL_INVALID_VALUE, "glShaderBinary", "n < 0.");
     return;
   }
   if (length < 0) {
     SetGLError(GL_INVALID_VALUE, "glShaderBinary", "length < 0.");
     return;
   }
   // TODO(gman): ShaderBinary should use buckets.
   unsigned int shader_id_size = n * sizeof(*shaders);
@@ skipping 13 matching lines @@
       buffer.offset(),
       binaryformat,
       buffer.shm_id(),
       buffer.offset() + shader_id_size,
       length);
   CheckGLError();
 }
 
 void GLES2Implementation::PixelStorei(GLenum pname, GLint param) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glPixelStorei("
-      << GLES2Util::GetStringPixelStore(pname) << ", "
-      << param << ")");
   switch (pname) {
     case GL_PACK_ALIGNMENT:
         pack_alignment_ = param;
         break;
     case GL_UNPACK_ALIGNMENT:
         unpack_alignment_ = param;
         break;
     case GL_UNPACK_ROW_LENGTH:
         unpack_row_length_ = param;
         return;
@@ skipping 15 matching lines @@
   }
   helper_->PixelStorei(pname, param);
   CheckGLError();
 }
 
 
 void GLES2Implementation::VertexAttribPointer(
     GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
     const void* ptr) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttribPointer("
-      << index << ", "
-      << size << ", "
-      << GLES2Util::GetStringVertexAttribType(type) << ", "
-      << GLES2Util::GetStringBool(normalized) << ", "
-      << stride << ", "
-      << static_cast<const void*>(ptr) << ")");
   // Record the info on the client side.
   if (!vertex_array_object_manager_->SetAttribPointer(
       bound_array_buffer_id_, index, size, type, normalized, stride, ptr)) {
     SetGLError(GL_INVALID_OPERATION, "glVertexAttribPointer",
                "client side arrays are not allowed in vertex array objects.");
     return;
   }
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   if (bound_array_buffer_id_ != 0) {
     // Only report NON client side buffers to the service.
     helper_->VertexAttribPointer(index, size, type, normalized, stride,
                                  ToGLuint(ptr));
   }
 #else  // !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   helper_->VertexAttribPointer(index, size, type, normalized, stride,
                                ToGLuint(ptr));
 #endif  // !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   CheckGLError();
 }
 
 void GLES2Implementation::VertexAttribDivisorANGLE(
     GLuint index, GLuint divisor) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttribDivisorANGLE("
-      << index << ", "
-      << divisor << ") ");
   // Record the info on the client side.
   vertex_array_object_manager_->SetAttribDivisor(index, divisor);
   helper_->VertexAttribDivisorANGLE(index, divisor);
   CheckGLError();
 }
 
 void GLES2Implementation::ShaderSource(
     GLuint shader, GLsizei count, const GLchar* const* source, const GLint* length) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glShaderSource("
-      << shader << ", " << count << ", "
-      << static_cast<const void*>(source) << ", "
-      << static_cast<const void*>(length) << ")");
-  GPU_CLIENT_LOG_CODE_BLOCK({
-    for (GLsizei ii = 0; ii < count; ++ii) {
-      if (source[ii]) {
-        if (length && length[ii] >= 0) {
-          std::string str(source[ii], length[ii]);
-          GPU_CLIENT_LOG("  " << ii << ": ---\n" << str << "\n---");
-        } else {
-          GPU_CLIENT_LOG("  " << ii << ": ---\n" << source[ii] << "\n---");
-        }
-      } else {
-        GPU_CLIENT_LOG("  " << ii << ": NULL");
-      }
-    }
-  });
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, "glShaderSource", "count < 0");
     return;
   }
   if (shader == 0) {
     SetGLError(GL_INVALID_VALUE, "glShaderSource", "shader == 0");
     return;
   }
 
   // Compute the total size.
@@ skipping 94 matching lines @@
 
   // Make the buffer with BufferData then send via BufferSubData
   helper_->BufferData(target, size, 0, 0, usage);
   BufferSubDataHelperImpl(target, 0, size, data, &buffer);
   CheckGLError();
 }
 
 void GLES2Implementation::BufferData(
     GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBufferData("
-      << GLES2Util::GetStringBufferTarget(target) << ", "
-      << size << ", "
-      << static_cast<const void*>(data) << ", "
-      << GLES2Util::GetStringBufferUsage(usage) << ")");
   BufferDataHelper(target, size, data, usage);
   CheckGLError();
 }
 
 void GLES2Implementation::BufferSubDataHelper(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
   if (size == 0) {
     return;
   }
 
@@ skipping 49 matching lines @@
     offset += buffer->size();
     source += buffer->size();
     size -= buffer->size();
     buffer->Release();
   }
 }
 
 void GLES2Implementation::BufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBufferSubData("
-      << GLES2Util::GetStringBufferTarget(target) << ", "
-      << offset << ", " << size << ", "
-      << static_cast<const void*>(data) << ")");
   BufferSubDataHelper(target, offset, size, data);
   CheckGLError();
 }
 
 bool GLES2Implementation::GetBoundPixelTransferBuffer(
     GLenum target,
     const char* function_name,
     GLuint* buffer_id) {
   *buffer_id = 0;
 
@@ skipping 34 matching lines @@
     SetGLError(GL_INVALID_VALUE, function_name, "unpack size to large");
     return NULL;
   }
   return buffer;
 }
 
 void GLES2Implementation::CompressedTexImage2D(
     GLenum target, GLint level, GLenum internalformat, GLsizei width,
     GLsizei height, GLint border, GLsizei image_size, const void* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCompressedTexImage2D("
-      << GLES2Util::GetStringTextureTarget(target) << ", "
-      << level << ", "
-      << GLES2Util::GetStringCompressedTextureFormat(internalformat) << ", "
-      << width << ", " << height << ", " << border << ", "
-      << image_size << ", "
-      << static_cast<const void*>(data) << ")");
   if (width < 0 || height < 0 || level < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexImage2D", "dimension < 0");
     return;
   }
   if (height == 0 || width == 0) {
     return;
   }
   // If there's a pixel unpack buffer bound use it when issuing
   // CompressedTexImage2D.
   if (bound_pixel_unpack_transfer_buffer_id_) {
@@ skipping 16 matching lines @@
   // and we don't have to wait for the result so from the client's perspective
   // it's cheap.
   helper_->SetBucketSize(kResultBucketId, 0);
   CheckGLError();
 }
 
 void GLES2Implementation::CompressedTexSubImage2D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLsizei image_size, const void* data) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCompressedTexSubImage2D("
-      << GLES2Util::GetStringTextureTarget(target) << ", "
-      << level << ", "
-      << xoffset << ", " << yoffset << ", "
-      << width << ", " << height << ", "
-      << GLES2Util::GetStringCompressedTextureFormat(format) << ", "
-      << image_size << ", "
-      << static_cast<const void*>(data) << ")");
   if (width < 0 || height < 0 || level < 0) {
     SetGLError(GL_INVALID_VALUE, "glCompressedTexSubImage2D", "dimension < 0");
     return;
   }
   // If there's a pixel unpack buffer bound use it when issuing
   // CompressedTexSubImage2D.
   if (bound_pixel_unpack_transfer_buffer_id_) {
     GLuint offset = ToGLuint(data);
     BufferTracker::Buffer* buffer = GetBoundPixelUnpackTransferBufferIfValid(
         bound_pixel_unpack_transfer_buffer_id_,
@@ skipping 50 matching lines @@
   }
 }
 
 }  // anonymous namespace
 
 void GLES2Implementation::TexImage2D(
     GLenum target, GLint level, GLint internalformat, GLsizei width,
     GLsizei height, GLint border, GLenum format, GLenum type,
     const void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage2D("
-      << GLES2Util::GetStringTextureTarget(target) << ", "
-      << level << ", "
-      << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
-      << width << ", " << height << ", " << border << ", "
-      << GLES2Util::GetStringTextureFormat(format) << ", "
-      << GLES2Util::GetStringPixelType(type) << ", "
-      << static_cast<const void*>(pixels) << ")");
   if (level < 0 || height < 0 || width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexImage2D", "dimension < 0");
     return;
   }
   uint32 size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
           width, height, format, type, unpack_alignment_, &size,
           &unpadded_row_size, &padded_row_size)) {
@@ skipping 73 matching lines @@
   TexSubImage2DImpl(
       target, level, 0, 0, width, height, format, type, unpadded_row_size,
       pixels, src_padded_row_size, GL_TRUE, &buffer, padded_row_size);
   CheckGLError();
 }
 
 void GLES2Implementation::TexSubImage2D(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLenum type, const void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexSubImage2D("
-      << GLES2Util::GetStringTextureTarget(target) << ", "
-      << level << ", "
-      << xoffset << ", " << yoffset << ", "
-      << width << ", " << height << ", "
-      << GLES2Util::GetStringTextureFormat(format) << ", "
-      << GLES2Util::GetStringPixelType(type) << ", "
-      << static_cast<const void*>(pixels) << ")");
 
   if (level < 0 || height < 0 || width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "dimension < 0");
     return;
   }
   if (height == 0 || width == 0) {
     return;
   }
 
   uint32 temp_size;
@@ skipping 141 matching lines @@
       }
     }
   }
   return result->success != 0;
 }
 
 void GLES2Implementation::GetActiveAttrib(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetActiveAttrib("
-      << program << ", " << index << ", " << bufsize << ", "
-      << static_cast<const void*>(length) << ", "
-      << static_cast<const void*>(size) << ", "
-      << static_cast<const void*>(type) << ", "
-      << static_cast<const void*>(name) << ", ");
   if (bufsize < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetActiveAttrib", "bufsize < 0");
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetActiveAttrib");
-  bool success = share_group_->program_info_manager()->GetActiveAttrib(
-        this, program, index, bufsize, length, size, type, name);
-  if (success) {
-    if (size) {
-      GPU_CLIENT_LOG("  size: " << *size);
-    }
-    if (type) {
-      GPU_CLIENT_LOG("  type: " << GLES2Util::GetStringEnum(*type));
-    }
-    if (name) {
-      GPU_CLIENT_LOG("  name: " << name);
-    }
-  }
+  share_group_->program_info_manager()->GetActiveAttrib(
+      this, program, index, bufsize, length, size, type, name);
   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 cmds::GetActiveUniform::Result Result;
   Result* result = GetResultAs<Result*>();
@@ skipping 27 matching lines @@
       }
     }
   }
   return result->success != 0;
 }
 
 void GLES2Implementation::GetActiveUniform(
     GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size,
     GLenum* type, char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetActiveUniform("
-      << program << ", " << index << ", " << bufsize << ", "
-      << static_cast<const void*>(length) << ", "
-      << static_cast<const void*>(size) << ", "
-      << static_cast<const void*>(type) << ", "
-      << static_cast<const void*>(name) << ", ");
   if (bufsize < 0) {
     SetGLError(GL_INVALID_VALUE, "glGetActiveUniform", "bufsize < 0");
     return;
   }
   TRACE_EVENT0("gpu", "GLES2::GetActiveUniform");
-  bool success = share_group_->program_info_manager()->GetActiveUniform(
+  share_group_->program_info_manager()->GetActiveUniform(
       this, program, index, bufsize, length, size, type, name);
-  if (success) {
-    if (size) {
-      GPU_CLIENT_LOG("  size: " << *size);
-    }
-    if (type) {
-      GPU_CLIENT_LOG("  type: " << GLES2Util::GetStringEnum(*type));
-    }
-    if (name) {
-      GPU_CLIENT_LOG("  name: " << name);
-    }
-  }
   CheckGLError();
 }
 
 void GLES2Implementation::GetAttachedShaders(
     GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) {
   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 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),
     size);
   int32 token = helper_->InsertToken();
   WaitForCmd();
   if (count) {
     *count = result->GetNumResults();
   }
   result->CopyResult(shaders);
-  GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int32 i = 0; i < result->GetNumResults(); ++i) {
-      GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
-    }
-  });
   transfer_buffer_->FreePendingToken(result, token);
   CheckGLError();
 }
 
 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 cmds::GetShaderPrecisionFormat::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
 
   GLStaticState::ShaderPrecisionKey key(shadertype, precisiontype);
   GLStaticState::ShaderPrecisionMap::iterator i =
       static_state_.shader_precisions.find(key);
   if (i != static_state_.shader_precisions.end()) {
     *result = i->second;
   } else {
     result->success = false;
     helper_->GetShaderPrecisionFormat(
         shadertype, precisiontype, GetResultShmId(), GetResultShmOffset());
     WaitForCmd();
     if (result->success)
       static_state_.shader_precisions[key] = *result;
   }
 
   if (result->success) {
     if (range) {
       range[0] = result->min_range;
       range[1] = result->max_range;
-      GPU_CLIENT_LOG("  min_range: " << range[0]);
-      GPU_CLIENT_LOG("  min_range: " << range[1]);
     }
     if (precision) {
       precision[0] = result->precision;
-      GPU_CLIENT_LOG("  min_range: " << precision[0]);
     }
   }
   CheckGLError();
 }
 
 const GLubyte* GLES2Implementation::GetStringHelper(GLenum name) {
   const char* result = NULL;
   // Clears the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetString(name, kResultBucketId);
@@ skipping 36 matching lines @@
           string_set.insert(str);
       DCHECK(insert_result.second);
       result = insert_result.first->c_str();
     }
   }
   return reinterpret_cast<const GLubyte*>(result);
 }
 
 const GLubyte* GLES2Implementation::GetString(GLenum name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetString("
-      << GLES2Util::GetStringStringType(name) << ")");
   TRACE_EVENT0("gpu", "GLES2::GetString");
   const GLubyte* result = GetStringHelper(name);
-  GPU_CLIENT_LOG("  returned " << reinterpret_cast<const char*>(result));
   CheckGLError();
   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 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 cmds::GetUniformiv::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
   result->SetNumResults(0);
   helper_->GetUniformiv(
       program, location, GetResultShmId(), GetResultShmOffset());
   WaitForCmd();
   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,
     GLenum type, void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glReadPixels("
-      << xoffset << ", " << yoffset << ", "
-      << width << ", " << height << ", "
-      << GLES2Util::GetStringReadPixelFormat(format) << ", "
-      << GLES2Util::GetStringPixelType(type) << ", "
-      << static_cast<const void*>(pixels) << ")");
   if (width < 0 || height < 0) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions < 0");
     return;
   }
   if (width == 0 || height == 0) {
     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
@@ skipping 84 matching lines @@
       return;
     }
     yoffset += num_rows;
     height -= num_rows;
   }
   CheckGLError();
 }
 
 void GLES2Implementation::ActiveTexture(GLenum texture) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glActiveTexture("
-      << GLES2Util::GetStringEnum(texture) << ")");
   GLuint texture_index = texture - GL_TEXTURE0;
   if (texture_index >= static_cast<GLuint>(
       static_state_.int_state.max_combined_texture_image_units)) {
     SetGLErrorInvalidEnum(
         "glActiveTexture", texture, "texture");
     return;
   }
 
   active_texture_unit_ = texture_index;
   helper_->ActiveTexture(texture);
@@ skipping 300 matching lines @@
   helper_->DeleteVertexArraysOESImmediate(n, arrays);
 }
 
 void GLES2Implementation::DeleteTexturesStub(
     GLsizei n, const GLuint* textures) {
   helper_->DeleteTexturesImmediate(n, textures);
 }
 
 void GLES2Implementation::DisableVertexAttribArray(GLuint index) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG(
-      "[" << GetLogPrefix() << "] glDisableVertexAttribArray(" << index << ")");
   vertex_array_object_manager_->SetAttribEnable(index, false);
   helper_->DisableVertexAttribArray(index);
   CheckGLError();
 }
 
 void GLES2Implementation::EnableVertexAttribArray(GLuint index) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glEnableVertexAttribArray("
-      << index << ")");
   vertex_array_object_manager_->SetAttribEnable(index, true);
   helper_->EnableVertexAttribArray(index);
   CheckGLError();
 }
 
 void GLES2Implementation::DrawArrays(GLenum mode, GLint first, GLsizei count) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDrawArrays("
-      << GLES2Util::GetStringDrawMode(mode) << ", "
-      << first << ", " << count << ")");
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawArrays", "count < 0");
     return;
   }
   bool simulated = false;
   if (!vertex_array_object_manager_->SetupSimulatedClientSideBuffers(
       "glDrawArrays", this, helper_, first + count, 0, &simulated)) {
     return;
   }
   helper_->DrawArrays(mode, first, count);
   RestoreArrayBuffer(simulated);
   CheckGLError();
 }
 
 void GLES2Implementation::GetVertexAttribfv(
     GLuint index, GLenum pname, GLfloat* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  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 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({
-    for (int32 i = 0; i < result->GetNumResults(); ++i) {
-      GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
-    }
-  });
   CheckGLError();
 }
 
 void GLES2Implementation::GetVertexAttribiv(
     GLuint index, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  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 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 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);
-  GPU_CLIENT_LOG("   returned " << GLES2Util::GetStringBool(*result));
   return *result;
 }
 
 void* GLES2Implementation::MapBufferSubDataCHROMIUM(
     GLuint target, GLintptr offset, GLsizeiptr size, GLenum access) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glMapBufferSubDataCHROMIUM("
-      << target << ", " << offset << ", " << size << ", "
-      << GLES2Util::GetStringEnum(access) << ")");
   // NOTE: target is NOT checked because the service will check it
   // and we don't know what targets are valid.
   if (access != GL_WRITE_ONLY) {
     SetGLErrorInvalidEnum(
         "glMapBufferSubDataCHROMIUM", access, "access");
     return NULL;
   }
   if (offset < 0 || size < 0) {
     SetGLError(GL_INVALID_VALUE, "glMapBufferSubDataCHROMIUM", "bad range");
     return NULL;
   }
   int32 shm_id;
   unsigned int shm_offset;
   void* mem = mapped_memory_->Alloc(size, &shm_id, &shm_offset);
   if (!mem) {
     SetGLError(GL_OUT_OF_MEMORY, "glMapBufferSubDataCHROMIUM", "out of memory");
     return NULL;
   }
 
   std::pair<MappedBufferMap::iterator, bool> result =
      mapped_buffers_.insert(std::make_pair(
          mem,
          MappedBuffer(
              access, shm_id, mem, shm_offset, target, offset, size)));
   DCHECK(result.second);
-  GPU_CLIENT_LOG("  returned " << mem);
   return mem;
 }
 
 void GLES2Implementation::UnmapBufferSubDataCHROMIUM(const void* mem) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG(
-      "[" << GetLogPrefix() << "] glUnmapBufferSubDataCHROMIUM(" << mem << ")");
   MappedBufferMap::iterator it = mapped_buffers_.find(mem);
   if (it == mapped_buffers_.end()) {
     SetGLError(
         GL_INVALID_VALUE, "UnmapBufferSubDataCHROMIUM", "buffer not mapped");
     return;
   }
   const MappedBuffer& mb = it->second;
   helper_->BufferSubData(
       mb.target, mb.offset, mb.size, mb.shm_id, mb.shm_offset);
   mapped_memory_->FreePendingToken(mb.shm_memory, helper_->InsertToken());
   mapped_buffers_.erase(it);
   CheckGLError();
 }
 
 void* GLES2Implementation::MapTexSubImage2DCHROMIUM(
      GLenum target,
      GLint level,
      GLint xoffset,
      GLint yoffset,
      GLsizei width,
      GLsizei height,
      GLenum format,
      GLenum type,
      GLenum access) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glMapTexSubImage2DCHROMIUM("
-      << target << ", " << level << ", "
-      << xoffset << ", " << yoffset << ", "
-      << width << ", " << height << ", "
-      << GLES2Util::GetStringTextureFormat(format) << ", "
-      << GLES2Util::GetStringPixelType(type) << ", "
-      << GLES2Util::GetStringEnum(access) << ")");
   if (access != GL_WRITE_ONLY) {
     SetGLErrorInvalidEnum(
         "glMapTexSubImage2DCHROMIUM", access, "access");
     return NULL;
   }
   // NOTE: target is NOT checked because the service will check it
   // and we don't know what targets are valid.
   if (level < 0 || xoffset < 0 || yoffset < 0 || width < 0 || height < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glMapTexSubImage2DCHROMIUM", "bad dimensions");
@@ skipping 14 matching lines @@
     return NULL;
   }
 
   std::pair<MappedTextureMap::iterator, bool> result =
      mapped_textures_.insert(std::make_pair(
          mem,
          MappedTexture(
              access, shm_id, mem, shm_offset,
              target, level, xoffset, yoffset, width, height, format, type)));
   DCHECK(result.second);
-  GPU_CLIENT_LOG("  returned " << mem);
   return mem;
 }
 
 void GLES2Implementation::UnmapTexSubImage2DCHROMIUM(const void* mem) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG(
-      "[" << GetLogPrefix() << "] glUnmapTexSubImage2DCHROMIUM(" << mem << ")");
   MappedTextureMap::iterator it = mapped_textures_.find(mem);
   if (it == mapped_textures_.end()) {
     SetGLError(
         GL_INVALID_VALUE, "UnmapTexSubImage2DCHROMIUM", "texture not mapped");
     return;
   }
   const MappedTexture& mt = it->second;
   helper_->TexSubImage2D(
       mt.target, mt.level, mt.xoffset, mt.yoffset, mt.width, mt.height,
       mt.format, mt.type, mt.shm_id, mt.shm_offset, GL_FALSE);
   mapped_memory_->FreePendingToken(mt.shm_memory, helper_->InsertToken());
   mapped_textures_.erase(it);
   CheckGLError();
 }
 
 void GLES2Implementation::ResizeCHROMIUM(GLuint width, GLuint height,
                                          float scale_factor) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glResizeCHROMIUM("
-                 << width << ", " << height << ", " << scale_factor << ")");
   helper_->ResizeCHROMIUM(width, height, scale_factor);
   CheckGLError();
 }
 
 const GLchar* GLES2Implementation::GetRequestableExtensionsCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix()
-      << "] glGetRequestableExtensionsCHROMIUM()");
   TRACE_EVENT0("gpu",
                "GLES2Implementation::GetRequestableExtensionsCHROMIUM()");
   const char* result = NULL;
   // Clear the bucket so if the command fails nothing will be in it.
   helper_->SetBucketSize(kResultBucketId, 0);
   helper_->GetRequestableExtensionsCHROMIUM(kResultBucketId);
   std::string str;
   if (GetBucketAsString(kResultBucketId, &str)) {
     // The set of requestable extensions shrinks as we enable
     // them. Because we don't know when the client will stop referring
     // to a previous one it queries (see GetString) we need to cache
     // the unique results.
     std::set<std::string>::const_iterator sit =
         requestable_extensions_set_.find(str);
     if (sit != requestable_extensions_set_.end()) {
       result = sit->c_str();
     } else {
       std::pair<std::set<std::string>::const_iterator, bool> insert_result =
           requestable_extensions_set_.insert(str);
       DCHECK(insert_result.second);
       result = insert_result.first->c_str();
     }
   }
-  GPU_CLIENT_LOG("  returned " << result);
   return reinterpret_cast<const GLchar*>(result);
 }
 
 // TODO(gman): Remove this command. It's here for WebGL but is incompatible
 // with VirtualGL contexts.
 void GLES2Implementation::RequestExtensionCHROMIUM(const char* extension) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glRequestExtensionCHROMIUM("
-                 << extension << ")");
   SetBucketAsCString(kResultBucketId, extension);
   helper_->RequestExtensionCHROMIUM(kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
 
   struct ExtensionCheck {
     const char* extension;
     ExtensionStatus* status;
   };
   const ExtensionCheck checks[] = {
     {
@@ skipping 10 matching lines @@
     const ExtensionCheck& check = checks[ii];
     if (*check.status == kUnavailableExtensionStatus &&
         !strcmp(extension, check.extension)) {
       *check.status = kUnknownExtensionStatus;
     }
   }
 }
 
 void GLES2Implementation::RateLimitOffscreenContextCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glRateLimitOffscreenCHROMIUM()");
   // Wait if this would add too many rate limit tokens.
   if (rate_limit_tokens_.size() == kMaxSwapBuffers) {
     helper_->WaitForToken(rate_limit_tokens_.front());
     rate_limit_tokens_.pop();
   }
   rate_limit_tokens_.push(helper_->InsertToken());
 }
 
 void GLES2Implementation::GetMultipleIntegervCHROMIUM(
     const GLenum* pnames, GLuint count, GLint* results, GLsizeiptr size) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetMultipleIntegervCHROMIUM("
-                 << static_cast<const void*>(pnames) << ", "
-                 << count << ", " << results << ", "
-                 << size << ")");
-  GPU_CLIENT_LOG_CODE_BLOCK({
-    for (GLuint i = 0; i < count; ++i) {
-      GPU_CLIENT_LOG(
-          "  " << i << ": " << GLES2Util::GetStringGLState(pnames[i]));
-    }
-  });
 
   GetMultipleIntegervState state(pnames, count, results, size);
   if (!GetMultipleIntegervSetup(&state)) {
     return;
   }
   state.buffer = transfer_buffer_->Alloc(state.transfer_buffer_size_needed);
   if (!state.buffer) {
     SetGLError(GL_OUT_OF_MEMORY, "glGetMultipleIntegervCHROMIUM",
                "Transfer buffer allocation failed.");
     return;
   }
   GetMultipleIntegervRequest(&state);
   WaitForCmd();
   GetMultipleIntegervOnCompleted(&state);
 
-  GPU_CLIENT_LOG("  returned");
-  GPU_CLIENT_LOG_CODE_BLOCK({
-    for (int i = 0; i < state.num_results; ++i) {
-      GPU_CLIENT_LOG("  " << i << ": " << (results[i]));
-    }
-  });
-
   // TODO(gman): We should be able to free without a token.
   transfer_buffer_->FreePendingToken(state.buffer, helper_->InsertToken());
   CheckGLError();
 }
 
 bool GLES2Implementation::GetMultipleIntegervSetup(
     GetMultipleIntegervState* state) {
   state->num_results = 0;
   for (GLuint ii = 0; ii < state->pnames_count; ++ii) {
     int num = util_.GLGetNumValuesReturned(state->pnames[ii]);
@@ skipping 115 matching lines @@
   if (static_cast<size_t>(bufsize) < result.size()) {
     SetGLError(GL_INVALID_OPERATION,
                "glProgramInfoCHROMIUM", "bufsize is too small for result.");
     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 cmds::CreateStreamTextureCHROMIUM::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return GL_ZERO;
   }
   *result = GL_ZERO;
 
   helper_->CreateStreamTextureCHROMIUM(texture,
                                        GetResultShmId(),
                                        GetResultShmOffset());
   WaitForCmd();
   GLuint result_value = *result;
   CheckGLError();
   return result_value;
 }
 
 void GLES2Implementation::DestroyStreamTextureCHROMIUM(GLuint texture) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] DestroyStreamTextureCHROMIUM("
-      << texture << ")");
   TRACE_EVENT0("gpu", "GLES2::DestroyStreamTextureCHROMIUM");
   helper_->DestroyStreamTextureCHROMIUM(texture);
   CheckGLError();
 }
 
 void GLES2Implementation::PostSubBufferCHROMIUM(
     GLint x, GLint y, GLint width, GLint height) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] PostSubBufferCHROMIUM("
-      << x << ", " << y << ", " << width << ", " << height << ")");
   TRACE_EVENT2("gpu", "GLES2::PostSubBufferCHROMIUM",
                "width", width, "height", height);
 
   // Same flow control as GLES2Implementation::SwapBuffers (see comments there).
   swap_buffers_tokens_.push(helper_->InsertToken());
   helper_->PostSubBufferCHROMIUM(x, y, width, height);
   helper_->CommandBufferHelper::Flush();
   if (swap_buffers_tokens_.size() > kMaxSwapBuffers + 1) {
     helper_->WaitForToken(swap_buffers_tokens_.front());
     swap_buffers_tokens_.pop();
@@ skipping 17 matching lines @@
   helper_->DeleteQueriesEXTImmediate(n, queries);
 }
 
 // TODO(gman): Remove this. Queries are not shared resources.
 void GLES2Implementation::DeleteQueriesStub(
     GLsizei /* n */, const GLuint* /* queries */) {
 }
 
 GLboolean GLES2Implementation::IsQueryEXT(GLuint id) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] IsQueryEXT(" << id << ")");
 
   // TODO(gman): To be spec compliant IDs from other contexts sharing
   // resources need to return true here even though you can't share
   // queries across contexts?
   return query_tracker_->GetQuery(id) != NULL;
 }
 
 void GLES2Implementation::BeginQueryEXT(GLenum target, GLuint id) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] BeginQueryEXT("
-                 << GLES2Util::GetStringQueryTarget(target)
-                 << ", " << id << ")");
 
   // if any outstanding queries INV_OP
   if (current_query_) {
     SetGLError(
         GL_INVALID_OPERATION, "glBeginQueryEXT", "query already in progress");
     return;
   }
 
   // id = 0 INV_OP
   if (id == 0) {
@@ skipping 18 matching lines @@
   }
 
   current_query_ = query;
 
   query->Begin(this);
   CheckGLError();
 }
 
 void GLES2Implementation::EndQueryEXT(GLenum target) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] EndQueryEXT("
-                 << GLES2Util::GetStringQueryTarget(target) << ")");
   // Don't do anything if the context is lost.
   if (helper_->IsContextLost()) {
     return;
   }
 
   if (!current_query_) {
     SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT", "no active query");
     return;
   }
 
   if (current_query_->target() != target) {
     SetGLError(GL_INVALID_OPERATION,
                "glEndQueryEXT", "target does not match active query");
     return;
   }
 
   current_query_->End(this);
   current_query_ = NULL;
   CheckGLError();
 }
 
 void GLES2Implementation::GetQueryivEXT(
     GLenum target, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] GetQueryivEXT("
-                 << GLES2Util::GetStringQueryTarget(target) << ", "
-                 << GLES2Util::GetStringQueryParameter(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
 
   if (pname != GL_CURRENT_QUERY_EXT) {
     SetGLErrorInvalidEnum("glGetQueryivEXT", pname, "pname");
     return;
   }
   *params = (current_query_ && current_query_->target() == target) ?
       current_query_->id() : 0;
-  GPU_CLIENT_LOG("  " << *params);
   CheckGLError();
 }
 
 void GLES2Implementation::GetQueryObjectuivEXT(
     GLuint id, GLenum pname, GLuint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] GetQueryivEXT(" << id << ", "
-                 << GLES2Util::GetStringQueryObjectParameter(pname) << ", "
-                 << static_cast<const void*>(params) << ")");
 
   QueryTracker::Query* query = query_tracker_->GetQuery(id);
   if (!query) {
     SetGLError(GL_INVALID_OPERATION, "glQueryObjectuivEXT", "unknown query id");
     return;
   }
 
   if (query == current_query_) {
     SetGLError(
         GL_INVALID_OPERATION,
@@ skipping 20 matching lines @@
       }
       *params = query->GetResult();
       break;
     case GL_QUERY_RESULT_AVAILABLE_EXT:
       *params = query->CheckResultsAvailable(helper_);
       break;
     default:
       SetGLErrorInvalidEnum("glQueryObjectuivEXT", pname, "pname");
       break;
   }
-  GPU_CLIENT_LOG("  " << *params);
   CheckGLError();
 }
 
 void GLES2Implementation::DrawArraysInstancedANGLE(
     GLenum mode, GLint first, GLsizei count, GLsizei primcount) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDrawArraysInstancedANGLE("
-      << GLES2Util::GetStringDrawMode(mode) << ", "
-      << first << ", " << count << ", " << primcount << ")");
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawArraysInstancedANGLE", "count < 0");
     return;
   }
   if (primcount < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawArraysInstancedANGLE", "primcount < 0");
     return;
   }
   if (primcount == 0) {
     return;
   }
   bool simulated = false;
   if (!vertex_array_object_manager_->SetupSimulatedClientSideBuffers(
       "glDrawArraysInstancedANGLE", this, helper_, first + count, primcount,
       &simulated)) {
     return;
   }
   helper_->DrawArraysInstancedANGLE(mode, first, count, primcount);
   RestoreArrayBuffer(simulated);
   CheckGLError();
 }
 
 void GLES2Implementation::DrawElementsInstancedANGLE(
     GLenum mode, GLsizei count, GLenum type, const void* indices,
     GLsizei primcount) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDrawElementsInstancedANGLE("
-      << GLES2Util::GetStringDrawMode(mode) << ", "
-      << count << ", "
-      << GLES2Util::GetStringIndexType(type) << ", "
-      << static_cast<const void*>(indices) << ", "
-      << primcount << ")");
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE,
                "glDrawElementsInstancedANGLE", "count less than 0.");
     return;
   }
   if (count == 0) {
     return;
   }
   if (primcount < 0) {
     SetGLError(GL_INVALID_VALUE,
@@ skipping 11 matching lines @@
     return;
   }
   helper_->DrawElementsInstancedANGLE(mode, count, type, offset, primcount);
   RestoreElementAndArrayBuffers(simulated);
   CheckGLError();
 }
 
 void GLES2Implementation::GenMailboxCHROMIUM(
     GLbyte* mailbox) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenMailboxCHROMIUM("
-      << static_cast<const void*>(mailbox) << ")");
   TRACE_EVENT0("gpu", "GLES2::GenMailboxCHROMIUM");
 
   std::vector<gpu::Mailbox> names;
   if (!gpu_control_->GenerateMailboxNames(1, &names)) {
     SetGLError(GL_OUT_OF_MEMORY, "glGenMailboxCHROMIUM", "Generate failed.");
     return;
   }
   memcpy(mailbox, names[0].name, GL_MAILBOX_SIZE_CHROMIUM);
 }
 
 void GLES2Implementation::PushGroupMarkerEXT(
     GLsizei length, const GLchar* marker) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glPushGroupMarkerEXT("
-      << length << ", " << marker << ")");
   if (!marker) {
     marker = "";
   }
   SetBucketAsString(
       kResultBucketId,
       (length ? std::string(marker, length) : std::string(marker)));
   helper_->PushGroupMarkerEXT(kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
   debug_marker_manager_.PushGroup(
       length ? std::string(marker, length) : std::string(marker));
 }
 
 void GLES2Implementation::InsertEventMarkerEXT(
     GLsizei length, const GLchar* marker) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glInsertEventMarkerEXT("
-      << length << ", " << marker << ")");
   if (!marker) {
     marker = "";
   }
   SetBucketAsString(
       kResultBucketId,
       (length ? std::string(marker, length) : std::string(marker)));
   helper_->InsertEventMarkerEXT(kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
   debug_marker_manager_.SetMarker(
       length ? std::string(marker, length) : std::string(marker));
 }
 
 void GLES2Implementation::PopGroupMarkerEXT() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glPopGroupMarkerEXT()");
   helper_->PopGroupMarkerEXT();
   debug_marker_manager_.PopGroup();
 }
 
 void GLES2Implementation::TraceBeginCHROMIUM(const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTraceBeginCHROMIUM("
-                 << name << ")");
   if (current_trace_name_.get()) {
     SetGLError(GL_INVALID_OPERATION, "glTraceBeginCHROMIUM",
                "trace already running");
     return;
   }
   TRACE_EVENT_COPY_ASYNC_BEGIN0("gpu", name, this);
   SetBucketAsCString(kResultBucketId, name);
   helper_->TraceBeginCHROMIUM(kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
   current_trace_name_.reset(new std::string(name));
 }
 
 void GLES2Implementation::TraceEndCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTraceEndCHROMIUM(" << ")");
   if (!current_trace_name_.get()) {
     SetGLError(GL_INVALID_OPERATION, "glTraceEndCHROMIUM",
                "missing begin trace");
     return;
   }
   helper_->TraceEndCHROMIUM();
   TRACE_EVENT_COPY_ASYNC_END0("gpu", current_trace_name_->c_str(), this);
   current_trace_name_.reset();
 }
 
 void* GLES2Implementation::MapBufferCHROMIUM(GLuint target, GLenum access) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glMapBufferCHROMIUM("
-      << target << ", " << GLES2Util::GetStringEnum(access) << ")");
   switch (target)  {
     case GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM:
       if (access != GL_READ_ONLY) {
         SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode");
         return NULL;
       }
       break;
     case GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM:
       if (access != GL_WRITE_ONLY) {
         SetGLError(GL_INVALID_ENUM, "glMapBufferCHROMIUM", "bad access mode");
@@ skipping 23 matching lines @@
   // TODO(hubbe): AsyncTex(Sub)Image2dCHROMIUM does not currently work
   // with this method of synchronization. Until this is fixed,
   // MapBufferCHROMIUM will not block even if the transfer is not ready
   // for these calls.
   if (buffer->transfer_ready_token()) {
     helper_->WaitForToken(buffer->transfer_ready_token());
     buffer->set_transfer_ready_token(0);
   }
   buffer->set_mapped(true);
 
-  GPU_CLIENT_LOG("  returned " << buffer->address());
   CheckGLError();
   return buffer->address();
 }
 
 GLboolean GLES2Implementation::UnmapBufferCHROMIUM(GLuint target) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG(
-      "[" << GetLogPrefix() << "] glUnmapBufferCHROMIUM(" << target << ")");
   GLuint buffer_id;
   if (!GetBoundPixelTransferBuffer(target, "glMapBufferCHROMIUM", &buffer_id)) {
     SetGLError(GL_INVALID_ENUM, "glUnmapBufferCHROMIUM", "invalid target");
   }
   if (!buffer_id) {
     return false;
   }
   BufferTracker::Buffer* buffer = buffer_tracker_->GetBuffer(buffer_id);
   if (!buffer) {
     SetGLError(GL_INVALID_OPERATION, "glUnmapBufferCHROMIUM", "invalid buffer");
     return false;
   }
   if (!buffer->mapped()) {
     SetGLError(GL_INVALID_OPERATION, "glUnmapBufferCHROMIUM", "not mapped");
     return false;
   }
   buffer->set_mapped(false);
   CheckGLError();
   return true;
 }
 
 void GLES2Implementation::AsyncTexImage2DCHROMIUM(
     GLenum target, GLint level, GLint internalformat, GLsizei width,
     GLsizei height, GLint border, GLenum format, GLenum type,
     const void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glTexImage2D("
-      << GLES2Util::GetStringTextureTarget(target) << ", "
-      << level << ", "
-      << GLES2Util::GetStringTextureInternalFormat(internalformat) << ", "
-      << width << ", " << height << ", " << border << ", "
-      << GLES2Util::GetStringTextureFormat(format) << ", "
-      << GLES2Util::GetStringPixelType(type) << ", "
-      << static_cast<const void*>(pixels) << ")");
   if (level < 0 || height < 0 || width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexImage2D", "dimension < 0");
     return;
   }
   uint32 size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
           width, height, format, type, unpack_alignment_, &size,
           &unpadded_row_size, &padded_row_size)) {
@@ skipping 21 matching lines @@
     helper_->AsyncTexImage2DCHROMIUM(
         target, level, internalformat, width, height, border, format, type,
         buffer->shm_id(), buffer->shm_offset() + offset);
   }
 }
 
 void GLES2Implementation::AsyncTexSubImage2DCHROMIUM(
     GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width,
     GLsizei height, GLenum format, GLenum type, const void* pixels) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glAsyncTexSubImage2DCHROMIUM("
-      << GLES2Util::GetStringTextureTarget(target) << ", "
-      << level << ", "
-      << xoffset << ", " << yoffset << ", "
-      << width << ", " << height << ", "
-      << GLES2Util::GetStringTextureFormat(format) << ", "
-      << GLES2Util::GetStringPixelType(type) << ", "
-      << static_cast<const void*>(pixels) << ")");
   if (level < 0 || height < 0 || width < 0) {
     SetGLError(
         GL_INVALID_VALUE, "glAsyncTexSubImage2DCHROMIUM", "dimension < 0");
     return;
   }
 
   uint32 size;
   uint32 unpadded_row_size;
   uint32 padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
@@ skipping 14 matching lines @@
       "glAsyncTexSubImage2DCHROMIUM", offset, size);
   if (buffer && buffer->shm_id() != -1) {
     helper_->AsyncTexSubImage2DCHROMIUM(
         target, level, xoffset, yoffset, width, height, format, type,
         buffer->shm_id(), buffer->shm_offset() + offset);
   }
 }
 
 void GLES2Implementation::WaitAsyncTexImage2DCHROMIUM(GLenum target) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glWaitAsyncTexImage2DCHROMIUM("
-      << GLES2Util::GetStringTextureTarget(target) << ")");
   helper_->WaitAsyncTexImage2DCHROMIUM(target);
   CheckGLError();
 }
 
 GLuint GLES2Implementation::InsertSyncPointCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glInsertSyncPointCHROMIUM");
   helper_->CommandBufferHelper::Flush();
   return gpu_control_->InsertSyncPoint();
 }
 
 GLuint GLES2Implementation::CreateImageCHROMIUMHelper(
     GLsizei width, GLsizei height, GLenum internalformat) {
   if (width <= 0) {
     SetGLError(GL_INVALID_VALUE, "glCreateImageCHROMIUM", "width <= 0");
     return 0;
   }
@@ skipping 12 matching lines @@
   if (buffer_id == 0) {
     SetGLError(GL_OUT_OF_MEMORY, "glCreateImageCHROMIUM", "out of GPU memory.");
     return 0;
   }
   return buffer_id;
 }
 
 GLuint GLES2Implementation::CreateImageCHROMIUM(
     GLsizei width, GLsizei height, GLenum internalformat) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glCreateImageCHROMIUM("
-      << width << ", "
-      << height << ", "
-      << GLES2Util::GetStringTextureInternalFormat(internalformat) << ")");
   GLuint image_id = CreateImageCHROMIUMHelper(width, height, internalformat);
   CheckGLError();
   return image_id;
 }
 
 void GLES2Implementation::DestroyImageCHROMIUMHelper(GLuint image_id) {
   gfx::GpuMemoryBuffer* gpu_buffer = gpu_memory_buffer_tracker_->GetBuffer(
       image_id);
   if (!gpu_buffer) {
     SetGLError(GL_INVALID_OPERATION, "glDestroyImageCHROMIUM", "invalid image");
     return;
   }
 
   // Flush the command stream to make sure all pending commands
   // that may refer to the image_id are executed on the service side.
   helper_->CommandBufferHelper::Flush();
   gpu_memory_buffer_tracker_->RemoveBuffer(image_id);
 }
 
 void GLES2Implementation::DestroyImageCHROMIUM(GLuint image_id) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDestroyImageCHROMIUM("
-      << image_id << ")");
   DestroyImageCHROMIUMHelper(image_id);
   CheckGLError();
 }
 
 void GLES2Implementation::UnmapImageCHROMIUMHelper(GLuint image_id) {
   gfx::GpuMemoryBuffer* gpu_buffer = gpu_memory_buffer_tracker_->GetBuffer(
       image_id);
   if (!gpu_buffer) {
     SetGLError(GL_INVALID_OPERATION, "glUnmapImageCHROMIUM", "invalid image");
     return;
   }
 
   if (!gpu_buffer->IsMapped()) {
     SetGLError(GL_INVALID_OPERATION, "glUnmapImageCHROMIUM", "not mapped");
     return;
   }
   gpu_buffer->Unmap();
 }
 
 void GLES2Implementation::UnmapImageCHROMIUM(GLuint image_id) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glUnmapImageCHROMIUM("
-       << image_id << ")");
-
   UnmapImageCHROMIUMHelper(image_id);
   CheckGLError();
 }
 
 void* GLES2Implementation::MapImageCHROMIUMHelper(GLuint image_id,
                                                   GLenum access) {
   gfx::GpuMemoryBuffer* gpu_buffer = gpu_memory_buffer_tracker_->GetBuffer(
       image_id);
   if (!gpu_buffer) {
     SetGLError(GL_INVALID_OPERATION, "glMapImageCHROMIUM", "invalid image");
@@ skipping 22 matching lines @@
   }
 
   void* mapped_buffer = NULL;
   gpu_buffer->Map(mode, &mapped_buffer);
   return mapped_buffer;
 }
 
 void* GLES2Implementation::MapImageCHROMIUM(
     GLuint image_id, GLenum access) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glMapImageCHROMIUM("
-      << image_id << ", "
-      << GLES2Util::GetStringEnum(access) << ")");
-
   void* mapped = MapImageCHROMIUMHelper(image_id, access);
   CheckGLError();
   return mapped;
 }
 
 void GLES2Implementation::GetImageParameterivCHROMIUMHelper(
     GLuint image_id, GLenum pname, GLint* params) {
   if (pname != GL_IMAGE_ROWBYTES_CHROMIUM) {
     SetGLError(GL_INVALID_ENUM, "glGetImageParameterivCHROMIUM",
                "invalid parameter");
     return;
   }
 
   gfx::GpuMemoryBuffer* gpu_buffer = gpu_memory_buffer_tracker_->GetBuffer(
       image_id);
   if (!gpu_buffer) {
     SetGLError(GL_INVALID_OPERATION, "glGetImageParameterivCHROMIUM",
                "invalid image");
     return;
   }
 
   *params = gpu_buffer->GetStride();
 }
 
 void GLES2Implementation::GetImageParameterivCHROMIUM(
     GLuint image_id, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_VALIDATE_DESTINATION_INITALIZATION(GLint, params);
-  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glImageParameterivCHROMIUM("
-      << image_id << ", "
-      << GLES2Util::GetStringBufferParameter(pname) << ", "
-      << static_cast<const void*>(params) << ")");
   GetImageParameterivCHROMIUMHelper(image_id, pname, params);
   CheckGLError();
 }
 
 // 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/client/gles2_implementation_impl_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu