Implement GL_EXT_debug_marker

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_cftyperef.h"
 #endif
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/string_number_conversions.h"
 #include "build/build_config.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
+#include "gpu/command_buffer/common/debug_marker_manager.h"
 #include "gpu/command_buffer/common/id_allocator.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
@@ skipping 1128 matching lines @@
 
   // Wrapper for glViewport
   void DoViewport(GLint x, GLint y, GLsizei width, GLsizei height);
 
   // Wrapper for glUseProgram
   void DoUseProgram(GLuint program);
 
   // Wrapper for glValidateProgram.
   void DoValidateProgram(GLuint program_client_id);
 
+  void DoInsertEventMarkerEXT(GLsizei length, const GLchar* marker);
+  void DoPushGroupMarkerEXT(GLsizei length, const GLchar* group);
+  void DoPopGroupMarkerEXT(void);
+
   // Gets the number of values that will be returned by glGetXXX. Returns
   // false if pname is unknown.
   bool GetNumValuesReturnedForGLGet(GLenum pname, GLsizei* num_values);
 
   // Gets the GLError and stores it in our wrapper. Effectively
   // this lets us peek at the error without losing it.
   GLenum PeekGLError();
 
   // Copies the real GL errors to the wrapper. This is so we can
   // make sure there are no native GL errors before calling some GL function
@@ skipping 160 matching lines @@
       GLsizei width, GLsizei height, GLenum format, size_t size);
   bool ValidateCompressedTexSubDimensions(
     const char* function_name,
     GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLsizei width, GLsizei height, GLenum format,
     TextureManager::TextureInfo* texture);
 
   void LogMessage(const std::string& msg);
   void RenderWarning(const std::string& msg);
   void PerformanceWarning(const std::string& msg);
+  const std::string& GetLogPrefix() const;
 
   bool ShouldDeferDraws() {
     return !offscreen_target_frame_buffer_.get() &&
            bound_draw_framebuffer_ == NULL &&
            surface_->DeferDraws();
   }
 
   void ForceCompileShaderIfPending(ShaderManager::ShaderInfo* info);
 
   // Generate a member function prototype for each command in an automated and
@@ skipping 152 matching lines @@
   bool bufferdata_faster_than_buffersubdata_;
 
   // The last error message set.
   std::string last_error_;
 
   int log_message_count_;
 
   // The current decoder error.
   error::Error current_decoder_error_;
 
+  DebugMarkerManager debug_marker_manager_;
+  std::string this_in_hex_;
+
   bool use_shader_translator_;
   scoped_refptr<ShaderTranslator> vertex_translator_;
   scoped_refptr<ShaderTranslator> fragment_translator_;
 
   DisallowedFeatures disallowed_features_;
 
   // Cached from ContextGroup
   const Validators* validators_;
   FeatureInfo::Ref feature_info_;
 
@@ skipping 435 matching lines @@
       derivatives_explicitly_enabled_(false),
       compile_shader_always_succeeds_(false),
       viewport_x_(0),
       viewport_y_(0),
       viewport_width_(0),
       viewport_height_(0),
       viewport_max_width_(0),
       viewport_max_height_(0) {
   DCHECK(group);
 
+  GLES2DecoderImpl* this_temp = this;
+  this_in_hex_ = HexEncode(&this_temp, sizeof(this_temp));
+
   attrib_0_value_.v[0] = 0.0f;
   attrib_0_value_.v[1] = 0.0f;
   attrib_0_value_.v[2] = 0.0f;
   attrib_0_value_.v[3] = 1.0f;
 
   // The shader translator is used for WebGL even when running on EGL
   // because additional restrictions are needed (like only enabling
   // GL_OES_standard_derivatives on demand).  It is used for the unit
   // tests because
   // GLES2DecoderWithShaderTest.GetShaderInfoLogValidArgs passes the
@@ skipping 1198 matching lines @@
 // by a (malicious) client at any time, so if validation has to happen, it
 // should operate on a copy of them.
 error::Error GLES2DecoderImpl::DoCommand(
     unsigned int command,
     unsigned int arg_count,
     const void* cmd_data) {
   error::Error result = error::kNoError;
   if (log_commands()) {
     // TODO(notme): Change this to a LOG/VLOG that works in release. Tried
     // LOG(INFO), tried VLOG(1), no luck.
-    LOG(ERROR) << "[" << this << "]" << "cmd: " << GetCommandName(command);
+    LOG(ERROR) << "[" << GetLogPrefix() << "]" << "cmd: "
+               << GetCommandName(command);
   }
   unsigned int command_index = command - kStartPoint - 1;
   if (command_index < arraysize(g_command_info)) {
     const CommandInfo& info = g_command_info[command_index];
     unsigned int info_arg_count = static_cast<unsigned int>(info.arg_count);
     if ((info.arg_flags == cmd::kFixed && arg_count == info_arg_count) ||
         (info.arg_flags == cmd::kAtLeastN && arg_count >= info_arg_count)) {
       uint32 immediate_data_size =
           (arg_count - info_arg_count) * sizeof(CommandBufferEntry);  // NOLINT
       switch (command) {
         #define GLES2_CMD_OP(name)                                 \
           case name::kCmdId:                                       \
             result = Handle ## name(                               \
                 immediate_data_size,                               \
                 *static_cast<const name*>(cmd_data));              \
             break;                                                 \
 
         GLES2_COMMAND_LIST(GLES2_CMD_OP)
         #undef GLES2_CMD_OP
       }
       if (debug()) {
         GLenum error;
         while ((error = glGetError()) != GL_NO_ERROR) {
-          LOG(ERROR) << "[" << this << "] "
+          LOG(ERROR) << "[" << GetLogPrefix() << "] "
                      << "GL ERROR: " << GLES2Util::GetStringEnum(error) << " : "
                      << GetCommandName(command);
           SetGLError(error, "DoCommand", "GL error from driver");
         }
       }
     } else {
       result = error::kInvalidArguments;
     }
   } else {
     result = DoCommonCommand(command, arg_count, cmd_data);
@@ skipping 1850 matching lines @@
   if (error != GL_NO_ERROR) {
     SetGLError(error, "", "");
   }
   return error;
 }
 
 void GLES2DecoderImpl::SetGLError(
     GLenum error, const char* function_name, const char* msg) {
   if (msg) {
     last_error_ = msg;
-    LogMessage(std::string("GL ERROR :") +
+    LogMessage(GetLogPrefix() + ": " + std::string("GL ERROR :") +
                GLES2Util::GetStringEnum(error) + " : " +
                function_name + ": " + msg);
   }
   error_bits_ |= GLES2Util::GLErrorToErrorBit(error);
 }
 
+const std::string& GLES2DecoderImpl::GetLogPrefix() const {
+  const std::string& prefix(debug_marker_manager_.GetMarker());
+  return prefix.empty() ? this_in_hex_ : prefix;
+}
+
 void GLES2DecoderImpl::LogMessage(const std::string& msg) {
   if (log_message_count_ < kMaxLogMessages ||
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGLErrorLimit)) {
     ++log_message_count_;
     // LOG this unless logging is turned off as any chromium code that
     // generates these errors probably has a bug.
     if (log_synthesized_gl_errors()) {
       LOG(ERROR) << msg;
     }
@@ skipping 4070 matching lines @@
 
   if (!texture_manager()->Restore(info, definition.release())) {
     SetGLError(GL_INVALID_OPERATION,
                "glConsumeTextureCHROMIUM", "invalid texture");
     return;
   }
 
   BindAndApplyTextureParameters(info);
 }
 
+void GLES2DecoderImpl::DoInsertEventMarkerEXT(
+    GLsizei length, const GLchar* marker) {
+  if (!marker) {
+    marker = "";
+  }
+  debug_marker_manager_.SetMarker(
+      length ? std::string(marker, length) : std::string(marker));
+}
+
+void GLES2DecoderImpl::DoPushGroupMarkerEXT(
+    GLsizei length, const GLchar* marker) {
+  if (!marker) {
+    marker = "";
+  }
+  debug_marker_manager_.PushGroup(
+      length ? std::string(marker, length) : std::string(marker));
+}
+
+void GLES2DecoderImpl::DoPopGroupMarkerEXT(void) {
+  debug_marker_manager_.PopGroup();
+}
+
+
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu