Change log level to show real errors in release mode

content/common/gpu/media/v4l2_image_processor.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 <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
 #include "content/common/gpu/media/v4l2_image_processor.h"
 #include "media/base/bind_to_current_loop.h"
 
 #define NOTIFY_ERROR()                      \
   do {                                      \
-    DLOG(ERROR) << "calling NotifyError()"; \
+    LOG(ERROR) << "calling NotifyError()";  \
     NotifyError();                          \
   } while (0)
 
 #define IOCTL_OR_ERROR_RETURN_VALUE(type, arg, value)              \
   do {                                                             \
     if (device_->Ioctl(type, arg) != 0) {                          \
-      DPLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type; \
+      PLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type;  \
       return value;                                                \
     }                                                              \
   } while (0)
 
 #define IOCTL_OR_ERROR_RETURN(type, arg) \
   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, ((void)0))
 
 #define IOCTL_OR_ERROR_RETURN_FALSE(type, arg) \
   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, false)
 
 #define IOCTL_OR_LOG_ERROR(type, arg)                              \
   do {                                                             \
     if (device_->Ioctl(type, arg) != 0)                            \
-      DPLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type; \
+      PLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type;  \
   } while (0)
 
 namespace content {
 
 V4L2ImageProcessor::InputRecord::InputRecord() : at_device(false) {
 }
 
 V4L2ImageProcessor::OutputRecord::OutputRecord()
     : at_device(false), at_client(false) {
 }
@@ skipping 49 matching lines @@
   DCHECK_EQ(input_format, media::VideoFrame::I420);
   DCHECK_EQ(output_format, media::VideoFrame::NV12);
 
   input_format_ = input_format;
   output_format_ = output_format;
   input_format_fourcc_ = V4L2Device::VideoFrameFormatToV4L2PixFmt(input_format);
   output_format_fourcc_ =
       V4L2Device::VideoFrameFormatToV4L2PixFmt(output_format);
 
   if (!input_format_fourcc_ || !output_format_fourcc_) {
-    DLOG(ERROR) << "Unrecognized format(s)";
+    LOG(ERROR) << "Unrecognized format(s)";
     return false;
   }
 
   input_visible_size_ = input_visible_size;
   output_visible_size_ = output_visible_size;
   output_allocated_size_ = output_allocated_size;
 
   input_planes_count_ = media::VideoFrame::NumPlanes(input_format);
   DCHECK_LE(input_planes_count_, static_cast<size_t>(VIDEO_MAX_PLANES));
   output_planes_count_ = media::VideoFrame::NumPlanes(output_format);
   DCHECK_LE(output_planes_count_, static_cast<size_t>(VIDEO_MAX_PLANES));
 
   // Capabilities check.
   struct v4l2_capability caps;
   memset(&caps, 0, sizeof(caps));
   const __u32 kCapsRequired = V4L2_CAP_VIDEO_CAPTURE_MPLANE |
                               V4L2_CAP_VIDEO_OUTPUT_MPLANE | V4L2_CAP_STREAMING;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
-    DLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
-                   "caps check failed: 0x" << std::hex << caps.capabilities;
+    LOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
+                  "caps check failed: 0x" << std::hex << caps.capabilities;
     return false;
   }
 
   if (!CreateInputBuffers() || !CreateOutputBuffers())
     return false;
 
   if (!device_thread_.Start()) {
-    DLOG(ERROR) << "Initialize(): encoder thread failed to start";
+    LOG(ERROR) << "Initialize(): encoder thread failed to start";
     return false;
   }
 
   // StartDevicePoll will NOTIFY_ERROR on failure, so IgnoreResult is fine here.
   device_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(base::IgnoreResult(&V4L2ImageProcessor::StartDevicePoll),
                  base::Unretained(this)));
 
   DVLOG(1) << "V4L2ImageProcessor initialized for "
@@ skipping 343 matching lines @@
     memset(&planes, 0, sizeof(planes));
     dqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
     dqbuf.memory = V4L2_MEMORY_USERPTR;
     dqbuf.m.planes = planes;
     dqbuf.length = input_planes_count_;
     if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
       if (errno == EAGAIN) {
         // EAGAIN if we're just out of buffers to dequeue.
         break;
       }
-      DPLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
+      PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR();
       return;
     }
     InputRecord& input_record = input_buffer_map_[dqbuf.index];
     DCHECK(input_record.at_device);
     input_record.at_device = false;
     input_record.frame = NULL;
     free_input_buffers_.push_back(dqbuf.index);
     input_buffer_queued_count_--;
   }
 
   // Dequeue completed output (VIDEO_CAPTURE) buffers, recycle to the free list.
   // Return the finished buffer to the client via the job ready callback.
   while (output_buffer_queued_count_ > 0) {
     DCHECK(output_streamon_);
     memset(&dqbuf, 0, sizeof(dqbuf));
     memset(&planes, 0, sizeof(planes));
     dqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
     dqbuf.memory = V4L2_MEMORY_DMABUF;
     dqbuf.m.planes = planes;
     dqbuf.length = output_planes_count_;
     if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
       if (errno == EAGAIN) {
         // EAGAIN if we're just out of buffers to dequeue.
         break;
       }
-      DPLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
+      PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR();
       return;
     }
     OutputRecord& output_record = output_buffer_map_[dqbuf.index];
     DCHECK(output_record.at_device);
     output_record.at_device = false;
     output_record.at_client = true;
     output_buffer_queued_count_--;
 
     // Jobs are always processed in FIFO order.
@@ skipping 97 matching lines @@
   return true;
 }
 
 bool V4L2ImageProcessor::StartDevicePoll() {
   DVLOG(3) << __func__ << ": starting device poll";
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
   DCHECK(!device_poll_thread_.IsRunning());
 
   // Start up the device poll thread and schedule its first DevicePollTask().
   if (!device_poll_thread_.Start()) {
-    DLOG(ERROR) << "StartDevicePoll(): Device thread failed to start";
+    LOG(ERROR) << "StartDevicePoll(): Device thread failed to start";
     NOTIFY_ERROR();
     return false;
   }
   // Enqueue a poll task with no devices to poll on - will wait only for the
   // poll interrupt
   device_poll_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(
           &V4L2ImageProcessor::DevicePollTask, base::Unretained(this), false));
 
@@ skipping 48 matching lines @@
     output_record.at_device = false;
     if (!output_record.at_client)
       free_output_buffers_.push_back(i);
   }
   output_buffer_queued_count_ = 0;
 
   return true;
 }
 
 }  // namespace content