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..f41a44d0dfe8106b5e0f8f995e953ae9e1601f67 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));
+  std::unique_ptr<ScopedCallback<TakePhotoCallback>> cb(

[Reilly Grant (use Gerrit), 2016/05/26 17:50:04]

nit: s/cb/heap_callback/

[mcasas, 2016/05/26 18:33:32]

Done.

+      new ScopedCallback<TakePhotoCallback>(std::move(callback)));
   const intptr_t callback_id = reinterpret_cast<intptr_t>(cb.get());
   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;
-                   });
+  const auto reference_it = std::find_if(
+      photo_callbacks_.begin(), photo_callbacks_.end(),
+      [cb](const std::unique_ptr<ScopedCallback<TakePhotoCallback>>& callback) {
+        return callback.get() == 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.empty() ? "" : "image/jpeg",
+                         mojo::Array<uint8_t>::From(native_data));
 
   photo_callbacks_.erase(reference_it);
 }