Implement GL_EXT_debug_marker

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>
 #include <queue>
 #include <set>
+#include <stdio.h>
+#include <string.h>
 #include <GLES2/gl2ext.h>
 #include "../client/mapped_memory.h"
 #include "../client/program_info_manager.h"
 #include "../client/query_tracker.h"
 #include "../client/transfer_buffer.h"
 #include "../common/gles2_cmd_utils.h"
 #include "../common/trace_event.h"
 
 #if defined(__native_client__) && !defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 #define GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
@@ skipping 379 matching lines @@
       client_side_array_id_(0),
       client_side_element_array_id_(0),
       error_bits_(0),
       debug_(false),
       use_count_(0),
       current_query_(NULL),
       error_message_callback_(NULL),
       context_lost_(false) {
   GPU_DCHECK(helper);
   GPU_DCHECK(transfer_buffer);
+
+  char temp[128];
+  sprintf(temp, "%p", this);
+  this_in_hex_ = std::string(temp);

[apatrick_chromium, 2012/08/10 19:29:31]

There's a function in base/stringprintf.h that lets you do this without worrying
about the buffer size.

[greggman, 2012/08/11 00:17:30]

I can't use base here :-(

+
   GPU_CLIENT_LOG_CODE_BLOCK({
     debug_ = CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kEnableGPUClientLogging);
   });
 
   share_group_ = (share_group ? share_group : new ShareGroup(
       share_resources, bind_generates_resource));
 
   memset(&reserved_ids_, 0, sizeof(reserved_ids_));
 }
@@ skipping 160 matching lines @@
       if (IsExtensionAvailable("GL_ANGLE_pack_reverse_row_order")) {
           angle_pack_reverse_row_order_status = kAvailableExtensionStatus;
           return true;
       } else {
           angle_pack_reverse_row_order_status = kUnavailableExtensionStatus;
           return false;
       }
   }
 }
 
+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("[" << this << "] glGetError()");
+  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;
   }
 
@@ skipping 25 matching lines @@
     error = GetClientSideGLError();
   } else {
     // There was an error, clear the corresponding wrapped error.
     error_bits_ &= ~GLES2Util::GLErrorToErrorBit(error);
   }
   return error;
 }
 
 void GLES2Implementation::SetGLError(
     GLenum error, const char* function_name, const char* msg) {
-  GPU_CLIENT_LOG("[" << this << "] Client Synthesized Error: "
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] Client Synthesized Error: "
                  << GLES2Util::GetStringError(error) << ": "
                  << function_name << ": " << msg);
   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);
   }
@@ skipping 131 matching lines @@
     case GL_STENCIL_TEST:
       gl_state_.enable_state.stencil_test = enabled;
       return true;
     default:
       return false;
   }
 }
 
 void GLES2Implementation::Disable(GLenum cap) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glDisable("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDisable("
                  << GLES2Util::GetStringCapability(cap) << ")");
   SetCapabilityState(cap, false);
   helper_->Disable(cap);
 }
 
 void GLES2Implementation::Enable(GLenum cap) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glEnable("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glEnable("
                  << GLES2Util::GetStringCapability(cap) << ")");
   SetCapabilityState(cap, true);
   helper_->Enable(cap);
 }
 
 GLboolean GLES2Implementation::IsEnabled(GLenum cap) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glIsEnabled("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glIsEnabled("
                  << GLES2Util::GetStringCapability(cap) << ")");
   bool state = false;
   switch (cap) {
     case GL_DITHER:
       state = gl_state_.enable_state.dither;
       break;
     case GL_BLEND:
       state = gl_state_.enable_state.blend;
       break;
     case GL_CULL_FACE:
@@ skipping 150 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("[" << this << "] glGetMaxValueInBufferCHROMIUM("
+  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);
   return result;
 }
 
 void GLES2Implementation::Clear(GLbitfield mask) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glClear(" << mask << ")");
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glClear(" << mask << ")");
   helper_->Clear(mask);
 }
 
 void GLES2Implementation::DrawElements(
     GLenum mode, GLsizei count, GLenum type, const void* indices) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glDrawElements("
+  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;
@@ skipping 32 matching lines @@
     // Restore the element array binding.
     helper_->BindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
   }
 #else
   helper_->DrawElements(mode, count, type, ToGLuint(indices));
 #endif
 }
 
 void GLES2Implementation::Flush() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glFlush()");
+  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("[" << this << "] glShallowFlushCHROMIUM()");
+  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();
 }
 
 bool GLES2Implementation::MustBeContextLost() {
   if (!context_lost_) {
     FinishHelper();
     context_lost_ = error::IsError(helper_->command_buffer()->GetLastError());
   }
   GPU_CHECK(context_lost_);
   return context_lost_;
 }
 
 void GLES2Implementation::FinishHelper() {
-  GPU_CLIENT_LOG("[" << this << "] glFinish()");
+  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("[" << this << "] glSwapBuffers()");
+  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("[" << this << "] glGenSharedIdsCHROMIUM("
+  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("[" << this << "] glDeleteSharedIdsCHROMIUM("
+  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("[" << this << "] glRegisterSharedIdsCHROMIUM("
+  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("[" << this << "] glBindAttribLocation(" << program << ", "
-      << index << ", " << name << ")");
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindAttribLocation("
+      << program << ", " << index << ", " << name << ")");
   SetBucketAsString(kResultBucketId, name);
   helper_->BindAttribLocationBucket(program, index, kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
 void GLES2Implementation::BindUniformLocationCHROMIUM(
   GLuint program, GLint location, const char* name) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glBindUniformLocationCHROMIUM("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBindUniformLocationCHROMIUM("
       << program << ", " << location << ", " << name << ")");
   SetBucketAsString(kResultBucketId, name);
   helper_->BindUniformLocationCHROMIUMBucket(
       program, location, kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
 void GLES2Implementation::GetVertexAttribPointerv(
     GLuint index, GLenum pname, void** ptr) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glGetVertexAttribPointer(" << index << ", "
-      << GLES2Util::GetStringVertexPointer(pname) << ", "
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribPointer("
+      << index << ", " << GLES2Util::GetStringVertexPointer(pname) << ", "
       << static_cast<void*>(ptr) << ")");
 
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   // If it's a client side buffer the client has the data.
   if (client_side_buffer_helper_->GetAttribPointer(index, pname, ptr)) {
     return;
   }
 #endif  // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
 
   TRACE_EVENT0("gpu", "GLES2::GetVertexAttribPointerv");
@@ skipping 63 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("[" << this << "] glGetAttribLocation(" << program
+  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);
   return loc;
 }
 
 GLint GLES2Implementation::GetUniformLocationHelper(
     GLuint program, const char* name) {
   typedef 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("[" << this << "] glGetUniformLocation(" << program
+  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);
   return loc;
 }
 
 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("[" << this << "] glLinkProgram(" << program << ")");
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glLinkProgram(" << program << ")");
   helper_->LinkProgram(program);
   share_group_->program_info_manager()->CreateInfo(program);
 }
 
 void GLES2Implementation::ShaderBinary(
     GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary,
     GLsizei length) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glShaderBinary(" << n << ", "
+  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.");
@@ skipping 16 matching lines @@
       buffer.shm_id(),
       buffer.offset(),
       binaryformat,
       buffer.shm_id(),
       buffer.offset() + shader_id_size,
       length);
 }
 
 void GLES2Implementation::PixelStorei(GLenum pname, GLint param) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glPixelStorei("
+  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:
@@ skipping 16 matching lines @@
         break;
   }
   helper_->PixelStorei(pname, param);
 }
 
 
 void GLES2Implementation::VertexAttribPointer(
     GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride,
     const void* ptr) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glVertexAttribPointer("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttribPointer("
       << index << ", "
       << size << ", "
       << GLES2Util::GetStringVertexAttribType(type) << ", "
       << GLES2Util::GetStringBool(normalized) << ", "
       << stride << ", "
       << static_cast<const void*>(ptr) << ")");
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   // Record the info on the client side.
   client_side_buffer_helper_->SetAttribPointer(
       bound_array_buffer_id_, index, size, type, normalized, stride, ptr);
   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)
 }
 
 void GLES2Implementation::VertexAttribDivisorANGLE(
     GLuint index, GLuint divisor) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glVertexAttribDivisorANGLE("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glVertexAttribDivisorANGLE("
       << index << ", "
       << divisor << ") ");
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   // Record the info on the client side.
   client_side_buffer_helper_->SetAttribDivisor(index, divisor);
 #endif // defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   helper_->VertexAttribDivisorANGLE(index, divisor);
 }
 
 void GLES2Implementation::ShaderSource(
     GLuint shader, GLsizei count, const char** source, const GLint* length) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glShaderSource("
+  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 {
@@ skipping 86 matching lines @@
   }
 
   // Make the buffer with BufferData then send via BufferSubData
   helper_->BufferData(target, size, 0, 0, usage);
   BufferSubDataHelperImpl(target, 0, size, data, &buffer);
 }
 
 void GLES2Implementation::BufferData(
     GLenum target, GLsizeiptr size, const void* data, GLenum usage) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glBufferData("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBufferData("
       << GLES2Util::GetStringBufferTarget(target) << ", "
       << size << ", "
       << static_cast<const void*>(data) << ", "
       << GLES2Util::GetStringBufferUsage(usage) << ")");
   BufferDataHelper(target, size, data, usage);
 }
 
 void GLES2Implementation::BufferSubDataHelper(
     GLenum target, GLintptr offset, GLsizeiptr size, const void* data) {
   if (size == 0) {
@@ skipping 29 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("[" << this << "] glBufferSubData("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glBufferSubData("
       << GLES2Util::GetStringBufferTarget(target) << ", "
       << offset << ", " << size << ", "
       << static_cast<const void*>(data) << ")");
   BufferSubDataHelper(target, offset, size, data);
 }
 
 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("[" << this << "] glCompressedTexImage2D("
+  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;
   }
   SetBucketContents(kResultBucketId, data, image_size);
   helper_->CompressedTexImage2DBucket(
       target, level, internalformat, width, height, border, kResultBucketId);
   // Free the bucket. This is not required but it does free up the memory.
   // and we don't have to wait for the result so from the client's perspective
   // it's cheap.
   helper_->SetBucketSize(kResultBucketId, 0);
 }
 
 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("[" << this << "] glCompressedTexSubImage2D("
+  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;
@@ skipping 40 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("[" << this << "] glTexImage2D("
+  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;
@@ skipping 61 matching lines @@
      0, 0);
   TexSubImage2DImpl(
       target, level, 0, 0, width, height, format, type, unpadded_row_size,
       pixels, src_padded_row_size, GL_TRUE, &buffer, padded_row_size);
 }
 
 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("[" << this << "] glTexSubImage2D("
+  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");
@@ skipping 131 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("[" << this << "] glGetActiveAttrib("
+  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");
@@ skipping 49 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("[" << this << "] glGetActiveUniform("
+  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(
       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);
     }
   }
 }
 
 void GLES2Implementation::GetAttachedShaders(
     GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glGetAttachedShaders("
+  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;
   uint32 size = Result::ComputeSize(maxcount);
@@ skipping 17 matching lines @@
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
   transfer_buffer_->FreePendingToken(result, token);
 }
 
 void GLES2Implementation::GetShaderPrecisionFormat(
     GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glGetShaderPrecisionFormat("
+  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;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return;
   }
@@ skipping 55 matching lines @@
           string_set.insert(str);
       GPU_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("[" << this << "] glGetString("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetString("
       << GLES2Util::GetStringStringType(name) << ")");
   const GLubyte* result = GetStringHelper(name);
   GPU_CLIENT_LOG("  returned " << reinterpret_cast<const char*>(result));
   return result;
 }
 
 void GLES2Implementation::GetUniformfv(
     GLuint program, GLint location, GLfloat* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glGetUniformfv("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetUniformfv("
       << program << ", " << location << ", "
       << static_cast<const void*>(params) << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformfv");
   typedef gles2::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]);
     }
   });
 }
 
 void GLES2Implementation::GetUniformiv(
     GLuint program, GLint location, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glGetUniformiv("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetUniformiv("
       << program << ", " << location << ", "
       << static_cast<const void*>(params) << ")");
   TRACE_EVENT0("gpu", "GLES2::GetUniformiv");
   typedef gles2::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);
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
 }
 
 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("[" << this << "] glReadPixels("
+  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) {
@@ skipping 67 matching lines @@
     if (*result == 0) {
       return;
     }
     yoffset += num_rows;
     height -= num_rows;
   }
 }
 
 void GLES2Implementation::ActiveTexture(GLenum texture) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glActiveTexture("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glActiveTexture("
       << GLES2Util::GetStringEnum(texture) << ")");
   GLuint texture_index = texture - GL_TEXTURE0;
   if (texture_index >= static_cast<GLuint>(
       gl_state_.int_state.max_combined_texture_image_units)) {
     SetGLError(
         GL_INVALID_ENUM, "glActiveTexture", "texture_unit out of range.");
     return;
   }
 
   active_texture_unit_ = texture_index;
@@ skipping 180 matching lines @@
 }
 
 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(
-      "[" << this << "] glDisableVertexAttribArray(" << index << ")");
+      "[" << GetLogPrefix() << "] glDisableVertexAttribArray(" << index << ")");
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   client_side_buffer_helper_->SetAttribEnable(index, false);
 #endif
   helper_->DisableVertexAttribArray(index);
 }
 
 void GLES2Implementation::EnableVertexAttribArray(GLuint index) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glEnableVertexAttribArray(" << index << ")");
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glEnableVertexAttribArray("
+      << index << ")");
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   client_side_buffer_helper_->SetAttribEnable(index, true);
 #endif
   helper_->EnableVertexAttribArray(index);
 }
 
 void GLES2Implementation::DrawArrays(GLenum mode, GLint first, GLsizei count) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glDrawArrays("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glDrawArrays("
       << GLES2Util::GetStringDrawMode(mode) << ", "
       << first << ", " << count << ")");
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, "glDrawArrays", "count < 0");
     return;
   }
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   bool have_client_side =
       client_side_buffer_helper_->HaveEnabledClientSideBuffers();
   if (have_client_side) {
@@ skipping 44 matching lines @@
       SetGLError(GL_INVALID_ENUM, "glGetVertexAttrib", "invalid enum");
       break;
   }
   return true;
 }
 #endif  // GLES2_SUPPORT_CLIENT_SIDE_ARRAYS
 
 void GLES2Implementation::GetVertexAttribfv(
     GLuint index, GLenum pname, GLfloat* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glGetVertexAttribfv("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribfv("
       << index << ", "
       << GLES2Util::GetStringVertexAttribute(pname) << ", "
       << static_cast<const void*>(params) << ")");
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   uint32 value = 0;
   if (GetVertexAttribHelper(index, pname, &value)) {
     *params = static_cast<float>(value);
     return;
   }
 #endif
@@ skipping 11 matching lines @@
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
 }
 
 void GLES2Implementation::GetVertexAttribiv(
     GLuint index, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glGetVertexAttribiv("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGetVertexAttribiv("
       << index << ", "
       << GLES2Util::GetStringVertexAttribute(pname) << ", "
       << static_cast<const void*>(params) << ")");
 #if defined(GLES2_SUPPORT_CLIENT_SIDE_ARRAYS)
   uint32 value = 0;
   if (GetVertexAttribHelper(index, pname, &value)) {
     *params = value;
     return;
   }
 #endif
@@ skipping 11 matching lines @@
   GPU_CLIENT_LOG_CODE_BLOCK({
     for (int32 i = 0; i < result->GetNumResults(); ++i) {
       GPU_CLIENT_LOG("  " << i << ": " << result->GetData()[i]);
     }
   });
 }
 
 GLboolean GLES2Implementation::EnableFeatureCHROMIUM(
     const char* feature) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glEnableFeatureCHROMIUM("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glEnableFeatureCHROMIUM("
                  << feature << ")");
   TRACE_EVENT0("gpu", "GLES2::EnableFeatureCHROMIUM");
   typedef 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("[" << this << "] glMapBufferSubDataCHROMIUM("
+  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) {
     SetGLError(
         GL_INVALID_ENUM, "glMapBufferSubDataCHROMIUM", "bad access mode");
     return NULL;
   }
   if (offset < 0 || size < 0) {
@@ skipping 14 matching lines @@
          MappedBuffer(
              access, shm_id, mem, shm_offset, target, offset, size)));
   GPU_DCHECK(result.second);
   GPU_CLIENT_LOG("  returned " << mem);
   return mem;
 }
 
 void GLES2Implementation::UnmapBufferSubDataCHROMIUM(const void* mem) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG(
-      "[" << this << "] glUnmapBufferSubDataCHROMIUM(" << mem << ")");
+      "[" << 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);
 }
 
 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("[" << this << "] glMapTexSubImage2DCHROMIUM("
+  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) {
     SetGLError(
         GL_INVALID_ENUM, "glMapTexSubImage2DCHROMIUM", "bad access mode");
     return NULL;
@@ skipping 27 matching lines @@
              access, shm_id, mem, shm_offset,
              target, level, xoffset, yoffset, width, height, format, type)));
   GPU_DCHECK(result.second);
   GPU_CLIENT_LOG("  returned " << mem);
   return mem;
 }
 
 void GLES2Implementation::UnmapTexSubImage2DCHROMIUM(const void* mem) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
   GPU_CLIENT_LOG(
-      "[" << this << "] glUnmapTexSubImage2DCHROMIUM(" << mem << ")");
+      "[" << 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);
 }
 
 void GLES2Implementation::ResizeCHROMIUM(GLuint width, GLuint height) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glResizeCHROMIUM("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glResizeCHROMIUM("
                  << width << ", " << height << ")");
   helper_->ResizeCHROMIUM(width, height);
 }
 
 const GLchar* GLES2Implementation::GetRequestableExtensionsCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glGetRequestableExtensionsCHROMIUM()");
+  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);
       GPU_DCHECK(insert_result.second);
       result = insert_result.first->c_str();
     }
   }
   GPU_CLIENT_LOG("  returned " << result);
   return reinterpret_cast<const GLchar*>(result);
 }
 
 void GLES2Implementation::RequestExtensionCHROMIUM(const char* extension) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glRequestExtensionCHROMIUM("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glRequestExtensionCHROMIUM("
                  << extension << ")");
   SetBucketAsCString(kResultBucketId, extension);
   helper_->RequestExtensionCHROMIUM(kResultBucketId);
   helper_->SetBucketSize(kResultBucketId, 0);
   if (kUnavailableExtensionStatus == angle_pack_reverse_row_order_status &&
       !strcmp(extension, "GL_ANGLE_pack_reverse_row_order")) {
     angle_pack_reverse_row_order_status = kUnknownExtensionStatus;
   }
 }
 
 void GLES2Implementation::RateLimitOffscreenContextCHROMIUM() {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glRateLimitOffscreenCHROMIUM()");
+  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("[" << this << "] glGetMultipleIntegervCHROMIUM("
+  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]));
     }
   });
   int num_results = 0;
   for (GLuint ii = 0; ii < count; ++ii) {
@@ skipping 80 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("[" << this << "] CreateStreamTextureCHROMIUM("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] CreateStreamTextureCHROMIUM("
       << texture << ")");
   TRACE_EVENT0("gpu", "GLES2::CreateStreamTextureCHROMIUM");
   typedef CreateStreamTextureCHROMIUM::Result Result;
   Result* result = GetResultAs<Result*>();
   if (!result) {
     return GL_ZERO;
   }
   *result = GL_ZERO;
 
   helper_->CreateStreamTextureCHROMIUM(texture,
                                        GetResultShmId(),
                                        GetResultShmOffset());
   WaitForCmd();
 
   return *result;
 }
 
 void GLES2Implementation::DestroyStreamTextureCHROMIUM(GLuint texture) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] DestroyStreamTextureCHROMIUM("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] DestroyStreamTextureCHROMIUM("
       << texture << ")");
   TRACE_EVENT0("gpu", "GLES2::DestroyStreamTextureCHROMIUM");
   helper_->DestroyStreamTextureCHROMIUM(texture);
 }
 
 void GLES2Implementation::PostSubBufferCHROMIUM(
     GLint x, GLint y, GLint width, GLint height) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] PostSubBufferCHROMIUM("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] PostSubBufferCHROMIUM("
       << x << ", " << y << ", " << width << ", " << height << ")");
   TRACE_EVENT0("gpu", "GLES2::PostSubBufferCHROMIUM");
 
   // 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 43 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("[" << this << "] IsQueryEXT(" << id << ")");
+  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("[" << this << "] BeginQueryEXT("
+  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;
   }
 
@@ skipping 19 matching lines @@
     return;
   }
 
   current_query_ = query;
 
   query->Begin(this);
 }
 
 void GLES2Implementation::EndQueryEXT(GLenum target) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] EndQueryEXT("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] EndQueryEXT("
                  << GLES2Util::GetStringQueryTarget(target) << ")");
   // Don't do anything if the context is lost.
   if (context_lost_) {
     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;
 }
 
 void GLES2Implementation::GetQueryivEXT(
     GLenum target, GLenum pname, GLint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] GetQueryivEXT("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] GetQueryivEXT("
                  << GLES2Util::GetStringQueryTarget(target) << ", "
                  << GLES2Util::GetStringQueryParameter(pname) << ", "
                  << static_cast<const void*>(params) << ")");
 
   if (pname != GL_CURRENT_QUERY_EXT) {
     SetGLError(GL_INVALID_ENUM, "glGetQueryivEXT", "invalid pname");
     return;
   }
   *params = (current_query_ && current_query_->target() == target) ?
       current_query_->id() : 0;
   GPU_CLIENT_LOG("  " << *params);
 }
 
 void GLES2Implementation::GetQueryObjectuivEXT(
     GLuint id, GLenum pname, GLuint* params) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] GetQueryivEXT(" << id << ", "
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] GetQueryivEXT(" << id << ", "
                  << GLES2Util::GetStringQueryObjectParameter(pname) << ", "
                  << static_cast<const void*>(params) << ")");
 
   // exit if the context is lost.
   if (context_lost_) {
     return;
   }
 
   QueryTracker::Query* query = query_tracker_->GetQuery(id);
   if (!query) {
@@ skipping 33 matching lines @@
     default:
       SetGLError(GL_INVALID_ENUM, "glQueryObjectuivEXT", "unknown pname");
       break;
   }
   GPU_CLIENT_LOG("  " << *params);
 }
 
 void GLES2Implementation::DrawArraysInstancedANGLE(
     GLenum mode, GLint first, GLsizei count, GLsizei primcount) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glDrawArraysInstancedANGLE("
+  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;
   }
@@ skipping 14 matching lines @@
     // Restore the user's current binding.
     helper_->BindBuffer(GL_ARRAY_BUFFER, bound_array_buffer_id_);
   }
 #endif
 }
 
 void GLES2Implementation::DrawElementsInstancedANGLE(
     GLenum mode, GLsizei count, GLenum type, const void* indices,
     GLsizei primcount) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glDrawElementsInstancedANGLE("
+  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;
   }
@@ skipping 44 matching lines @@
   }
 #else
   helper_->DrawElementsInstancedANGLE(
       mode, count, type, ToGLuint(indices), primcount);
 #endif
 }
 
 void GLES2Implementation::GenMailboxCHROMIUM(
     GLbyte* mailbox) {
   GPU_CLIENT_SINGLE_THREAD_CHECK();
-  GPU_CLIENT_LOG("[" << this << "] glGenMailboxCHROMIUM("
+  GPU_CLIENT_LOG("[" << GetLogPrefix() << "] glGenMailboxCHROMIUM("
       << static_cast<const void*>(mailbox) << ")");
   TRACE_EVENT0("gpu", "GLES2::GenMailboxCHROMIUM");
 
   helper_->GenMailboxCHROMIUM(kResultBucketId);
 
   std::vector<GLbyte> result;
   GetBucketContents(kResultBucketId, &result);
 
   std::copy(result.begin(), result.end(), mailbox);
 }
 
+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();
+}
+
 }  // namespace gles2
 }  // namespace gpu