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

media/capture/video/mac/video_capture_device_mac.mm

 // 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 "media/capture/video/mac/video_capture_device_mac.h"
 
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USBSpec.h>
 
@@ skipping 363 matching lines @@
   if (device_name_.capture_api_type() == Name::AVFOUNDATION)
     LogMessage("Using AVFoundation for device: " + device_name_.name());
   else
     LogMessage("Using QTKit for device: " + device_name_.name());
   NSString* deviceId =
       [NSString stringWithUTF8String:device_name_.id().c_str()];
 
   [capture_device_ setFrameReceiver:this];
 
   if (![capture_device_ setCaptureDevice:deviceId]) {
-    SetErrorState("Could not open capture device.");
+    SetErrorState(FROM_HERE, "Could not open capture device.");
     return;
   }
 
   capture_format_.frame_size = resolution;
   capture_format_.frame_rate =
       std::max(kMinFrameRate,
                std::min(params.requested_format.frame_rate, kMaxFrameRate));
   // Leave the pixel format selection to AVFoundation/QTKit. The pixel format
   // will be passed to |ReceiveFrame|.
   capture_format_.pixel_format = PIXEL_FORMAT_UNKNOWN;
@@ skipping 20 matching lines @@
     std::string model_id = device_model.substr(kVidPidSize + 1);
     int vendor_id_as_int, model_id_as_int;
     if (base::HexStringToInt(base::StringPiece(vendor_id), &vendor_id_as_int) &&
         base::HexStringToInt(base::StringPiece(model_id), &model_id_as_int)) {
       SetAntiFlickerInUsbDevice(vendor_id_as_int, model_id_as_int,
                                 GetPowerLineFrequency(params));
     }
   }
 
   if (![capture_device_ startCapture]) {
-    SetErrorState("Could not start capture device.");
+    SetErrorState(FROM_HERE, "Could not start capture device.");
     return;
   }
 
   state_ = kCapturing;
 }
 
 void VideoCaptureDeviceMac::StopAndDeAllocate() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == kCapturing || state_ == kError) << state_;
 
@@ skipping 87 matching lines @@
       return;
     }
   }
 
   // QTKit capture source can change resolution if someone else reconfigures the
   // camera, and that is fine: http://crbug.com/353620. In AVFoundation, this
   // should not happen, it should resize internally.
   if (!AVFoundationGlue::IsAVFoundationSupported()) {
     capture_format_.frame_size = frame_format.frame_size;
   } else if (capture_format_.frame_size != frame_format.frame_size) {
-    ReceiveError("Captured resolution " + frame_format.frame_size.ToString() +
-                 ", and expected " + capture_format_.frame_size.ToString());
+    ReceiveError(FROM_HERE,
+                 "Captured resolution " + frame_format.frame_size.ToString() +
+                     ", and expected " + capture_format_.frame_size.ToString());
     return;
   }
 
   client_->OnIncomingCapturedData(video_frame, video_frame_length, frame_format,
                                   0, base::TimeTicks::Now());
 }
 
-void VideoCaptureDeviceMac::ReceiveError(const std::string& reason) {
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&VideoCaptureDeviceMac::SetErrorState,
-                                    weak_factory_.GetWeakPtr(), reason));
+void VideoCaptureDeviceMac::ReceiveError(
+    const tracked_objects::Location& from_here,
+    const std::string& reason) {
+  task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoCaptureDeviceMac::SetErrorState,
+                            weak_factory_.GetWeakPtr(), from_here, reason));
 }
 
-void VideoCaptureDeviceMac::SetErrorState(const std::string& reason) {
+void VideoCaptureDeviceMac::SetErrorState(
+    const tracked_objects::Location& from_here,
+    const std::string& reason) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   state_ = kError;
-  client_->OnError(reason);
+  client_->OnError(from_here, reason);
 }
 
 void VideoCaptureDeviceMac::LogMessage(const std::string& message) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (client_)
     client_->OnLog(message);
 }
 
 bool VideoCaptureDeviceMac::UpdateCaptureResolution() {
   if (![capture_device_ setCaptureHeight:capture_format_.frame_size.height()
                                    width:capture_format_.frame_size.width()
                                frameRate:capture_format_.frame_rate]) {
-    ReceiveError("Could not configure capture device.");
+    ReceiveError(FROM_HERE, "Could not configure capture device.");
     return false;
   }
   return true;
 }
 
 }  // namespace media