Reland [Mojo Video Capture] Replace method OnIncomingCapturedVideoFrame() with OnIncomingCapturedBuf

media/capture/video/video_capture_device_client.cc

 // Copyright 2015 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/video_capture_device_client.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_frame.h"
 #include "media/capture/video/video_capture_buffer_handle.h"
 #include "media/capture/video/video_capture_buffer_pool.h"
 #include "media/capture/video/video_capture_jpeg_decoder.h"
 #include "media/capture/video/video_frame_receiver.h"
 #include "media/capture/video_capture_types.h"
+#include "mojo/public/cpp/system/platform_handle.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 using media::VideoCaptureFormat;
 using media::VideoFrame;
 using media::VideoFrameMetadata;
 
 namespace {
 
 bool IsFormatSupported(media::VideoPixelFormat pixel_format) {
   return (pixel_format == media::PIXEL_FORMAT_I420 ||
@@ skipping 254 matching lines @@
     return nullptr;
   return base::WrapUnique<Buffer>(
       new AutoReleaseBuffer(buffer_pool_, buffer_id, frame_feedback_id));
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     std::unique_ptr<Buffer> buffer,
     const VideoCaptureFormat& format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp) {
-  DCHECK(IsFormatSupported(format.pixel_format));
-  DCHECK_EQ(media::PIXEL_STORAGE_CPU, format.pixel_storage);
+  OnIncomingCapturedBufferExt(std::move(buffer), format, reference_time,
+                              timestamp, gfx::Rect(format.frame_size),
+                              VideoFrameMetadata());
+}
 
-  scoped_refptr<VideoFrame> frame;
-  if (buffer->IsBackedByVideoFrame()) {
-    frame = buffer->GetVideoFrame();
-    frame->set_timestamp(timestamp);
-  } else {
-    frame = VideoFrame::WrapExternalSharedMemory(
-        format.pixel_format, format.frame_size, gfx::Rect(format.frame_size),
-        format.frame_size, reinterpret_cast<uint8_t*>(buffer->data()),
-        VideoFrame::AllocationSize(format.pixel_format, format.frame_size),
-        base::SharedMemory::NULLHandle(), 0u, timestamp);
-  }
-  if (!frame)
-    return;
+void VideoCaptureDeviceClient::OnIncomingCapturedBufferExt(
+    std::unique_ptr<Buffer> buffer,
+    const VideoCaptureFormat& format,
+    base::TimeTicks reference_time,
+    base::TimeDelta timestamp,
+    gfx::Rect visible_rect,
+    const VideoFrameMetadata& additional_metadata) {
+  const int buffer_id = buffer->id();
+
+  auto buffer_mojo_handle = buffer_pool_->GetHandleForTransit(buffer_id);
+  base::SharedMemoryHandle memory_handle;
+  size_t memory_size = 0;
+  bool read_only_flag = false;
+  const MojoResult unwrap_result_code = mojo::UnwrapSharedMemoryHandle(
+      std::move(buffer_mojo_handle), &memory_handle, &memory_size,
+      &read_only_flag);
+  DCHECK_EQ(MOJO_RESULT_OK, unwrap_result_code);
+
+  scoped_refptr<media::VideoFrame> frame =
+      media::VideoFrame::WrapExternalSharedMemory(
+          format.pixel_format,                    // format
+          format.frame_size,                      // coded_size
+          visible_rect,                           // visible_rect
+          format.frame_size,                      // natural_size
+          static_cast<uint8_t*>(buffer->data()),  // data
+          buffer->mapped_size(),                  // data_size
+          memory_handle,                          // handle
+          0,                                      // shared_memory_offset
+          timestamp);                             // timestamp
+  frame->metadata()->MergeMetadataFrom(&additional_metadata);
   frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                format.frame_rate);
   frame->metadata()->SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
                                   reference_time);
-  OnIncomingCapturedVideoFrame(std::move(buffer), std::move(frame));
-}
 
-void VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(
-    std::unique_ptr<Buffer> buffer,
-    scoped_refptr<VideoFrame> frame) {
   receiver_->OnIncomingCapturedVideoFrame(std::move(buffer), std::move(frame));
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureDeviceClient::ResurrectLastOutputBuffer(
     const gfx::Size& dimensions,
     media::VideoPixelFormat format,
     media::VideoPixelStorage storage,
     int new_frame_feedback_id) {
   const int buffer_id =
@@ skipping 77 matching lines @@
     return;
   memcpy(buffer->data(), data, length);
   const VideoCaptureFormat output_format =
       VideoCaptureFormat(format.frame_size, format.frame_rate,
                          media::PIXEL_FORMAT_Y16, media::PIXEL_STORAGE_CPU);
   OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
                            timestamp);
 }
 
 }  // namespace media