Revert of [Mojo Video Capture] Replace method OnIncomingCapturedVideoFrame with OnIncomingCapturedBufferExt

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) {
-  OnIncomingCapturedBufferExt(std::move(buffer), format, reference_time,
-                              timestamp, gfx::Rect(format.frame_size),
-                              VideoFrameMetadata());
-}
+  DCHECK(IsFormatSupported(format.pixel_format));
+  DCHECK_EQ(media::PIXEL_STORAGE_CPU, format.pixel_storage);
 
-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);
+  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;
   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