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

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>
@@ skipping 476 matching lines @@
 };
 
 
 // }  // anonymous namespace.
 
 bool GLES2Decoder::GetServiceTextureId(uint32 client_texture_id,
                                        uint32* service_texture_id) {
   return false;
 }
 
-GLES2Decoder::GLES2Decoder()
-    : initialized_(false),
-      debug_(false),
-      log_commands_(false) {
-}
+GLES2Decoder::GLES2Decoder() : initialized_(false), debug_(false) {}
 
-GLES2Decoder::~GLES2Decoder() {
-}
+GLES2Decoder::~GLES2Decoder() {}
 
 // This class implements GLES2Decoder so we don't have to expose all the GLES2
 // cmd stuff to outside this class.
 class GLES2DecoderImpl : public GLES2Decoder,
                          public FramebufferManager::TextureDetachObserver {
  public:
   // Used by PrepForSetUniformByLocation to validate types.
   struct BaseUniformInfo {
     const GLenum* const valid_types;
     size_t num_valid_types;
@@ skipping 373 matching lines @@
   Program* CreateProgram(
       GLuint client_id, GLuint service_id) {
     return program_manager()->CreateProgram(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
   Program* GetProgram(GLuint client_id) {
     return program_manager()->GetProgram(client_id);
   }
 
-#if defined(NDEBUG)
-  void LogClientServiceMapping(
-      const char* /* function_name */,
-      GLuint /* client_id */,
-      GLuint /* service_id */) {
-  }
-  template<typename T>
-  void LogClientServiceForInfo(
-      T* /* info */, GLuint /* client_id */, const char* /* function_name */) {
-  }
-#else
-  void LogClientServiceMapping(
-      const char* function_name, GLuint client_id, GLuint service_id) {
-    if (service_logging_) {
-      DLOG(INFO) << "[" << logger_.GetLogPrefix() << "] " << function_name
-                 << ": client_id = " << client_id
-                 << ", service_id = " << service_id;
-    }
-  }
-  template<typename T>
-  void LogClientServiceForInfo(
-      T* info, GLuint client_id, const char* function_name) {
-    if (info) {
-      LogClientServiceMapping(function_name, client_id, info->service_id());
-    }
-  }
-#endif
-
   // Gets the program info for the given program. If it's not a program
   // generates a GL error. Returns NULL if not program.
   Program* GetProgramInfoNotShader(
       GLuint client_id, const char* function_name) {
     Program* program = GetProgram(client_id);
     if (!program) {
       if (GetShader(client_id)) {
         LOCAL_SET_GL_ERROR(
             GL_INVALID_OPERATION, function_name, "shader passed for program");
       } else {
         LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "unknown program");
       }
     }
-    LogClientServiceForInfo(program, client_id, function_name);
     return program;
   }
 
 
   // Creates a Shader for the given shader.
   Shader* CreateShader(
       GLuint client_id,
       GLuint service_id,
       GLenum shader_type) {
     return shader_manager()->CreateShader(
@@ skipping 12 matching lines @@
     Shader* shader = GetShader(client_id);
     if (!shader) {
       if (GetProgram(client_id)) {
         LOCAL_SET_GL_ERROR(
             GL_INVALID_OPERATION, function_name, "program passed for shader");
       } else {
         LOCAL_SET_GL_ERROR(
             GL_INVALID_VALUE, function_name, "unknown shader");
       }
     }
-    LogClientServiceForInfo(shader, client_id, function_name);
     return shader;
   }
 
   // Creates a buffer info for the given buffer.
   void CreateBuffer(GLuint client_id, GLuint service_id) {
     return buffer_manager()->CreateBuffer(client_id, service_id);
   }
 
   // Gets the buffer info for the given buffer.
   Buffer* GetBuffer(GLuint client_id) {
@@ skipping 684 matching lines @@
   // contexts, the assumptions on the availablity of extensions in WebGL
   // contexts may be broken.  These flags override the shared state to preserve
   // WebGL semantics.
   bool force_webgl_glsl_validation_;
   bool derivatives_explicitly_enabled_;
   bool frag_depth_explicitly_enabled_;
   bool draw_buffers_explicitly_enabled_;
 
   bool compile_shader_always_succeeds_;
 
-  // Log extra info.
-  bool service_logging_;
-
 #if defined(OS_MACOSX)
   typedef std::map<GLuint, CFTypeRef> TextureToIOSurfaceMap;
   TextureToIOSurfaceMap texture_to_io_surface_map_;
 #endif
 
   scoped_ptr<CopyTextureCHROMIUMResourceManager> copy_texture_CHROMIUM_;
 
   // Cached values of the currently assigned viewport dimensions.
   GLsizei viewport_max_width_;
   GLsizei viewport_max_height_;
@@ skipping 452 matching lines @@
       feature_info_(group_->feature_info()),
       frame_number_(0),
       has_robustness_extension_(false),
       reset_status_(GL_NO_ERROR),
       reset_by_robustness_extension_(false),
       force_webgl_glsl_validation_(false),
       derivatives_explicitly_enabled_(false),
       frag_depth_explicitly_enabled_(false),
       draw_buffers_explicitly_enabled_(false),
       compile_shader_always_succeeds_(false),
-      service_logging_(CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableGPUServiceLoggingGPU)),
       viewport_max_width_(0),
       viewport_max_height_(0),
       texture_state_(group_->feature_info()
                          ->workarounds()
                          .texsubimage2d_faster_than_teximage2d),
       validation_texture_(0),
       validation_fbo_multisample_(0),
       validation_fbo_(0) {
   DCHECK(group);
 
@@ skipping 30 matching lines @@
 
   set_initialized();
   gpu_tracer_ = GPUTracer::Create();
   gpu_state_tracer_ = GPUStateTracer::Create(&state_);
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUDebugging)) {
     set_debug(true);
   }
 
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnableGPUCommandLogging)) {
-    set_log_commands(true);
-  }
-
   compile_shader_always_succeeds_ = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kCompileShaderAlwaysSucceeds);
 
 
   // Take ownership of the context and surface. The surface can be replaced with
   // SetSurface.
   context_ = context;
   surface_ = surface;
 
   if (!group_->Initialize(this, disallowed_features)) {
@@ skipping 1253 matching lines @@
 
 // Decode command with its arguments, and call the corresponding GL function.
 // Note: args is a pointer to the command buffer. As such, it could be changed
 // 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) << "[" << logger_.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)                                 \
@@ skipping 90 matching lines @@
 
       // It's a new id so make a buffer buffer for it.
       glGenBuffersARB(1, &service_id);
       CreateBuffer(client_id, service_id);
       buffer = GetBuffer(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kBuffers);
       id_allocator->MarkAsUsed(client_id);
     }
   }
-  LogClientServiceForInfo(buffer, client_id, "glBindBuffer");
   if (buffer) {
     if (!buffer_manager()->SetTarget(buffer, target)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_OPERATION,
           "glBindBuffer", "buffer bound to more than 1 target");
       return;
     }
     service_id = buffer->service_id();
   }
   switch (target) {
@@ skipping 158 matching lines @@
       CreateFramebuffer(client_id, service_id);
       framebuffer = GetFramebuffer(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kFramebuffers);
       id_allocator->MarkAsUsed(client_id);
     } else {
       service_id = framebuffer->service_id();
     }
     framebuffer->MarkAsValid();
   }
-  LogClientServiceForInfo(framebuffer, client_id, "glBindFramebuffer");
 
   if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER_EXT) {
     framebuffer_state_.bound_draw_framebuffer = framebuffer;
   }
   if (target == GL_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER_EXT) {
     framebuffer_state_.bound_read_framebuffer = framebuffer;
   }
 
   framebuffer_state_.clear_state_dirty = true;
 
@@ skipping 25 matching lines @@
       CreateRenderbuffer(client_id, service_id);
       renderbuffer = GetRenderbuffer(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kRenderbuffers);
       id_allocator->MarkAsUsed(client_id);
     } else {
       service_id = renderbuffer->service_id();
     }
     renderbuffer->MarkAsValid();
   }
-  LogClientServiceForInfo(renderbuffer, client_id, "glBindRenerbuffer");
   state_.bound_renderbuffer = renderbuffer;
   glBindRenderbufferEXT(target, service_id);
 }
 
 void GLES2DecoderImpl::DoBindTexture(GLenum target, GLuint client_id) {
   TextureRef* texture_ref = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
     texture_ref = GetTexture(client_id);
     if (!texture_ref) {
@@ skipping 24 matching lines @@
         GL_INVALID_OPERATION,
         "glBindTexture", "texture bound to more than 1 target.");
     return;
   }
   if (texture->IsStreamTexture() && target != GL_TEXTURE_EXTERNAL_OES) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glBindTexture", "illegal target for stream texture.");
     return;
   }
-  LogClientServiceForInfo(texture, client_id, "glBindTexture");
   if (texture->target() == 0) {
     texture_manager()->SetTarget(texture_ref, target);
   }
   glBindTexture(target, texture->service_id());
 
   TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   unit.bind_target = target;
   switch (target) {
     case GL_TEXTURE_2D:
       unit.bound_texture_2d = texture_ref;
@@ skipping 1466 matching lines @@
 }
 
 void GLES2DecoderImpl::DoLinkProgram(GLuint program_id) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoLinkProgram");
   Program* program = GetProgramInfoNotShader(
       program_id, "glLinkProgram");
   if (!program) {
     return;
   }
 
-  LogClientServiceForInfo(program, program_id, "glLinkProgram");
   ShaderTranslator* vertex_translator = NULL;
   ShaderTranslator* fragment_translator = NULL;
   if (use_shader_translator_) {
     vertex_translator = vertex_translator_.get();
     fragment_translator = fragment_translator_.get();
   }
   if (program->Link(shader_manager(),
                     vertex_translator,
                     fragment_translator,
                     feature_info_.get(),
@@ skipping 457 matching lines @@
           GL_INVALID_OPERATION, "glUseProgram", "program not linked");
       return;
     }
     service_id = program->service_id();
   }
   if (state_.current_program.get()) {
     program_manager()->UnuseProgram(shader_manager(),
                                     state_.current_program.get());
   }
   state_.current_program = program;
-  LogClientServiceMapping("glUseProgram", program_id, service_id);
   glUseProgram(service_id);
   if (state_.current_program.get()) {
     program_manager()->UseProgram(state_.current_program.get());
   }
 }
 
 void GLES2DecoderImpl::RenderWarning(
     const char* filename, int line, const std::string& msg) {
   logger_.LogMessage(filename, line, std::string("RENDER WARNING: ") + msg);
 }
@@ skipping 4653 matching lines @@
   DoDidUseTexImageIfNeeded(texture, texture->target());
 }
 
 // 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