Let clients interact with VideoCaptureDeviceClient instead of VideoCaptureDevice

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"
@@ skipping 26 matching lines @@
                     int buffer_id)
       : id_(buffer_id),
         pool_(pool),
         buffer_handle_(pool_->GetBufferHandle(buffer_id)) {
     DCHECK(pool_.get());
   }
   int id() const override { return id_; }
   gfx::Size dimensions() const override { return buffer_handle_->dimensions(); }
   size_t mapped_size() const override { return buffer_handle_->mapped_size(); }
   void* data(int plane) override { return buffer_handle_->data(plane); }
-  ClientBuffer AsClientBuffer(int plane) override {
-    return buffer_handle_->AsClientBuffer(plane);
-  }
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   base::FileDescriptor AsPlatformFile() override {
     return buffer_handle_->AsPlatformFile();
   }
 #endif
+  bool IsBackedByVideoFrame() const override {
+    return buffer_handle_->IsBackedByVideoFrame();
+  }
+  scoped_refptr<VideoFrame> GetVideoFrame() override {
+    return buffer_handle_->GetVideoFrame();
+  }
 
  private:
   ~AutoReleaseBuffer() override { pool_->RelinquishProducerReservation(id_); }
 
   const int id_;
   const scoped_refptr<VideoCaptureBufferPool> pool_;
   const std::unique_ptr<VideoCaptureBufferHandle> buffer_handle_;
 };
 
 VideoCaptureDeviceClient::VideoCaptureDeviceClient(
@@ skipping 207 matching lines @@
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     std::unique_ptr<Buffer> buffer,
     const VideoCaptureFormat& frame_format,
     base::TimeTicks reference_time,
     base::TimeDelta timestamp) {
   // Currently, only I420 pixel format is supported.
   DCHECK_EQ(media::PIXEL_FORMAT_I420, frame_format.pixel_format);
   DCHECK_EQ(media::PIXEL_STORAGE_CPU, frame_format.pixel_storage);
 
-  scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalSharedMemory(
-      media::PIXEL_FORMAT_I420, frame_format.frame_size,
-      gfx::Rect(frame_format.frame_size), frame_format.frame_size,
-      reinterpret_cast<uint8_t*>(buffer->data()),
-      VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
-                                 frame_format.frame_size),
-      base::SharedMemory::NULLHandle(), 0u, timestamp);
+  scoped_refptr<VideoFrame> frame;
+  if (buffer->IsBackedByVideoFrame()) {
+    frame = buffer->GetVideoFrame();
+    frame->set_timestamp(timestamp);
+  } else {
+    frame = VideoFrame::WrapExternalSharedMemory(
+        media::PIXEL_FORMAT_I420, frame_format.frame_size,
+        gfx::Rect(frame_format.frame_size), frame_format.frame_size,
+        reinterpret_cast<uint8_t*>(buffer->data()),
+        VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
+                                   frame_format.frame_size),
+        base::SharedMemory::NULLHandle(), 0u, timestamp);
+  }
   if (!frame)
     return;
   frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                frame_format.frame_rate);
   frame->metadata()->SetTimeTicks(media::VideoFrameMetadata::REFERENCE_TIME,
                                   reference_time);
   OnIncomingCapturedVideoFrame(std::move(buffer), frame);
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(
@@ skipping 58 matching lines @@
   *u_plane_data =
       *y_plane_data +
       VideoFrame::PlaneSize(format, VideoFrame::kYPlane, dimensions).GetArea();
   *v_plane_data =
       *u_plane_data +
       VideoFrame::PlaneSize(format, VideoFrame::kUPlane, dimensions).GetArea();
   return buffer;
 }
 
 }  // namespace media