ImageCapture: ScopedResultCallback

content/browser/media/capture/image_capture_impl.cc

 // Copyright 2016 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 "content/browser/media/capture/image_capture_impl.h"
 
 #include "base/bind_helpers.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/browser_thread.h"
+#include "media/base/bind_to_current_loop.h"
 #include "media/capture/video/video_capture_device.h"
 
 namespace content {
 
 namespace {
 
-void RunMojoCallback(const ImageCaptureImpl::TakePhotoCallback& callback,
-                     const std::string& mime_type,
-                     mojo::Array<uint8_t> data) {
+void RunFailedGetCapabilitiesCallback(
+    const ImageCaptureImpl::GetCapabilitiesCallback& cb) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  blink::mojom::PhotoCapabilitiesPtr empty_capabilities =
+      blink::mojom::PhotoCapabilities::New();
+  empty_capabilities->zoom = blink::mojom::Range::New();
+  cb.Run(std::move(empty_capabilities));
+}
+
+void RunTakePhotoCallbackOnUIThread(
+    const ImageCaptureImpl::TakePhotoCallback& callback,
+    mojo::String mime_type,
+    mojo::Array<uint8_t> data) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {

[miu, 2016/05/27 22:36:38]

Instead of trampolining, can you just use media::BindToCurrentLoop() on L91
below?

[mcasas, 2016/05/27 23:36:06]

media::BindToCurrentLoop() does not know how 
to forward mojo::Array<> etc, so until that time
comes, can't do that here -- unlike the other
RunFailed...Callback() functions, which do use it.

Actually, on second thoughts this function would 
never be called on UI thread since we already have
at least one jump to IO. So I simplified it a bit.

+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&RunTakePhotoCallbackOnUIThread, std::move(callback),
+                   mime_type, base::Passed(std::move(data))));
+    return;
+  }
+
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   callback.Run(mime_type, std::move(data));
 }
 
-void RunTakePhotoCallback(const ImageCaptureImpl::TakePhotoCallback& callback,
-                          const std::string& mime_type,
-                          std::unique_ptr<std::vector<uint8_t>> data) {
-  DCHECK(data.get());
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&RunMojoCallback, callback, mime_type,
-                 base::Passed(mojo::Array<uint8_t>::From(*data))));
+void RunFailedTakePhotoCallback(const ImageCaptureImpl::TakePhotoCallback& cb) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  cb.Run("", mojo::Array<uint8_t>());
 }
 
-void TakePhotoOnIOThread(const mojo::String& source_id,
-                         const ImageCaptureImpl::TakePhotoCallback& callback,
-                         MediaStreamManager* media_stream_manager) {
+void TakePhotoOnIOThread(
+    const mojo::String& source_id,
+    MediaStreamManager* media_stream_manager,
+    media::ScopedCallback<ImageCaptureImpl::TakePhotoCallback> callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   const int session_id =
       media_stream_manager->VideoDeviceIdToSessionId(source_id);
 
-  if (session_id == StreamDeviceInfo::kNoId ||
-      !media_stream_manager->video_capture_manager()->TakePhoto(
-          session_id, base::Bind(&RunTakePhotoCallback, callback))) {
-    std::unique_ptr<std::vector<uint8_t>> empty_vector(
-        new std::vector<uint8_t>());
-    RunTakePhotoCallback(callback, "", std::move(empty_vector));
-  }
+  if (session_id == StreamDeviceInfo::kNoId)
+    return;
+  media_stream_manager->video_capture_manager()->TakePhoto(session_id,
+                                                           std::move(callback));
 }
 
 }  // anonymous namespace
 
 // static
 void ImageCaptureImpl::Create(
     mojo::InterfaceRequest<blink::mojom::ImageCapture> request) {
   // |binding_| will take ownership of ImageCaptureImpl.
   new ImageCaptureImpl(std::move(request));
 }
 
 ImageCaptureImpl::~ImageCaptureImpl() {}
 
 void ImageCaptureImpl::GetCapabilities(
     const mojo::String& source_id,
     const GetCapabilitiesCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  blink::mojom::PhotoCapabilitiesPtr empty_capabilities =
-      blink::mojom::PhotoCapabilities::New();
-  empty_capabilities->zoom = blink::mojom::Range::New();
-  callback.Run(std::move(empty_capabilities));
+  media::ScopedCallback<GetCapabilitiesCallback> scoped_callback(
+      callback,
+      media::BindToCurrentLoop(base::Bind(&RunFailedGetCapabilitiesCallback)));
 }
 
-
 void ImageCaptureImpl::TakePhoto(const mojo::String& source_id,
                                  const TakePhotoCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  media::ScopedCallback<TakePhotoCallback> scoped_callback(
+      base::Bind(&RunTakePhotoCallbackOnUIThread, callback),
+      media::BindToCurrentLoop(base::Bind(&RunFailedTakePhotoCallback)));
+
   // media_stream_manager() can only be called on UI thread.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&TakePhotoOnIOThread, source_id, callback,
-                 BrowserMainLoop::GetInstance()->media_stream_manager()));
+      base::Bind(&TakePhotoOnIOThread, source_id,
+                 BrowserMainLoop::GetInstance()->media_stream_manager(),
+                 base::Passed(&scoped_callback)));
 }
 
 ImageCaptureImpl::ImageCaptureImpl(
     mojo::InterfaceRequest<blink::mojom::ImageCapture> request)
     : binding_(this, std::move(request)) {}
 
 }  // namespace content