Change log level to show real errors in release mode

content/common/gpu/media/v4l2_video_device.cc

 // Copyright 2014 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 <linux/videodev2.h>
 
 #include "base/numerics/safe_conversions.h"
 #include "content/common/gpu/media/exynos_v4l2_video_device.h"
 #include "content/common/gpu/media/tegra_v4l2_video_device.h"
 
 namespace content {
 
 V4L2Device::~V4L2Device() {}
 
 // static
 scoped_ptr<V4L2Device> V4L2Device::Create(Type type) {
   DVLOG(3) << __PRETTY_FUNCTION__;
 
   scoped_ptr<ExynosV4L2Device> exynos_device(new ExynosV4L2Device(type));
   if (exynos_device->Initialize())
     return exynos_device.PassAs<V4L2Device>();
 
   scoped_ptr<TegraV4L2Device> tegra_device(new TegraV4L2Device(type));
   if (tegra_device->Initialize())
     return tegra_device.PassAs<V4L2Device>();
 
-  DLOG(ERROR) << "Failed to create V4L2Device";
+  LOG(ERROR) << "Failed to create V4L2Device";
   return scoped_ptr<V4L2Device>();
 }
 
 // static
 media::VideoFrame::Format V4L2Device::V4L2PixFmtToVideoFrameFormat(
     uint32 pix_fmt) {
   switch (pix_fmt) {
     case V4L2_PIX_FMT_NV12:
     case V4L2_PIX_FMT_NV12M:
       return media::VideoFrame::NV12;
@@ skipping 68 matching lines @@
 
   int horiz_bpp =
       media::VideoFrame::PlaneHorizontalBitsPerPixel(frame_format, 0);
   DVLOG(3) << __func__ << ": bytesperline=" << bytesperline
            << ", sizeimage=" << sizeimage
            << ", visible_size=" << visible_size.ToString() << ", frame_format="
            << media::VideoFrame::FormatToString(frame_format)
            << ", horiz_bpp=" << horiz_bpp;
   if (sizeimage == 0 || bytesperline == 0 || horiz_bpp == 0 ||
       (bytesperline * 8) % horiz_bpp != 0) {
-    DLOG(ERROR) << "Invalid format provided";
+    LOG(ERROR) << "Invalid format provided";
     return coded_size;
   }
 
   // Round up sizeimage to full bytesperlines. sizeimage does not have to be
   // a multiple of bytesperline, as in V4L2 terms it's just a byte size of
   // the buffer, unrelated to its payload.
   sizeimage = ((sizeimage + bytesperline - 1) / bytesperline) * bytesperline;
 
   coded_size.SetSize(bytesperline * 8 / horiz_bpp, sizeimage / bytesperline);
   DVLOG(3) << "coded_size=" << coded_size.ToString();
 
   // Sanity checks. Calculated coded size has to contain given visible size
   // and fulfill buffer byte size requirements for each plane.
   DCHECK(gfx::Rect(coded_size).Contains(gfx::Rect(visible_size)));
 
   if (V4L2_TYPE_IS_MULTIPLANAR(format.type)) {
     for (size_t i = 0; i < format.fmt.pix_mp.num_planes; ++i) {
       DCHECK_EQ(format.fmt.pix_mp.plane_fmt[i].bytesperline,
                 base::checked_cast<__u32>(media::VideoFrame::RowBytes(
                     i, frame_format, coded_size.width())));
     }
   }
 
   return coded_size;
 }
 
 }  //  namespace content