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

content/browser/renderer_host/media/video_capture_manager.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/media/video_capture_manager.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 153 matching lines @@
 }
 
 }  // namespace
 
 namespace content {
 
 // Instances of this struct go through several different phases during their
 // lifetime.
 // Phase 1: When first created (in GetOrCreateDeviceEntry()), this consists of
 // only the |video_capture_controller|. Clients can already connect to the
-// controller, but there is no |buffer_pool| or |video_capture_device| present.
+// controller, but there is no |video_capture_device| present.
 // Phase 2: When a request to "start" the entry comes in (via
-// HandleQueuedStartRequest()), |buffer_pool| is created and creation of
-// |video_capture_device| is scheduled to run asynchronously on the Device
-// Thread.
+// HandleQueuedStartRequest()), creation of |video_capture_device| is scheduled
+// to run asynchronously on the Device Thread.
 // Phase 3: As soon as the creation of the VideoCaptureDevice is complete, this
 // newly created VideoCaptureDevice instance is connected to the
-// VideoCaptureController via SetConsumerFeedbackObserver(). Furthermore, the
-// |buffer_pool| is moved to the |video_capture_controller| as a
-// FrameBufferPool via SetFrameBufferPool().
+// VideoCaptureController via SetConsumerFeedbackObserver().
 // Phase 4: This phase can only be reached on Android. When the application goes
 // to the background, the |video_capture_device| is asynchronously stopped and
 // released on the Device Thread. When the application is resumed, we
 // transition to Phase 2.
 struct VideoCaptureManager::DeviceEntry {
  public:
   DeviceEntry(MediaStreamType stream_type,
               const std::string& id,
               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;
 };
 
 // Bundles a media::VideoCaptureDeviceDescriptor with corresponding supported
 // video formats.
 struct VideoCaptureManager::DeviceInfo {
   DeviceInfo();
   DeviceInfo(media::VideoCaptureDeviceDescriptor descriptor);
   DeviceInfo(const DeviceInfo& other);
   ~DeviceInfo();
   DeviceInfo& operator=(const DeviceInfo& other);
 
   media::VideoCaptureDeviceDescriptor descriptor;
   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:
   CaptureDeviceStartRequest(int serial_id,
                             media::VideoCaptureSessionId session_id,
                             const media::VideoCaptureParams& params);
   int serial_id() const { return serial_id_; }
   media::VideoCaptureSessionId session_id() const { return session_id_; }
   media::VideoCaptureParams params() const { return params_; }
 
@@ skipping 28 matching lines @@
   DCHECK(video_capture_device == nullptr);
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client>
 VideoCaptureManager::DeviceEntry::CreateDeviceClient() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   const int max_buffers = stream_type == MEDIA_TAB_VIDEO_CAPTURE
                               ? kMaxNumberOfBuffersForTabCapture
                               : kMaxNumberOfBuffers;
-  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>(std::move(buffer_pool));
+      std::move(buffer_pool),
+      base::Bind(&CreateGpuJpegDecoder,
+                 base::Bind(&media::VideoFrameReceiver::OnFrameReadyInBuffer,
+                            video_capture_controller.GetWeakPtrForIOThread())));
 }
 
 VideoCaptureManager::DeviceInfo::DeviceInfo() = default;
 
 VideoCaptureManager::DeviceInfo::DeviceInfo(
     media::VideoCaptureDeviceDescriptor descriptor)
     : descriptor(descriptor) {}
 
 VideoCaptureManager::DeviceInfo::DeviceInfo(
     const VideoCaptureManager::DeviceInfo& other) = default;
@@ skipping 171 matching lines @@
   if (device_info != nullptr) {
     for (auto& observer : capture_observers_)
       observer.OnVideoCaptureStopped(device_info->descriptor.facing);
   }
 
   DVLOG(3) << "DoStopDevice. Send stop request for device = " << entry->id
            << " serial_id = " << entry->serial_id << ".";
   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.
   if (entry->video_capture_device) {
     device_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
                    base::Passed(&entry->video_capture_device)));
   }
 }
@@ skipping 11 matching lines @@
 
   const int serial_id = request->serial_id();
   DeviceEntry* const entry = GetDeviceEntryBySerialId(serial_id);
   DCHECK(entry);
 
   DVLOG(3) << "HandleQueuedStartRequest, Post start to device thread, device = "
            << entry->id << " start id = " << entry->serial_id;
 
   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;
 
   switch (entry->stream_type) {
     case MEDIA_DEVICE_VIDEO_CAPTURE: {
       // We look up the device id from the renderer in our local enumeration
       // since the renderer does not have all the information that might be
       // held in the browser-side VideoCaptureDevice::Name structure.
       const DeviceInfo* found = GetDeviceInfoById(entry->id);
@@ skipping 43 matching lines @@
       break;
 
     default: {
       NOTIMPLEMENTED();
       return;
     }
   }
   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);
   DCHECK_EQ(serial_id, device_start_queue_.begin()->serial_id());
   // |device| can be null if creation failed in
   //  DoStartDeviceCaptureOnDeviceThread.
   if (device_start_queue_.front().abort_start()) {
     // The device is no longer wanted. Stop the device again.
     DVLOG(3) << "OnDeviceStarted but start request have been aborted.";
     media::VideoCaptureDevice* device_ptr = device.get();
     base::Closure closure =
         base::Bind(&VideoCaptureManager::DoStopDeviceOnDeviceThread, this,
                    base::Passed(&device));
     if (device_ptr && !device_task_runner_->PostTask(FROM_HERE, closure)) {
       // PostTask failed. The device must be stopped anyway.
       device_ptr->StopAndDeAllocate();
     }
   } else {
     DeviceEntry* const entry = GetDeviceEntryBySerialId(serial_id);
     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
       // |entry->video_capture_device_| on the |device_task_runner_|.
       entry->video_capture_controller.SetConsumerFeedbackObserver(
           base::MakeUnique<VideoFrameConsumerFeedbackObserverOnTaskRunner>(
               device.get(), device_task_runner_));
     }
     entry->video_capture_device = std::move(device);
 
@@ skipping 740 matching lines @@
     if (!device_in_queue) {
       // Session ID is only valid for Screen capture. So we can fake it to
       // resume video capture devices here.
       QueueStartDevice(kFakeSessionId, entry.get(), entry->parameters);
     }
   }
 }
 #endif  // defined(OS_ANDROID)
 
 }  // namespace content