Convert some non-debug logging on content/common to debug logging.

content/common/gpu/gpu_command_buffer_stub.cc

  // Copyright (c) 2011 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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/shared_memory.h"
@@ skipping 56 matching lines @@
   gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(
       handle_, renderer_id_, render_view_id_));
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
   // Ensure the appropriate GL context is current before handling any IPC
   // messages directed at the command buffer. This ensures that the message
   // handler can assume that the context is current.
   if (decoder_.get()) {
     if (!decoder_->MakeCurrent()) {
-      LOG(ERROR) << "Context lost because MakeCurrent failed.";
+      DLOG(ERROR) << "Context lost because MakeCurrent failed.";
       command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
       command_buffer_->SetParseError(gpu::error::kLostContext);
       if (gfx::GLContext::LosesAllContextsOnContextLost())
         channel_->LoseAllContexts();
       return false;
     }
   }
 
   // Always use IPC_MESSAGE_HANDLER_DELAY_REPLY for synchronous message handlers
   // here. This is so the reply can be delayed if the scheduler is unscheduled.
@@ skipping 110 matching lines @@
 #endif
   } else {
     surface_ = gfx::GLSurface::CreateOffscreenGLSurface(software_,
                                                         gfx::Size(1, 1));
   }
 
   if (!surface_.get()) {
     // Ensure the decoder is not destroyed if it is not initialized.
     decoder_.reset();
 
-    LOG(ERROR) << "Failed to create surface.\n";
+    DLOG(ERROR) << "Failed to create surface.\n";
     OnInitializeFailed(reply_message);
     return;
   }
 
   gfx::GpuPreference gpu_preference =
       channel_->ShouldPreferDiscreteGpu() ?
           gfx::PreferDiscreteGpu : gpu_preference_;
 
   context_ = gfx::GLContext::CreateGLContext(
       channel_->share_group(),
       surface_.get(),
       gpu_preference);
   if (!context_.get()) {
     // Ensure the decoder is not destroyed if it is not initialized.
     decoder_.reset();
 
-    LOG(ERROR) << "Failed to create context.\n";
+    DLOG(ERROR) << "Failed to create context.\n";
     OnInitializeFailed(reply_message);
     return;
   }
 
   // Initialize the decoder with either the view or pbuffer GLContext.
   if (!decoder_->Initialize(surface_.get(),
                             context_.get(),
                             initial_size_,
                             disallowed_features_,
                             allowed_extensions_.c_str(),
                             requested_attribs_)) {
-    LOG(ERROR) << "Failed to initialize decoder.";
+    DLOG(ERROR) << "Failed to initialize decoder.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUServiceLogging)) {
     decoder_->set_debug(true);
   }
 
   SetSwapInterval();
@@ skipping 265 matching lines @@
 void GpuCommandBufferStub::OnDestroyVideoDecoder(int decoder_route_id) {
   channel_->RemoveRoute(decoder_route_id);
   video_decoders_.Remove(decoder_route_id);
 }
 
 void GpuCommandBufferStub::OnSetSurfaceVisible(bool visible) {
   surface_->SetVisible(visible);
 }
 
 #endif  // defined(ENABLE_GPU)