Change log level to show real errors in release mode

content/common/gpu/media/vaapi_video_decode_accelerator.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 "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
@@ skipping 12 matching lines @@
       "Media.VAVDAH264.DecoderFailure",
       failure,
       content::VaapiH264Decoder::VAVDA_H264_DECODER_FAILURES_MAX);
 }
 
 namespace content {
 
 #define RETURN_AND_NOTIFY_ON_FAILURE(result, log, error_code, ret)  \
   do {                                                              \
     if (!(result)) {                                                \
-      DVLOG(1) << log;                                              \
+      LOG(ERROR) << log;                                            \
       NotifyError(error_code);                                      \
       return ret;                                                   \
     }                                                               \
   } while (0)
 
 VaapiVideoDecodeAccelerator::InputBuffer::InputBuffer() : id(0), size(0) {
 }
 
 VaapiVideoDecodeAccelerator::InputBuffer::~InputBuffer() {
 }
 
 void VaapiVideoDecodeAccelerator::NotifyError(Error error) {
   if (message_loop_ != base::MessageLoop::current()) {
     DCHECK(decoder_thread_proxy_->BelongsToCurrentThread());
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &VaapiVideoDecodeAccelerator::NotifyError, weak_this_, error));
     return;
   }
 
   // Post Cleanup() as a task so we don't recursively acquire lock_.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &VaapiVideoDecodeAccelerator::Cleanup, weak_this_));
 
-  DVLOG(1) << "Notifying of error " << error;
+  LOG(ERROR) << "Notifying of error " << error;
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.reset();
   }
 }
 
 // TFPPicture allocates X Pixmaps and binds them to textures passed
 // in PictureBuffers from clients to them. TFPPictures are created as
 // a consequence of receiving a set of PictureBuffers from clients and released
 // at the end of decode (or when a new set of PictureBuffers is required).
@@ skipping 94 matching lines @@
   if (!make_context_current_.Run())
     return false;
 
   XWindowAttributes win_attr;
   int screen = DefaultScreen(x_display_);
   XGetWindowAttributes(x_display_, RootWindow(x_display_, screen), &win_attr);
   //TODO(posciak): pass the depth required by libva, not the RootWindow's depth
   x_pixmap_ = XCreatePixmap(x_display_, RootWindow(x_display_, screen),
                             size_.width(), size_.height(), win_attr.depth);
   if (!x_pixmap_) {
-    DVLOG(1) << "Failed creating an X Pixmap for TFP";
+    LOG(ERROR) << "Failed creating an X Pixmap for TFP";
     return false;
   }
 
   static const int pixmap_attr[] = {
     GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
     GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
     GL_NONE,
   };
 
   glx_pixmap_ = glXCreatePixmap(x_display_, fb_config, x_pixmap_, pixmap_attr);
   if (!glx_pixmap_) {
     // x_pixmap_ will be freed in the destructor.
-    DVLOG(1) << "Failed creating a GLX Pixmap for TFP";
+    LOG(ERROR) << "Failed creating a GLX Pixmap for TFP";
     return false;
   }
 
   return true;
 }
 
 VaapiVideoDecodeAccelerator::TFPPicture::~TFPPicture() {
   DCHECK(CalledOnValidThread());
   // Unbind surface from texture and deallocate resources.
   if (glx_pixmap_ && make_context_current_.Run()) {
@@ skipping 16 matching lines @@
   gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, texture_id_);
   glXBindTexImageEXT(x_display_, glx_pixmap_, GLX_FRONT_LEFT_EXT, NULL);
 
   return true;
 }
 
 VaapiVideoDecodeAccelerator::TFPPicture*
     VaapiVideoDecodeAccelerator::TFPPictureById(int32 picture_buffer_id) {
   TFPPictures::iterator it = tfp_pictures_.find(picture_buffer_id);
   if (it == tfp_pictures_.end()) {
-    DVLOG(1) << "Picture id " << picture_buffer_id << " does not exist";
+    LOG(ERROR) << "Picture id " << picture_buffer_id << " does not exist";
     return NULL;
   }
 
   return it->second.get();
 }
 
 VaapiVideoDecodeAccelerator::VaapiVideoDecodeAccelerator(
     Display* x_display,
     const base::Callback<bool(void)>& make_context_current)
     : x_display_(x_display),
@@ skipping 55 matching lines @@
   client_ = client_ptr_factory_->GetWeakPtr();
 
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kUninitialized);
   DVLOG(2) << "Initializing VAVDA, profile: " << profile;
 
   if (!make_context_current_.Run())
     return false;
 
   if (!InitializeFBConfig()) {
-    DVLOG(1) << "Could not get a usable FBConfig";
+    LOG(ERROR) << "Could not get a usable FBConfig";
     return false;
   }
 
   vaapi_wrapper_ = VaapiWrapper::Create(
       VaapiWrapper::kDecode,
       profile,
       x_display_,
       base::Bind(&ReportToUMA, content::VaapiH264Decoder::VAAPI_ERROR));
 
   if (!vaapi_wrapper_.get()) {
-    DVLOG(1) << "Failed initializing VAAPI";
+    LOG(ERROR) << "Failed initializing VAAPI";
     return false;
   }
 
   decoder_.reset(
       new VaapiH264Decoder(
           vaapi_wrapper_.get(),
           media::BindToCurrentLoop(base::Bind(
               &VaapiVideoDecodeAccelerator::SurfaceReady, weak_this_)),
           base::Bind(&ReportToUMA)));
 
@@ skipping 597 matching lines @@
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   Cleanup();
   delete this;
 }
 
 bool VaapiVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 }  // namespace content