ImageCapture: ScopedResultCallback

media/capture/video/android/video_capture_device_android.cc

Index: media/capture/video/android/video_capture_device_android.cc
diff --git a/media/capture/video/android/video_capture_device_android.cc b/media/capture/video/android/video_capture_device_android.cc
index d42272fe805ed32c286d12498f6f79939b63a65b..ec07c9c0795e31ed3cdd1ec292a041f471f845cd 100644
--- a/media/capture/video/android/video_capture_device_android.cc
+++ b/media/capture/video/android/video_capture_device_android.cc
@@ -41,16 +41,6 @@ VideoCaptureDeviceAndroid::VideoCaptureDeviceAndroid(const Name& device_name)
 
 VideoCaptureDeviceAndroid::~VideoCaptureDeviceAndroid() {
   StopAndDeAllocate();
-  // If there are still |photo_callbacks_|, resolve them with empty datas.
-  {
-    base::AutoLock lock(photo_callbacks_lock_);
-    std::for_each(photo_callbacks_.begin(), photo_callbacks_.end(),
-                  [](const std::unique_ptr<TakePhotoCallback>& callback) {
-                    std::unique_ptr<std::vector<uint8_t>> empty_data(
-                        new std::vector<uint8_t>());
-                    callback->Run("", std::move(empty_data));
-                  });
-  }
 }
 
 bool VideoCaptureDeviceAndroid::Init() {
@@ -145,26 +135,27 @@ void VideoCaptureDeviceAndroid::StopAndDeAllocate() {
   Java_VideoCapture_deallocate(env, j_capture_.obj());
 }
 
-bool VideoCaptureDeviceAndroid::TakePhoto(const TakePhotoCallback& callback) {
+void VideoCaptureDeviceAndroid::TakePhoto(
+    ScopedCallback<TakePhotoCallback> callback) {
   {
     base::AutoLock lock(lock_);
     if (state_ != kCapturing)
-      return false;
+      return;
   }
 
   JNIEnv* env = AttachCurrentThread();
 
   // Make copy on the heap so we can pass the pointer through JNI.
-  std::unique_ptr<TakePhotoCallback> cb(new TakePhotoCallback(callback));
-  const intptr_t callback_id = reinterpret_cast<intptr_t>(cb.get());
+  ScopedCallback<TakePhotoCallback> cb(
+      new ScopedCallback<TakePhotoCallback>(callback));
+  const intptr_t callback_id = reinterpret_cast<intptr_t>(&cb);

[Reilly Grant (use Gerrit), 2016/05/26 00:27:45]

&cb is a stack pointer. You can't pass it to Java.

[mcasas, 2016/05/26 17:24:04]

Yeah, all this code was essentially untouched,
I should have been more clear.

   if (!Java_VideoCapture_takePhoto(env, j_capture_.obj(), callback_id))
-    return false;
+    return;
 
   {
     base::AutoLock lock(photo_callbacks_lock_);
     photo_callbacks_.push_back(std::move(cb));
   }
-  return true;
 }
 
 void VideoCaptureDeviceAndroid::OnFrameAvailable(
@@ -221,23 +212,24 @@ void VideoCaptureDeviceAndroid::OnPhotoTaken(
 
   base::AutoLock lock(photo_callbacks_lock_);
 
-  TakePhotoCallback* const cb =
-      reinterpret_cast<TakePhotoCallback*>(callback_id);
+  ScopedCallback<TakePhotoCallback>* const cb =
+      reinterpret_cast<ScopedCallback<TakePhotoCallback>*>(callback_id);
   // Search for the pointer |cb| in the list of |photo_callbacks_|.
   const auto reference_it =
       std::find_if(photo_callbacks_.begin(), photo_callbacks_.end(),
-                   [cb](const std::unique_ptr<TakePhotoCallback>& callback) {
-                     return callback.get() == cb;
+                   [cb](const ScopedCallback<TakePhotoCallback>& callback) {
+                     return &callback == cb;
                    });
   if (reference_it == photo_callbacks_.end()) {
     NOTREACHED() << "|callback_id| not found.";
     return;
   }
 
-  std::unique_ptr<std::vector<uint8_t>> native_data(new std::vector<uint8_t>());
-  base::android::JavaByteArrayToByteVector(env, data.obj(), native_data.get());
+  std::vector<uint8_t> native_data;
+  base::android::JavaByteArrayToByteVector(env, data.obj(), &native_data);
 
-  cb->Run(native_data->size() ? "image/jpeg" : "", std::move(native_data));
+  cb->PassCallback().Run(native_data->size() ? "image/jpeg" : "",
+                         mojo::Array<uint8_t>::From(native_data));
 
   photo_callbacks_.erase(reference_it);
 }