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

media/capture/video/mac/video_capture_device_decklink_mac.mm

 // 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 "media/capture/video/mac/video_capture_device_decklink_mac.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/synchronization/lock.h"
@@ skipping 51 matching lines @@
   HRESULT VideoInputFrameArrived(
       IDeckLinkVideoInputFrame* video_frame,
       IDeckLinkAudioInputPacket* audio_packet) override;
 
   // IUnknown interface implementation.
   HRESULT QueryInterface(REFIID iid, void** ppv) override;
   ULONG AddRef() override;
   ULONG Release() override;
 
   // Forwarder to VideoCaptureDeviceDeckLinkMac::SendErrorString().
-  void SendErrorString(const std::string& reason);
+  void SendErrorString(const tracked_objects::Location& from_here,
+                       const std::string& reason);
 
   // Forwarder to VideoCaptureDeviceDeckLinkMac::SendLogString().
   void SendLogString(const std::string& message);
 
   const media::VideoCaptureDevice::Name device_name_;
 
   // Protects concurrent setting and using of |frame_receiver_|.
   base::Lock lock_;
   // Weak reference to the captured frames client, used also for error messages
   // and logging. Initialized on construction and used until cleared by calling
@@ skipping 53 matching lines @@
 
   ScopedDeckLinkPtr<IDeckLink> decklink_local;
   while (decklink_iter->Next(decklink_local.Receive()) == S_OK) {
     CFStringRef device_model_name = NULL;
     if ((decklink_local->GetModelName(&device_model_name) == S_OK) ||
         (device_name_.id() == base::SysCFStringRefToUTF8(device_model_name))) {
       break;
     }
   }
   if (!decklink_local.get()) {
-    SendErrorString("Device id not found in the system");
+    SendErrorString(FROM_HERE, "Device id not found in the system");
     return;
   }
 
   ScopedDeckLinkPtr<IDeckLinkInput> decklink_input_local;
   if (decklink_local->QueryInterface(
           IID_IDeckLinkInput, decklink_input_local.ReceiveVoid()) != S_OK) {
-    SendErrorString("Error querying input interface.");
+    SendErrorString(FROM_HERE, "Error querying input interface.");
     return;
   }
 
   ScopedDeckLinkPtr<IDeckLinkDisplayModeIterator> display_mode_iter;
   if (decklink_input_local->GetDisplayModeIterator(
           display_mode_iter.Receive()) != S_OK) {
-    SendErrorString("Error creating Display Mode Iterator");
+    SendErrorString(FROM_HERE, "Error creating Display Mode Iterator");
     return;
   }
 
   ScopedDeckLinkPtr<IDeckLinkDisplayMode> chosen_display_mode;
   ScopedDeckLinkPtr<IDeckLinkDisplayMode> display_mode;
   float min_diff = FLT_MAX;
   while (display_mode_iter->Next(display_mode.Receive()) == S_OK) {
     const float diff = labs(display_mode->GetWidth() -
                             params.requested_format.frame_size.width()) +
                        labs(params.requested_format.frame_size.height() -
                             display_mode->GetHeight()) +
                        fabs(params.requested_format.frame_rate -
                             GetDisplayModeFrameRate(display_mode));
     if (diff < min_diff) {
       chosen_display_mode = display_mode;
       min_diff = diff;
     }
     display_mode.Release();
   }
   if (!chosen_display_mode.get()) {
-    SendErrorString("Could not find a display mode");
+    SendErrorString(FROM_HERE, "Could not find a display mode");
     return;
   }
 #if !defined(NDEBUG)
   DVLOG(1) << "Requested format: "
            << media::VideoCaptureFormat::ToString(params.requested_format);
   CFStringRef format_name = NULL;
   if (chosen_display_mode->GetName(&format_name) == S_OK)
     DVLOG(1) << "Chosen format: " << base::SysCFStringRefToUTF8(format_name);
 #endif
 
   // Enable video input. Configure for no input video format change detection,
   // this in turn will disable calls to VideoInputFormatChanged().
   if (decklink_input_local->EnableVideoInput(
           chosen_display_mode->GetDisplayMode(), bmdFormat8BitYUV,
           bmdVideoInputFlagDefault) != S_OK) {
-    SendErrorString("Could not select the video format we like.");
+    SendErrorString(FROM_HERE, "Could not select the video format we like.");
     return;
   }
 
   decklink_input_local->SetCallback(this);
   if (decklink_input_local->StartStreams() != S_OK)
-    SendErrorString("Could not start capturing");
+    SendErrorString(FROM_HERE, "Could not start capturing");
 
   decklink_.swap(decklink_local);
   decklink_input_.swap(decklink_input_local);
 }
 
 void DeckLinkCaptureDelegate::StopAndDeAllocate() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!decklink_input_.get())
     return;
   if (decklink_input_->StopStreams() != S_OK)
@@ skipping 23 matching lines @@
   media::VideoPixelFormat pixel_format =
       media::PIXEL_FORMAT_UNKNOWN;
   switch (video_frame->GetPixelFormat()) {
     case bmdFormat8BitYUV:  // A.k.a. '2vuy';
       pixel_format = media::PIXEL_FORMAT_UYVY;
       break;
     case bmdFormat8BitARGB:
       pixel_format = media::PIXEL_FORMAT_ARGB;
       break;
     default:
-      SendErrorString("Unsupported pixel format");
+      SendErrorString(FROM_HERE, "Unsupported pixel format");
       break;
   }
 
   const media::VideoCaptureFormat capture_format(
       gfx::Size(video_frame->GetWidth(), video_frame->GetHeight()),
       0.0f,  // Frame rate is not needed for captured data callback.
       pixel_format);
   base::AutoLock lock(lock_);
   if (frame_receiver_) {
     frame_receiver_->OnIncomingCapturedData(
@@ skipping 23 matching lines @@
   return 1;
 }
 
 ULONG DeckLinkCaptureDelegate::Release() {
   DCHECK(thread_checker_.CalledOnValidThread());
   bool ret_value = !HasOneRef();
   base::RefCountedThreadSafe<DeckLinkCaptureDelegate>::Release();
   return ret_value;
 }
 
-void DeckLinkCaptureDelegate::SendErrorString(const std::string& reason) {
+void DeckLinkCaptureDelegate::SendErrorString(
+    const tracked_objects::Location& from_here,
+    const std::string& reason) {
   base::AutoLock lock(lock_);
   if (frame_receiver_)
-    frame_receiver_->SendErrorString(reason);
+    frame_receiver_->SendErrorString(from_here, reason);
 }
 
 void DeckLinkCaptureDelegate::SendLogString(const std::string& message) {
   base::AutoLock lock(lock_);
   if (frame_receiver_)
     frame_receiver_->SendLogString(message);
 }
 
 void DeckLinkCaptureDelegate::ResetVideoCaptureDeviceReference() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 141 matching lines @@
     const VideoCaptureFormat& frame_format,
     int rotation,  // Clockwise.
     base::TimeTicks timestamp) {
   base::AutoLock lock(lock_);
   if (client_) {
     client_->OnIncomingCapturedData(data, length, frame_format, rotation,
                                     timestamp);
   }
 }
 
-void VideoCaptureDeviceDeckLinkMac::SendErrorString(const std::string& reason) {
+void VideoCaptureDeviceDeckLinkMac::SendErrorString(
+    const tracked_objects::Location& from_here,
+    const std::string& reason) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
   if (client_)
-    client_->OnError(reason);
+    client_->OnError(from_here, reason);
 }
 
 void VideoCaptureDeviceDeckLinkMac::SendLogString(const std::string& message) {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock lock(lock_);
   if (client_)
     client_->OnLog(message);
 }
 
 void VideoCaptureDeviceDeckLinkMac::AllocateAndStart(
     const VideoCaptureParams& params,
     scoped_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   client_ = client.Pass();
   if (decklink_capture_delegate_.get())
     decklink_capture_delegate_->AllocateAndStart(params);
 }
 
 void VideoCaptureDeviceDeckLinkMac::StopAndDeAllocate() {
   if (decklink_capture_delegate_.get())
     decklink_capture_delegate_->StopAndDeAllocate();
 }
 
 }  // namespace media