Reland2 [Mojo Video Capture] Replace method OnIncomingCapturedVideoFrame() with OnIncomingCapturedBu

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) {
+  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
+          base::SharedMemory::NULLHandle(),       // handle

[miu, 2017/01/10 23:32:19]

This could either be great or not:

Great in that maybe all the special code for managing ownership of shared memory
can be removed from media::VideoFrame.

Bad in that maybe we want to ensure media::VideoFrame retains a ref-count on the
shared memory so that it is guaranteed to out-live the VideoFrame?

Your call, as your brain's "cache memory" is better primed than mine for all of
this right now. ;-)

[chfremer, 2017/01/10 23:45:29]

In this case, I think it is okay to not attach a ref-count of the shared memory
to video frame, for the following two reasons:
1. The code before this CL did not do it either, and I am trying to not make any
functional change.
2. The ownership of buffer is already included in |buffer|.

The need to wrap into a media::VideoFrame also goes away in the subsequent CL
anyway.

+          0u,                                     // 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