ImageCapture: ScopedResultCallback

media/capture/video/fake_video_capture_device.cc

 // Copyright (c) 2012 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/fake_video_capture_device.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/base/video_frame.h"
+#include "mojo/public/cpp/bindings/string.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace media {
 
 // Sweep at 600 deg/sec.
 static const float kPacmanAngularVelocity = 600;
 // Beep every 500 ms.
@@ skipping 43 matching lines @@
 
   const std::string time_string =
       base::StringPrintf("%d:%02d:%02d:%03d %d", hours, minutes, seconds,
                          milliseconds, frame_count);
   canvas.scale(3, 3);
   canvas.drawText(time_string.data(), time_string.length(), 30, 20, paint);
 }
 
 // Creates a PNG-encoded frame and sends it back to |callback|. The other
 // parameters are used to replicate the PacMan rendering.
-void DoTakeFakePhoto(const VideoCaptureDevice::TakePhotoCallback& callback,
-                     const VideoCaptureFormat& capture_format,
-                     base::TimeDelta elapsed_time,
-                     float fake_capture_rate) {
+void DoTakeFakePhoto(
+    ScopedResultCallback<VideoCaptureDevice::TakePhotoCallback> callback,
+    const VideoCaptureFormat& capture_format,
+    base::TimeDelta elapsed_time,
+    float fake_capture_rate) {
   std::unique_ptr<uint8_t[]> buffer(new uint8_t[VideoFrame::AllocationSize(
       PIXEL_FORMAT_ARGB, capture_format.frame_size)]);
 
   DrawPacman(true /* use_argb */, buffer.get(), elapsed_time, fake_capture_rate,
              capture_format.frame_size);
 
-  std::unique_ptr<std::vector<uint8_t>> encoded_data(
-      new std::vector<uint8_t>());
+  std::vector<uint8_t> encoded_data;
   const bool result = gfx::PNGCodec::Encode(
       buffer.get(), gfx::PNGCodec::FORMAT_RGBA, capture_format.frame_size,
       capture_format.frame_size.width() * 4, true /* discard_transparency */,
-      std::vector<gfx::PNGCodec::Comment>(), encoded_data.get());
+      std::vector<gfx::PNGCodec::Comment>(), &encoded_data);
   DCHECK(result);
 
-  callback.Run("image/png", std::move(encoded_data));
+  callback.Run(mojo::String::From("image/png"),
+               mojo::Array<uint8_t>::From(encoded_data));
 }
 
 FakeVideoCaptureDevice::FakeVideoCaptureDevice(BufferOwnership buffer_ownership,
                                                float fake_capture_rate)
     : buffer_ownership_(buffer_ownership),
       fake_capture_rate_(fake_capture_rate),
       weak_factory_(this) {}
 
 FakeVideoCaptureDevice::~FakeVideoCaptureDevice() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 47 matching lines @@
         base::TimeTicks::Now(),
         base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
                    weak_factory_.GetWeakPtr()));
 }
 
 void FakeVideoCaptureDevice::StopAndDeAllocate() {
   DCHECK(thread_checker_.CalledOnValidThread());
   client_.reset();
 }
 
-bool FakeVideoCaptureDevice::TakePhoto(
-    const TakePhotoCallback& photo_callback) {
+void FakeVideoCaptureDevice::TakePhoto(
+    ScopedResultCallback<TakePhotoCallback> callback) {
   base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&DoTakeFakePhoto, photo_callback, capture_format_,
-                            elapsed_time_, fake_capture_rate_));
-  return true;
+      FROM_HERE,
+      base::Bind(&DoTakeFakePhoto, base::Passed(&callback), capture_format_,
+                 elapsed_time_, fake_capture_rate_));
 }
 
 void FakeVideoCaptureDevice::CaptureUsingOwnBuffers(
     base::TimeTicks expected_execution_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const size_t frame_size = capture_format_.ImageAllocationSize();
   memset(fake_frame_.get(), 0, frame_size);
 
   DrawPacman(false /* use_argb */, fake_frame_.get(), elapsed_time_,
              fake_capture_rate_, capture_format_.frame_size);
@@ skipping 83 matching lines @@
   // Don't accumulate any debt if we are lagging behind - just post the next
   // frame immediately and continue as normal.
   const base::TimeTicks next_execution_time =
       std::max(current_time, expected_execution_time + frame_interval);
   const base::TimeDelta delay = next_execution_time - current_time;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(next_capture, next_execution_time), delay);
 }
 
 }  // namespace media