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

content/common/gpu/media/omx_video_decode_accelerator.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.
 
 #include "content/common/gpu/media/omx_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 66 matching lines @@
       return OMX_VIDEO_AVCProfileMax;
   }
 }
 
 // Helper macros for dealing with failure.  If |result| evaluates false, emit
 // |log| to ERROR, register |error| with the decoder, and return |ret_val|
 // (which may be omitted for functions that return void).
 #define RETURN_ON_FAILURE(result, log, error, ret_val)             \
   do {                                                             \
     if (!(result)) {                                               \
-      LOG(ERROR) << log;                                           \
+      DLOG(ERROR) << log;                                          \
       StopOnError(error);                                          \
       return ret_val;                                              \
     }                                                              \
   } while (0)
 
 // OMX-specific version of RETURN_ON_FAILURE which compares with OMX_ErrorNone.
 #define RETURN_ON_OMX_FAILURE(omx_result, log, error, ret_val)          \
   RETURN_ON_FAILURE(                                                    \
       ((omx_result) == OMX_ErrorNone),                                  \
       log << ", OMX result: 0x" << std::hex << omx_result,              \
@@ skipping 234 matching lines @@
   RETURN_ON_OMX_FAILURE(result, "OMX_EmptyThisBuffer() failed",
                         PLATFORM_FAILURE,);
   input_buffers_at_component_++;
 }
 
 void OmxVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   RETURN_ON_FAILURE(CanFillBuffer(), "Can't fill buffer", ILLEGAL_STATE,);
 
-  CHECK_EQ(output_buffers_at_component_, 0);
-  CHECK_EQ(fake_output_buffers_.size(), 0U);
-  CHECK_EQ(pictures_.size(), 0U);
+  DCHECK_EQ(output_buffers_at_component_, 0);
+  DCHECK_EQ(fake_output_buffers_.size(), 0U);
+  DCHECK_EQ(pictures_.size(), 0U);
 
   static Gles2TextureToEglImageTranslator texture2eglImage_translator;
   for (size_t i = 0; i < buffers.size(); ++i) {
     EGLImageKHR egl_image = texture2eglImage_translator.TranslateToEglImage(
         egl_display_, egl_context_, buffers[i].texture_id());
     CHECK(pictures_.insert(std::make_pair(
         buffers[i].id(), OutputPicture(buffers[i], NULL, egl_image))).second);
   }
 
   if (pictures_.size() < kNumPictureBuffers)
@@ skipping 243 matching lines @@
 }
 
 void OmxVideoDecodeAccelerator::OnReachedInvalidInErroring() {
   client_state_ = OMX_StateInvalid;
   ShutdownComponent();
 }
 
 void OmxVideoDecodeAccelerator::ShutdownComponent() {
   OMX_ERRORTYPE result = omx_free_handle(component_handle_);
   if (result != OMX_ErrorNone)
-    LOG(ERROR) << "OMX_FreeHandle() error. Error code: " << result;
+    DLOG(ERROR) << "OMX_FreeHandle() error. Error code: " << result;
   component_handle_ = NULL;
   client_state_ = OMX_StateMax;
   // This Release() call must happen *after* any access to |*this| because it
   // might result in |this| being deleted.
   Release();  // Since OMX no longer has |this| to call back to.
   omx_deinit();
 }
 
 void OmxVideoDecodeAccelerator::StopOnError(
     media::VideoDecodeAccelerator::Error error) {
@@ skipping 69 matching lines @@
 }
 
 void OmxVideoDecodeAccelerator::FreeOutputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   // Calls to OMX to free buffers.
   OMX_ERRORTYPE result;
   static Gles2TextureToEglImageTranslator texture2eglImage_translator;
   for (OutputPictureById::iterator it = pictures_.begin();
        it != pictures_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* omx_buffer = it->second.omx_buffer_header;
-    CHECK(omx_buffer);
+    DCHECK(omx_buffer);
     delete reinterpret_cast<media::Picture*>(omx_buffer->pAppPrivate);
     result = OMX_FreeBuffer(component_handle_, output_port_, omx_buffer);
     RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer", PLATFORM_FAILURE,);
     texture2eglImage_translator.DestroyEglImage(egl_display_,
                                                 it->second.egl_image);
     if (client_)
       client_->DismissPictureBuffer(it->first);
   }
   pictures_.clear();
 }
@@ skipping 52 matching lines @@
       reinterpret_cast<media::Picture*>(buffer->pAppPrivate);
   int picture_buffer_id = picture ? picture->picture_buffer_id() : -1;
   TRACE_EVENT2("Video Decoder", "OVDA::FillBufferDoneTask",
                "Buffer id", buffer->nTimeStamp,
                "Picture id", picture_buffer_id);
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_GT(output_buffers_at_component_, 0);
   --output_buffers_at_component_;
 
   if (fake_output_buffers_.size() && fake_output_buffers_.count(buffer)) {
-    CHECK_EQ(fake_output_buffers_.erase(buffer), 1U);
+    DCHECK_EQ(fake_output_buffers_.erase(buffer), 1U);
     OMX_ERRORTYPE result =
         OMX_FreeBuffer(component_handle_, output_port_, buffer);
     RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer failed", PLATFORM_FAILURE,);
     return;
   }
-  CHECK(!fake_output_buffers_.size());
+  DCHECK(!fake_output_buffers_.size());
 
   if (buffer->nFlags & OMX_BUFFERFLAG_EOS) {
     // Avoid sending the (fake) EOS buffer to the client.
     return;
   }
 
   // During the transition from Executing to Idle, and during port-flushing, all
   // pictures are sent back through here.  Avoid giving them to the client.
   if (current_state_change_ != NO_TRANSITION &&
       current_state_change_ != FLUSHING) {
@@ skipping 237 matching lines @@
 
 bool OmxVideoDecodeAccelerator::SendCommandToPort(
     OMX_COMMANDTYPE cmd, int port_index) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                          cmd, port_index, 0);
   RETURN_ON_OMX_FAILURE(result, "SendCommand() failed" << cmd,
                         PLATFORM_FAILURE, false);
   return true;
 }