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

media/capture/video/android/video_capture_device_android.cc

 // Copyright (c) 2013 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/android/video_capture_device_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/strings/string_number_conversions.h"
 #include "jni/VideoCapture_jni.h"
@@ skipping 50 matching lines @@
     got_first_frame_ = false;
   }
 
   JNIEnv* env = AttachCurrentThread();
 
   jboolean ret = Java_VideoCapture_allocate(
       env, j_capture_.obj(), params.requested_format.frame_size.width(),
       params.requested_format.frame_size.height(),
       params.requested_format.frame_rate);
   if (!ret) {
-    SetErrorState("failed to allocate");
+    SetErrorState(FROM_HERE, "failed to allocate");
     return;
   }
 
   // Store current width and height.
   capture_format_.frame_size.SetSize(
       Java_VideoCapture_queryWidth(env, j_capture_.obj()),
       Java_VideoCapture_queryHeight(env, j_capture_.obj()));
   capture_format_.frame_rate =
       Java_VideoCapture_queryFrameRate(env, j_capture_.obj());
   capture_format_.pixel_format = GetColorspace();
   DCHECK_NE(capture_format_.pixel_format, media::PIXEL_FORMAT_UNKNOWN);
   CHECK(capture_format_.frame_size.GetArea() > 0);
   CHECK(!(capture_format_.frame_size.width() % 2));
   CHECK(!(capture_format_.frame_size.height() % 2));
 
   if (capture_format_.frame_rate > 0) {
     frame_interval_ = base::TimeDelta::FromMicroseconds(
         (base::Time::kMicrosecondsPerSecond + capture_format_.frame_rate - 1) /
         capture_format_.frame_rate);
   }
 
   DVLOG(1) << "VideoCaptureDeviceAndroid::Allocate: queried frame_size="
            << capture_format_.frame_size.ToString()
            << ", frame_rate=" << capture_format_.frame_rate;
 
   ret = Java_VideoCapture_startCapture(env, j_capture_.obj());
   if (!ret) {
-    SetErrorState("failed to start capture");
+    SetErrorState(FROM_HERE, "failed to start capture");
     return;
   }
 
   {
     base::AutoLock lock(lock_);
     state_ = kCapturing;
   }
 }
 
 void VideoCaptureDeviceAndroid::StopAndDeAllocate() {
   DVLOG(1) << "VideoCaptureDeviceAndroid::StopAndDeAllocate";
   {
     base::AutoLock lock(lock_);
     if (state_ != kCapturing && state_ != kError)
       return;
   }
 
   JNIEnv* env = AttachCurrentThread();
 
   jboolean ret = Java_VideoCapture_stopCapture(env, j_capture_.obj());
   if (!ret) {
-    SetErrorState("failed to stop capture");
+    SetErrorState(FROM_HERE, "failed to stop capture");
     return;
   }
 
   {
     base::AutoLock lock(lock_);
     state_ = kIdle;
     client_.reset();
   }
 
   Java_VideoCapture_deallocate(env, j_capture_.obj());
@@ skipping 32 matching lines @@
                                     capture_format_, rotation,
                                     base::TimeTicks::Now());
   }
 
   env->ReleaseByteArrayElements(data, buffer, JNI_ABORT);
 }
 
 void VideoCaptureDeviceAndroid::OnError(JNIEnv* env,
                                         jobject obj,
                                         jstring message) {
-  SetErrorState(base::android::ConvertJavaStringToUTF8(env, message));
+  SetErrorState(FROM_HERE,
+                base::android::ConvertJavaStringToUTF8(env, message));
 }
 
 VideoPixelFormat VideoCaptureDeviceAndroid::GetColorspace() {
   JNIEnv* env = AttachCurrentThread();
   const int current_capture_colorspace =
       Java_VideoCapture_getColorspace(env, j_capture_.obj());
   switch (current_capture_colorspace) {
     case ANDROID_IMAGE_FORMAT_YV12:
       return media::PIXEL_FORMAT_YV12;
     case ANDROID_IMAGE_FORMAT_YUV_420_888:
       return media::PIXEL_FORMAT_I420;
     case ANDROID_IMAGE_FORMAT_NV21:
       return media::PIXEL_FORMAT_NV21;
     case ANDROID_IMAGE_FORMAT_UNKNOWN:
     default:
       return media::PIXEL_FORMAT_UNKNOWN;
   }
 }
 
-void VideoCaptureDeviceAndroid::SetErrorState(const std::string& reason) {
+void VideoCaptureDeviceAndroid::SetErrorState(
+    const tracked_objects::Location& from_here,
+    const std::string& reason) {
   {
     base::AutoLock lock(lock_);
     state_ = kError;
   }
-  client_->OnError(reason);
+  client_->OnError(from_here, reason);
 }
 
 }  // namespace media