Change log level to show real errors in release mode

content/common/gpu/media/vaapi_wrapper.cc

 // Copyright 2013 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/vaapi_wrapper.h"
 
 #include <dlfcn.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 // Auto-generated for dlopen libva libraries
 #include "content/common/gpu/media/va_stubs.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 using content_common_gpu_media::kModuleVa;
 using content_common_gpu_media::InitializeStubs;
 using content_common_gpu_media::StubPathMap;
 
 // libva-x11 depends on libva, so dlopen libva-x11 is enough
 static const base::FilePath::CharType kVaLib[] =
     FILE_PATH_LITERAL("libva-x11.so.1");
 
 #define LOG_VA_ERROR_AND_REPORT(va_error, err_msg)         \
   do {                                                     \
-    DVLOG(1) << err_msg                                    \
+    LOG(ERROR) << err_msg                                  \
              << " VA error: " << vaErrorStr(va_error);     \
     report_error_to_uma_cb_.Run();                         \
   } while (0)
 
 #define VA_LOG_ON_ERROR(va_error, err_msg)                 \
   do {                                                     \
     if ((va_error) != VA_STATUS_SUCCESS)                   \
       LOG_VA_ERROR_AND_REPORT(va_error, err_msg);          \
   } while (0)
 
@@ skipping 112 matching lines @@
   if (va_res != VA_STATUS_SUCCESS)
     DVLOG(2) << "vaSetDisplayAttributes unsupported, ignoring by default.";
 }
 
 bool VaapiWrapper::Initialize(CodecMode mode,
                               media::VideoCodecProfile profile,
                               Display* x_display,
                               const base::Closure& report_error_to_uma_cb) {
   static bool vaapi_functions_initialized = PostSandboxInitialization();
   if (!vaapi_functions_initialized) {
-    DVLOG(1) << "Failed to initialize VAAPI libs";
+    LOG(ERROR) << "Failed to initialize VAAPI libs";
     return false;
   }
 
   report_error_to_uma_cb_ = report_error_to_uma_cb;
 
   base::AutoLock auto_lock(va_lock_);
 
   va_display_ = vaGetDisplay(x_display);
   if (!vaDisplayIsValid(va_display_)) {
-    DVLOG(1) << "Could not get a valid VA display";
+    LOG(ERROR) << "Could not get a valid VA display";
     return false;
   }
 
   VAStatus va_res = vaInitialize(va_display_, &major_version_, &minor_version_);
   VA_SUCCESS_OR_RETURN(va_res, "vaInitialize failed", false);
   DVLOG(1) << "VAAPI version: " << major_version_ << "." << minor_version_;
 
   if (VAAPIVersionLessThan(0, 34)) {
-    DVLOG(1) << "VAAPI version < 0.34 is not supported.";
+    LOG(ERROR) << "VAAPI version < 0.34 is not supported.";
     return false;
   }
 
   // Query the driver for supported profiles.
   int max_profiles = vaMaxNumProfiles(va_display_);
   std::vector<VAProfile> supported_profiles(
       base::checked_cast<size_t>(max_profiles));
 
   int num_supported_profiles;
   va_res = vaQueryConfigProfiles(
       va_display_, &supported_profiles[0], &num_supported_profiles);
   VA_SUCCESS_OR_RETURN(va_res, "vaQueryConfigProfiles failed", false);
   if (num_supported_profiles < 0 || num_supported_profiles > max_profiles) {
-    DVLOG(1) << "vaQueryConfigProfiles returned: " << num_supported_profiles;
+    LOG(ERROR) << "vaQueryConfigProfiles returned: " << num_supported_profiles;
     return false;
   }
 
   supported_profiles.resize(base::checked_cast<size_t>(num_supported_profiles));
 
   VAProfile va_profile = ProfileToVAProfile(profile, supported_profiles);
   if (va_profile == VAProfileNone) {
-    DVLOG(1) << "Unsupported profile";
+    LOG(ERROR) << "Unsupported profile";

[Pawel Osciak, 2014/10/02 08:58:53]

This is not an ERROR, will happen on devices that don't support a profile
normally.

     return false;
   }
 
   // Query the driver for supported entrypoints.
   int max_entrypoints = vaMaxNumEntrypoints(va_display_);
   std::vector<VAEntrypoint> supported_entrypoints(
       base::checked_cast<size_t>(max_entrypoints));
 
   int num_supported_entrypoints;
   va_res = vaQueryConfigEntrypoints(va_display_,
                                     va_profile,
                                     &supported_entrypoints[0],
                                     &num_supported_entrypoints);
   VA_SUCCESS_OR_RETURN(va_res, "vaQueryConfigEntrypoints failed", false);
   if (num_supported_entrypoints < 0 ||
       num_supported_entrypoints > max_entrypoints) {
-    DVLOG(1) << "vaQueryConfigEntrypoints returned: "
-             << num_supported_entrypoints;
+    LOG(ERROR) << "vaQueryConfigEntrypoints returned: "
+               << num_supported_entrypoints;
     return false;
   }
 
   VAEntrypoint entrypoint =
       (mode == kEncode ? VAEntrypointEncSlice : VAEntrypointVLD);
 
   if (std::find(supported_entrypoints.begin(),
                 supported_entrypoints.end(),
                 entrypoint) == supported_entrypoints.end()) {
-    DVLOG(1) << "Unsupported entrypoint";
+    LOG(ERROR) << "Unsupported entrypoint";

[Pawel Osciak, 2014/10/02 08:58:53]

Ditto.

     return false;
   }
 
   // Query the driver for required attributes.
   std::vector<VAConfigAttrib> required_attribs;
   required_attribs.insert(
       required_attribs.end(),
       kCommonVAConfigAttribs,
       kCommonVAConfigAttribs + arraysize(kCommonVAConfigAttribs));
   if (mode == kEncode) {
     required_attribs.insert(
         required_attribs.end(),
         kEncodeVAConfigAttribs,
         kEncodeVAConfigAttribs + arraysize(kEncodeVAConfigAttribs));
   }
 
   std::vector<VAConfigAttrib> attribs = required_attribs;
   for (size_t i = 0; i < required_attribs.size(); ++i)
     attribs[i].value = 0;
 
   va_res = vaGetConfigAttributes(
       va_display_, va_profile, entrypoint, &attribs[0], attribs.size());
   VA_SUCCESS_OR_RETURN(va_res, "vaGetConfigAttributes failed", false);
 
   for (size_t i = 0; i < required_attribs.size(); ++i) {
     if (attribs[i].type != required_attribs[i].type ||
         (attribs[i].value & required_attribs[i].value) !=
             required_attribs[i].value) {
-      DVLOG(1) << "Unsupported value " << required_attribs[i].value
-               << " for attribute type " << required_attribs[i].type;
+      LOG(ERROR) << "Unsupported value " << required_attribs[i].value

[Pawel Osciak, 2014/10/02 08:58:54]

Also not an error to report.

+                 << " for attribute type " << required_attribs[i].type;
       return false;
     }
   }
 
   TryToSetVADisplayAttributeToLocalGPU();
 
   va_res = vaCreateConfig(va_display_,
                           va_profile,
                           entrypoint,
                           &required_attribs[0],
@@ skipping 301 matching lines @@
     VASurfaceID va_surface_id) {
   base::AutoLock auto_lock(va_lock_);
 
   VAImage image;
   VAStatus va_res = vaDeriveImage(va_display_, va_surface_id, &image);
   VA_SUCCESS_OR_RETURN(va_res, "vaDeriveImage failed", false);
   base::ScopedClosureRunner vaimage_deleter(
       base::Bind(&DestroyVAImage, va_display_, image));
 
   if (image.format.fourcc != VA_FOURCC_NV12) {
-    DVLOG(1) << "Unsupported image format: " << image.format.fourcc;
+    LOG(ERROR) << "Unsupported image format: " << image.format.fourcc;
     return false;
   }
 
   if (gfx::Rect(image.width, image.height) < gfx::Rect(frame->coded_size())) {
-    DVLOG(1) << "Buffer too small to fit the frame.";
+    LOG(ERROR) << "Buffer too small to fit the frame.";
     return false;
   }
 
   void* image_ptr = NULL;
   va_res = vaMapBuffer(va_display_, image.buf, &image_ptr);
   VA_SUCCESS_OR_RETURN(va_res, "vaMapBuffer failed", false);
   DCHECK(image_ptr);
 
   int ret = 0;
   {
@@ skipping 70 matching lines @@
 
 // static
 bool VaapiWrapper::PostSandboxInitialization() {
   StubPathMap paths;
   paths[kModuleVa].push_back(kVaLib);
 
   return InitializeStubs(paths);
 }
 
 }  // namespace content