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

media/capture/video/win/video_capture_device_win.cc

 // 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/win/video_capture_device_win.h"
 
 #include <ks.h>
 #include <ksmedia.h>
 
 #include <algorithm>
@@ skipping 330 matching lines @@
 
   // Reduce the frame rate if the requested frame rate is lower
   // than the capability.
   const float frame_rate =
       std::min(params.requested_format.frame_rate,
                found_capability.supported_format.frame_rate);
 
   ScopedComPtr<IAMStreamConfig> stream_config;
   HRESULT hr = output_capture_pin_.QueryInterface(stream_config.Receive());
   if (FAILED(hr)) {
-    SetErrorState("Can't get the Capture format settings");
+    SetErrorState(FROM_HERE, "Can't get the Capture format settings");
     return;
   }
 
   int count = 0, size = 0;
   hr = stream_config->GetNumberOfCapabilities(&count, &size);
   if (FAILED(hr)) {
-    SetErrorState("Failed to GetNumberOfCapabilities");
+    SetErrorState(FROM_HERE, "Failed to GetNumberOfCapabilities");
     return;
   }
 
   scoped_ptr<BYTE[]> caps(new BYTE[size]);
   ScopedMediaType media_type;
 
   // Get the windows capability from the capture device.
   // GetStreamCaps can return S_FALSE which we consider an error. Therefore the
   // FAILED macro can't be used.
   hr = stream_config->GetStreamCaps(found_capability.stream_index,
                                     media_type.Receive(), caps.get());
   if (hr != S_OK) {
-    SetErrorState("Failed to get capture device capabilities");
+    SetErrorState(FROM_HERE, "Failed to get capture device capabilities");
     return;
   }
   if (media_type->formattype == FORMAT_VideoInfo) {
     VIDEOINFOHEADER* h =
         reinterpret_cast<VIDEOINFOHEADER*>(media_type->pbFormat);
     if (frame_rate > 0)
       h->AvgTimePerFrame = kSecondsToReferenceTime / frame_rate;
   }
   // Set the sink filter to request this format.
   sink_filter_->SetRequestedMediaFormat(
       found_capability.supported_format.pixel_format, frame_rate,
       found_capability.info_header);
   // Order the capture device to use this format.
   hr = stream_config->SetFormat(media_type.get());
   if (FAILED(hr)) {
     // TODO(grunell): Log the error. http://crbug.com/405016.
-    SetErrorState("Failed to set capture device output format");
+    SetErrorState(FROM_HERE, "Failed to set capture device output format");
     return;
   }
 
   SetAntiFlickerInCaptureFilter(params);
 
   if (media_type->subtype == kMediaSubTypeHDYC) {
     // HDYC pixel format, used by the DeckLink capture card, needs an AVI
     // decompressor filter after source, let |graph_builder_| add it.
     hr = graph_builder_->Connect(output_capture_pin_.get(),
                                  input_sink_pin_.get());
   } else {
     hr = graph_builder_->ConnectDirect(output_capture_pin_.get(),
                                        input_sink_pin_.get(), NULL);
   }
 
   if (FAILED(hr)) {
-    SetErrorState("Failed to connect the Capture graph.");
+    SetErrorState(FROM_HERE, "Failed to connect the Capture graph.");
     return;
   }
 
   hr = media_control_->Pause();
   if (FAILED(hr)) {
     SetErrorState(
+        FROM_HERE,
         "Failed to pause the Capture device, is it already occupied?");
     return;
   }
 
   // Get the format back from the sink filter after the filter have been
   // connected.
   capture_format_ = sink_filter_->ResultingFormat();
 
   // Start capturing.
   hr = media_control_->Run();
   if (FAILED(hr)) {
-    SetErrorState("Failed to start the Capture device.");
+    SetErrorState(FROM_HERE, "Failed to start the Capture device.");
     return;
   }
 
   state_ = kCapturing;
 }
 
 void VideoCaptureDeviceWin::StopAndDeAllocate() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (state_ != kCapturing)
     return;
 
   HRESULT hr = media_control_->Stop();
   if (FAILED(hr)) {
-    SetErrorState("Failed to stop the capture graph.");
+    SetErrorState(FROM_HERE, "Failed to stop the capture graph.");
     return;
   }
 
   graph_builder_->Disconnect(output_capture_pin_.get());
   graph_builder_->Disconnect(input_sink_pin_.get());
 
   client_.reset();
   state_ = kIdle;
 }
 
@@ skipping 117 matching lines @@
                          KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY, &data,
                          sizeof(data), &data, sizeof(data));
     DLOG_IF(ERROR, FAILED(hr)) << "Anti-flicker setting failed: "
                                << logging::SystemErrorCodeToString(hr);
     DVLOG_IF(2, SUCCEEDED(hr)) << "Anti-flicker set correctly.";
   } else {
     DVLOG(2) << "Anti-flicker setting not supported.";
   }
 }
 
-void VideoCaptureDeviceWin::SetErrorState(const std::string& reason) {
+void VideoCaptureDeviceWin::SetErrorState(
+    const tracked_objects::Location& from_here,
+    const std::string& reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   state_ = kError;
-  client_->OnError(reason);
+  client_->OnError(from_here, reason);
 }
 }  // namespace media