[Mojo Video Capture] Split OnIncomingCapturedVideoFrame() to OnNewBuffer() + OnFrameReadyInBuffer()

content/browser/renderer_host/media/video_capture_manager.cc

Index: content/browser/renderer_host/media/video_capture_manager.cc
diff --git a/content/browser/renderer_host/media/video_capture_manager.cc b/content/browser/renderer_host/media/video_capture_manager.cc
index f5a1e0c6fb70de4e24c8df4c50cfd5c9955ed6f2..cfaabdbb3359eaa33991c5c4447319d929f939fa 100644
--- a/content/browser/renderer_host/media/video_capture_manager.cc
+++ b/content/browser/renderer_host/media/video_capture_manager.cc
@@ -187,14 +187,12 @@ struct VideoCaptureManager::DeviceEntry {
               const media::VideoCaptureParams& params);
   ~DeviceEntry();
   std::unique_ptr<media::VideoCaptureDevice::Client> CreateDeviceClient();
-  std::unique_ptr<media::FrameBufferPool> CreateFrameBufferPool();
 
   const int serial_id;
   const MediaStreamType stream_type;
   const std::string id;
   const media::VideoCaptureParams parameters;
   VideoCaptureController video_capture_controller;
-  scoped_refptr<media::VideoCaptureBufferPool> buffer_pool;
   std::unique_ptr<media::VideoCaptureDevice> video_capture_device;
 };
 
@@ -211,24 +209,6 @@ struct VideoCaptureManager::DeviceInfo {
   media::VideoCaptureFormats supported_formats;
 };
 
-class BufferPoolFrameBufferPool : public media::FrameBufferPool {
- public:
-  explicit BufferPoolFrameBufferPool(
-      scoped_refptr<media::VideoCaptureBufferPool> buffer_pool)
-      : buffer_pool_(std::move(buffer_pool)) {}
-
-  void SetBufferHold(int buffer_id) override {
-    buffer_pool_->HoldForConsumers(buffer_id, 1);
-  }
-
-  void ReleaseBufferHold(int buffer_id) override {
-    buffer_pool_->RelinquishConsumerHold(buffer_id, 1);
-  }
-
- private:
-  scoped_refptr<media::VideoCaptureBufferPool> buffer_pool_;
-};
-
 // Class used for queuing request for starting a device.
 class VideoCaptureManager::CaptureDeviceStartRequest {
  public:
@@ -277,27 +257,18 @@ VideoCaptureManager::DeviceEntry::CreateDeviceClient() {
   const int max_buffers = stream_type == MEDIA_TAB_VIDEO_CAPTURE
                               ? kMaxNumberOfBuffersForTabCapture
                               : kMaxNumberOfBuffers;
-  if (!buffer_pool) {
-    buffer_pool = new media::VideoCaptureBufferPoolImpl(
-        base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(),
-        max_buffers);
-  }
+  scoped_refptr<media::VideoCaptureBufferPool> buffer_pool =
+      new media::VideoCaptureBufferPoolImpl(
+          base::MakeUnique<media::VideoCaptureBufferTrackerFactoryImpl>(),
+          max_buffers);
 
   return base::MakeUnique<media::VideoCaptureDeviceClient>(
       base::MakeUnique<VideoFrameReceiverOnIOThread>(
           video_capture_controller.GetWeakPtrForIOThread()),
-      buffer_pool,
-      base::Bind(
-          &CreateGpuJpegDecoder,
-          base::Bind(&media::VideoFrameReceiver::OnIncomingCapturedVideoFrame,
-                     video_capture_controller.GetWeakPtrForIOThread())));
-}
-
-std::unique_ptr<media::FrameBufferPool>
-VideoCaptureManager::DeviceEntry::CreateFrameBufferPool() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(buffer_pool);
-  return base::MakeUnique<BufferPoolFrameBufferPool>(buffer_pool);
+      std::move(buffer_pool),
+      base::Bind(&CreateGpuJpegDecoder,
+                 base::Bind(&media::VideoFrameReceiver::OnFrameReadyInBuffer,
+                            video_capture_controller.GetWeakPtrForIOThread())));
 }
 
 VideoCaptureManager::DeviceInfo::DeviceInfo() = default;
@@ -470,7 +441,6 @@ void VideoCaptureManager::DoStopDevice(DeviceEntry* entry) {
   entry->video_capture_controller.OnLog(
       base::StringPrintf("Stopping device: id: %s", entry->id.c_str()));
   entry->video_capture_controller.SetConsumerFeedbackObserver(nullptr);
-  entry->video_capture_controller.SetFrameBufferPool(nullptr);
 
   // |entry->video_capture_device| can be null if creating the device has
   // failed.
@@ -502,8 +472,6 @@ void VideoCaptureManager::HandleQueuedStartRequest() {
 
   std::unique_ptr<media::VideoCaptureDevice::Client> device_client =
       entry->CreateDeviceClient();
-  std::unique_ptr<media::FrameBufferPool> frame_buffer_pool =
-      entry->CreateFrameBufferPool();
 
   base::Callback<std::unique_ptr<VideoCaptureDevice>(void)>
       start_capture_function;
@@ -564,12 +532,11 @@ void VideoCaptureManager::HandleQueuedStartRequest() {
   base::PostTaskAndReplyWithResult(
       device_task_runner_.get(), FROM_HERE, start_capture_function,
       base::Bind(&VideoCaptureManager::OnDeviceStarted, this,
-                 request->serial_id(), base::Passed(&frame_buffer_pool)));
+                 request->serial_id()));
 }
 
 void VideoCaptureManager::OnDeviceStarted(
     int serial_id,
-    std::unique_ptr<media::FrameBufferPool> frame_buffer_pool,
     std::unique_ptr<VideoCaptureDevice> device) {
   DVLOG(3) << __func__;
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ -592,8 +559,6 @@ void VideoCaptureManager::OnDeviceStarted(
     DCHECK(entry);
     DCHECK(!entry->video_capture_device);
     if (device) {
-      entry->video_capture_controller.SetFrameBufferPool(
-          std::move(frame_buffer_pool));
       // Passing raw pointer |device.get()| to the controller is safe,
       // because we transfer ownership of it to |entry|. We are calling
       // SetConsumerFeedbackObserver(nullptr) before releasing