ImageCapture: Implement takePhoto() for Mac AVFoundation

media/capture/video/mac/video_capture_device_mac.mm

Index: media/capture/video/mac/video_capture_device_mac.mm
diff --git a/media/capture/video/mac/video_capture_device_mac.mm b/media/capture/video/mac/video_capture_device_mac.mm
index f032280d68e9a150dc54e94220a5323d7de32b38..6ae6b8c1d8c8ef7a6ed3e71551f2842c00b25af0 100644
--- a/media/capture/video/mac/video_capture_device_mac.mm
+++ b/media/capture/video/mac/video_capture_device_mac.mm
@@ -389,6 +389,17 @@ void VideoCaptureDeviceMac::StopAndDeAllocate() {
   state_ = kIdle;
 }
 
+void VideoCaptureDeviceMac::TakePhoto(TakePhotoCallback callback) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(state_ == kCapturing) << state_;
+
+  if (photo_callback_)  // Only one picture can be in flight at a time.
+    return;
+
+  photo_callback_.reset(new TakePhotoCallback(std::move(callback)));
+  [capture_device_ takePhoto];
+}
+
 bool VideoCaptureDeviceMac::Init(
     VideoCaptureDevice::Name::CaptureApiType capture_api_type) {
   DCHECK(task_runner_->BelongsToCurrentThread());
@@ -413,8 +424,6 @@ void VideoCaptureDeviceMac::ReceiveFrame(const uint8_t* video_frame,
                                          int aspect_numerator,
                                          int aspect_denominator,
                                          base::TimeDelta timestamp) {
-  // This method is safe to call from a device capture thread, i.e. any thread
-  // controlled by AVFoundation.
   if (capture_format_.frame_size != frame_format.frame_size) {
     ReceiveError(FROM_HERE,
                  "Captured resolution " + frame_format.frame_size.ToString() +
@@ -426,6 +435,26 @@ void VideoCaptureDeviceMac::ReceiveFrame(const uint8_t* video_frame,
                                   0, base::TimeTicks::Now(), timestamp);
 }
 
+void VideoCaptureDeviceMac::OnPhotoTaken(const uint8_t* image_data,
+                                         size_t image_length,
+                                         const std::string& mime_type) {
+  DCHECK(photo_callback_);
+  if (!image_data || !image_length) {
+    OnPhotoError();
+    return;
+  }
+
+  photo_callback_->Run(mojo::String::From(mime_type),
+                       mojo::Array<uint8_t>(std::vector<uint8_t>(

[Robert Sesek, 2016/07/12 12:29:47]

This needs to be std::move to get the rvalue ref constructor.

[mcasas, 2016/07/12 13:35:00]

When constructing a temporary, copy elision is
automatic, so std::move is not needed. This is
what llvm says if I change it:

../../media/capture/video/mac/video_capture_device_mac.mm:448:45: error: moving
a temporary object prevents copy elision [-Werror,-Wpessimizing-move]
                       mojo::Array<uint8_t>(std::move(std::vector<uint8_t>(

../../media/capture/video/mac/video_capture_device_mac.mm:448:45: note: remove
std::move call here
                       mojo::Array<uint8_t>(std::move(std::vector<uint8_t>(

(If it was a static var, I'd need std::move() to
add the second & that'd force using the move
constructor).

+                           image_data, image_data + image_length)));
+  photo_callback_.reset();
+}
+
+void VideoCaptureDeviceMac::OnPhotoError() {
+  DLOG(ERROR) << __FUNCTION__ << " error taking picture";
+  photo_callback_.reset();
+}
+
 void VideoCaptureDeviceMac::ReceiveError(
     const tracked_objects::Location& from_here,
     const std::string& reason) {