Extend VideoCaptureDevice::Client::OnError() to have a tracked_objects::Location param.

media/capture/video/linux/v4l2_capture_delegate.cc

 // Copyright 2015 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 "media/capture/video/linux/v4l2_capture_delegate.h"
 
 #include <poll.h>
 #include <sys/fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
@@ skipping 162 matching lines @@
     int height,
     float frame_rate,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   DCHECK(client);
   client_ = client.Pass();
 
   // Need to open camera with O_RDWR after Linux kernel 3.3.
   device_fd_.reset(HANDLE_EINTR(open(device_name_.id().c_str(), O_RDWR)));
   if (!device_fd_.is_valid()) {
-    SetErrorState("Failed to open V4L2 device driver file.");
+    SetErrorState(FROM_HERE, "Failed to open V4L2 device driver file.");
     return;
   }
 
   v4l2_capability cap = {};
   if (!((HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_QUERYCAP, &cap)) == 0) &&
         ((cap.capabilities & V4L2_CAP_VIDEO_CAPTURE ||
           cap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE) &&
          !(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT) &&
          !(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT_MPLANE)))) {
     device_fd_.reset();
-    SetErrorState("This is not a V4L2 video capture device");
+    SetErrorState(FROM_HERE, "This is not a V4L2 video capture device");
     return;
   }
 
   // Get supported video formats in preferred order.
   // For large resolutions, favour mjpeg over raw formats.
   const std::list<uint32_t>& desired_v4l2_formats =
       GetListOfUsableFourCcs(width > kMjpegWidth || height > kMjpegHeight);
   std::list<uint32_t>::const_iterator best = desired_v4l2_formats.end();
 
   v4l2_fmtdesc fmtdesc = {};
   fmtdesc.type = capture_type_;
   for (; HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_ENUM_FMT, &fmtdesc)) == 0;
        ++fmtdesc.index) {
     best = std::find(desired_v4l2_formats.begin(), best, fmtdesc.pixelformat);
   }
   if (best == desired_v4l2_formats.end()) {
-    SetErrorState("Failed to find a supported camera format.");
+    SetErrorState(FROM_HERE, "Failed to find a supported camera format.");
     return;
   }
 
   DVLOG(1) << "Chosen pixel format is " << FourccToString(*best);
 
   video_fmt_.type = capture_type_;
   if (!FillV4L2Format(&video_fmt_, width, height, *best)) {
-    SetErrorState("Failed filling in V4L2 Format");
+    SetErrorState(FROM_HERE, "Failed filling in V4L2 Format");
     return;
   }
 
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_S_FMT, &video_fmt_)) < 0) {
-    SetErrorState("Failed to set video capture format");
+    SetErrorState(FROM_HERE, "Failed to set video capture format");
     return;
   }
   const VideoPixelFormat pixel_format =
       V4l2FourCcToChromiumPixelFormat(video_fmt_.fmt.pix.pixelformat);
   if (pixel_format == PIXEL_FORMAT_UNKNOWN) {
-    SetErrorState("Unsupported pixel format");
+    SetErrorState(FROM_HERE, "Unsupported pixel format");
     return;
   }
 
   // Set capture framerate in the form of capture interval.
   v4l2_streamparm streamparm = {};
   streamparm.type = capture_type_;
   // The following line checks that the driver knows about framerate get/set.
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_G_PARM, &streamparm)) >= 0) {
     // Now check if the device is able to accept a capture framerate set.
     if (streamparm.parm.capture.capability & V4L2_CAP_TIMEPERFRAME) {
       // |frame_rate| is float, approximate by a fraction.
       streamparm.parm.capture.timeperframe.numerator =
           media::kFrameRatePrecision;
       streamparm.parm.capture.timeperframe.denominator =
           (frame_rate) ? (frame_rate * media::kFrameRatePrecision)
                        : (kTypicalFramerate * media::kFrameRatePrecision);
 
       if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_S_PARM, &streamparm)) <
           0) {
-        SetErrorState("Failed to set camera framerate");
+        SetErrorState(FROM_HERE, "Failed to set camera framerate");
         return;
       }
       DVLOG(2) << "Actual camera driverframerate: "
                << streamparm.parm.capture.timeperframe.denominator << "/"
                << streamparm.parm.capture.timeperframe.numerator;
     }
   }
   // TODO(mcasas): what should be done if the camera driver does not allow
   // framerate configuration, or the actual one is different from the desired?
 
@@ skipping 14 matching lines @@
   capture_format_.frame_size.SetSize(video_fmt_.fmt.pix.width,
                                      video_fmt_.fmt.pix.height);
   capture_format_.frame_rate = frame_rate;
   capture_format_.pixel_format = pixel_format;
 
   v4l2_requestbuffers r_buffer = {};
   r_buffer.type = capture_type_;
   r_buffer.memory = V4L2_MEMORY_MMAP;
   r_buffer.count = kNumVideoBuffers;
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_REQBUFS, &r_buffer)) < 0) {
-    SetErrorState("Error requesting MMAP buffers from V4L2");
+    SetErrorState(FROM_HERE, "Error requesting MMAP buffers from V4L2");
     return;
   }
   for (unsigned int i = 0; i < r_buffer.count; ++i) {
     if (!MapAndQueueBuffer(i)) {
-      SetErrorState("Allocate buffer failed");
+      SetErrorState(FROM_HERE, "Allocate buffer failed");
       return;
     }
   }
 
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_STREAMON, &capture_type_)) <
       0) {
-    SetErrorState("VIDIOC_STREAMON failed");
+    SetErrorState(FROM_HERE, "VIDIOC_STREAMON failed");
     return;
   }
 
   is_capturing_ = true;
   // Post task to start fetching frames from v4l2.
   v4l2_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2CaptureDelegate::DoCapture, this));
 }
 
 void V4L2CaptureDelegate::StopAndDeAllocate() {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   // The order is important: stop streaming, clear |buffer_pool_|,
   // thus munmap()ing the v4l2_buffers, and then return them to the OS.
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_STREAMOFF, &capture_type_)) <
       0) {
-    SetErrorState("VIDIOC_STREAMOFF failed");
+    SetErrorState(FROM_HERE, "VIDIOC_STREAMOFF failed");
     return;
   }
 
   buffer_tracker_pool_.clear();
 
   v4l2_requestbuffers r_buffer = {};
   r_buffer.type = capture_type_;
   r_buffer.memory = V4L2_MEMORY_MMAP;
   r_buffer.count = 0;
   if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_REQBUFS, &r_buffer)) < 0)
-    SetErrorState("Failed to VIDIOC_REQBUFS with count = 0");
+    SetErrorState(FROM_HERE, "Failed to VIDIOC_REQBUFS with count = 0");
 
   // At this point we can close the device.
   // This is also needed for correctly changing settings later via VIDIOC_S_FMT.
   device_fd_.reset();
   is_capturing_ = false;
   client_.reset();
 }
 
 void V4L2CaptureDelegate::SetRotation(int rotation) {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
@@ skipping 35 matching lines @@
 void V4L2CaptureDelegate::DoCapture() {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   if (!is_capturing_)
     return;
 
   pollfd device_pfd = {};
   device_pfd.fd = device_fd_.get();
   device_pfd.events = POLLIN;
   const int result = HANDLE_EINTR(poll(&device_pfd, 1, kCaptureTimeoutMs));
   if (result < 0) {
-    SetErrorState("Poll failed");
+    SetErrorState(FROM_HERE, "Poll failed");
     return;
   }
   // Check if poll() timed out; track the amount of times it did in a row and
   // throw an error if it times out too many times.
   if (result == 0) {
     timeout_count_++;
     if (timeout_count_ >= kContinuousTimeoutLimit) {
-      SetErrorState("Multiple continuous timeouts while read-polling.");
+      SetErrorState(FROM_HERE,
+                    "Multiple continuous timeouts while read-polling.");
       timeout_count_ = 0;
       return;
     }
   } else {
     timeout_count_ = 0;
   }
 
   // Deenqueue, send and reenqueue a buffer if the driver has filled one in.
   if (device_pfd.revents & POLLIN) {
     v4l2_buffer buffer;
     FillV4L2Buffer(&buffer, 0);
 
     if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_DQBUF, &buffer)) < 0) {
-      SetErrorState("Failed to dequeue capture buffer");
+      SetErrorState(FROM_HERE, "Failed to dequeue capture buffer");
       return;
     }
 
     SetPayloadSize(buffer_tracker_pool_[buffer.index], buffer);
     SendBuffer(buffer_tracker_pool_[buffer.index], video_fmt_);
 
     if (HANDLE_EINTR(ioctl(device_fd_.get(), VIDIOC_QBUF, &buffer)) < 0) {
-      SetErrorState("Failed to enqueue capture buffer");
+      SetErrorState(FROM_HERE, "Failed to enqueue capture buffer");
       return;
     }
   }
 
   v4l2_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2CaptureDelegate::DoCapture, this));
 }
 
-void V4L2CaptureDelegate::SetErrorState(const std::string& reason) {
+void V4L2CaptureDelegate::SetErrorState(
+    const tracked_objects::Location& from_here,
+    const std::string& reason) {
   DCHECK(v4l2_task_runner_->BelongsToCurrentThread());
   is_capturing_ = false;
-  client_->OnError(reason);
+  client_->OnError(from_here, reason);
 }
 
 }  // namespace media