ImageCapture: ScopedResultCallback

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 <stdint.h>
 #include <utility>
 
 #include "base/android/jni_android.h"
@@ skipping 23 matching lines @@
   // an unknown device model.
   return "";
 }
 
 VideoCaptureDeviceAndroid::VideoCaptureDeviceAndroid(const Name& device_name)
     : state_(kIdle), got_first_frame_(false), device_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() {
   int id;
   if (!base::StringToInt(device_name_.id(), &id))
     return false;
 
   j_capture_.Reset(VideoCaptureDeviceFactoryAndroid::createVideoCaptureAndroid(
       id, reinterpret_cast<intptr_t>(this)));
   return true;
@@ skipping 74 matching lines @@
 
   {
     base::AutoLock lock(lock_);
     state_ = kIdle;
     client_.reset();
   }
 
   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());
+  std::unique_ptr<ScopedCallback<TakePhotoCallback>> heap_callback(
+      new ScopedCallback<TakePhotoCallback>(std::move(callback)));
+  const intptr_t callback_id = reinterpret_cast<intptr_t>(heap_callback.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));
+    photo_callbacks_.push_back(std::move(heap_callback));
   }
-  return true;
 }
 
 void VideoCaptureDeviceAndroid::OnFrameAvailable(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jbyteArray>& data,
     jint length,
     jint rotation) {
   DVLOG(3) << "VideoCaptureDeviceAndroid::OnFrameAvailable: length =" << length;
 
@@ skipping 36 matching lines @@
 
 void VideoCaptureDeviceAndroid::OnPhotoTaken(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj,
     jlong callback_id,
     const base::android::JavaParamRef<jbyteArray>& data) {
   DCHECK(callback_id);
 
   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);
 }
 
 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:
@@ skipping 12 matching lines @@
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   {
     base::AutoLock lock(lock_);
     state_ = kError;
   }
   client_->OnError(from_here, reason);
 }
 
 }  // namespace media