Break tight coupling of VideoCaptureDeviceClient to renderer_host

content/browser/renderer_host/media/video_capture_buffer_pool.cc

 // Copyright (c) 2013 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_buffer_pool.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "build/build_config.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/gfx/buffer_format_util.h"
 
 namespace content {
 
-const int VideoCaptureBufferPool::kInvalidId = -1;
-
 // Tracker specifics for SharedMemory.
-class VideoCaptureBufferPool::SharedMemTracker final : public Tracker {
+class VideoCaptureBufferPoolImpl::SharedMemTracker final : public Tracker {
  public:
   SharedMemTracker() : Tracker() {}
 
   bool Init(const gfx::Size& dimensions,
             media::VideoPixelFormat format,
             media::VideoPixelStorage storage_type,
             base::Lock* lock) override {
     DVLOG(2) << "allocating ShMem of " << dimensions.ToString();
     set_dimensions(dimensions);
     // |dimensions| can be 0x0 for trackers that do not require memory backing.
@@ skipping 18 matching lines @@
   bool ShareToProcess2(int plane,
                        base::ProcessHandle process_handle,
                        gfx::GpuMemoryBufferHandle* new_handle) override {
     NOTREACHED();
     return false;
   }
 
  private:
   // A simple proxy that implements the BufferHandle interface, providing
   // accessors to SharedMemTracker's memory and properties.
-  class SharedMemBufferHandle : public VideoCaptureBufferPool::BufferHandle {
+  class SharedMemBufferHandle
+      : public VideoCaptureBufferPoolImpl::BufferHandle {
    public:
     // |tracker| must outlive SimpleBufferHandle. This is ensured since a
     // tracker is pinned until ownership of this SimpleBufferHandle is returned
-    // to VideoCaptureBufferPool.
+    // to VideoCaptureBufferPoolImpl.
     explicit SharedMemBufferHandle(SharedMemTracker* tracker)
         : tracker_(tracker) {}
     ~SharedMemBufferHandle() override {}
 
     gfx::Size dimensions() const override { return tracker_->dimensions(); }
     size_t mapped_size() const override { return tracker_->mapped_size_; }
     void* data(int plane) override {
       DCHECK_EQ(plane, 0);
       return tracker_->shared_memory_.memory();
     }
@@ skipping 11 matching lines @@
     SharedMemTracker* const tracker_;
   };
 
   // The memory created to be shared with renderer processes.
   base::SharedMemory shared_memory_;
   size_t mapped_size_;
 };
 
 // Tracker specifics for GpuMemoryBuffer. Owns GpuMemoryBuffers and its
 // associated pixel dimensions.
-class VideoCaptureBufferPool::GpuMemoryBufferTracker final : public Tracker {
+class VideoCaptureBufferPoolImpl::GpuMemoryBufferTracker final
+    : public Tracker {
  public:
   GpuMemoryBufferTracker() : Tracker() {}
 
   ~GpuMemoryBufferTracker() override {
     for (const auto& gmb : gpu_memory_buffers_)
       gmb->Unmap();
   }
 
   bool Init(const gfx::Size& dimensions,
             media::VideoPixelFormat format,
@@ skipping 72 matching lines @@
         return true;
     }
     NOTREACHED();
     return true;
   }
 
  private:
   // A simple proxy that implements the BufferHandle interface, providing
   // accessors to GpuMemoryBufferTracker's memory and properties.
   class GpuMemoryBufferBufferHandle
-      : public VideoCaptureBufferPool::BufferHandle {
+      : public VideoCaptureBufferPoolImpl::BufferHandle {
    public:
     // |tracker| must outlive GpuMemoryBufferBufferHandle. This is ensured since
     // a tracker is pinned until ownership of this GpuMemoryBufferBufferHandle
-    // is returned to VideoCaptureBufferPool.
+    // is returned to VideoCaptureBufferPoolImpl.
     explicit GpuMemoryBufferBufferHandle(GpuMemoryBufferTracker* tracker)
         : tracker_(tracker) {}
     ~GpuMemoryBufferBufferHandle() override {}
 
     gfx::Size dimensions() const override { return tracker_->dimensions(); }
     size_t mapped_size() const override {
       return tracker_->dimensions().GetArea();
     }
     void* data(int plane) override {
       DCHECK_GE(plane, 0);
@@ skipping 15 matching lines @@
 
    private:
     GpuMemoryBufferTracker* const tracker_;
   };
 
   // Owned references to GpuMemoryBuffers.
   std::vector<std::unique_ptr<gfx::GpuMemoryBuffer>> gpu_memory_buffers_;
 };
 
 // static
-std::unique_ptr<VideoCaptureBufferPool::Tracker>
-VideoCaptureBufferPool::Tracker::CreateTracker(
+std::unique_ptr<VideoCaptureBufferPoolImpl::Tracker>
+VideoCaptureBufferPoolImpl::Tracker::CreateTracker(
     media::VideoPixelStorage storage) {
   switch (storage) {
     case media::PIXEL_STORAGE_GPUMEMORYBUFFER:
       return base::MakeUnique<GpuMemoryBufferTracker>();
     case media::PIXEL_STORAGE_CPU:
       return base::MakeUnique<SharedMemTracker>();
   }
   NOTREACHED();
-  return std::unique_ptr<VideoCaptureBufferPool::Tracker>();
+  return std::unique_ptr<VideoCaptureBufferPoolImpl::Tracker>();
 }
 
-VideoCaptureBufferPool::Tracker::~Tracker() {}
+VideoCaptureBufferPoolImpl::Tracker::~Tracker() {}
 
-VideoCaptureBufferPool::VideoCaptureBufferPool(int count)
+VideoCaptureBufferPoolImpl::VideoCaptureBufferPoolImpl(int count)
     : count_(count),
       next_buffer_id_(0),
       last_relinquished_buffer_id_(kInvalidId) {
   DCHECK_GT(count, 0);
 }
 
-VideoCaptureBufferPool::~VideoCaptureBufferPool() {
+VideoCaptureBufferPoolImpl::~VideoCaptureBufferPoolImpl() {
   base::STLDeleteValues(&trackers_);
 }
 
-bool VideoCaptureBufferPool::ShareToProcess(
+bool VideoCaptureBufferPoolImpl::ShareToProcess(
     int buffer_id,
     base::ProcessHandle process_handle,
     base::SharedMemoryHandle* new_handle) {
   base::AutoLock lock(lock_);
 
   Tracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return false;
   }
   if (tracker->ShareToProcess(process_handle, new_handle))
     return true;
   DPLOG(ERROR) << "Error mapping memory";
   return false;
 }
 
-bool VideoCaptureBufferPool::ShareToProcess2(
+bool VideoCaptureBufferPoolImpl::ShareToProcess2(
     int buffer_id,
     int plane,
     base::ProcessHandle process_handle,
     gfx::GpuMemoryBufferHandle* new_handle) {
   base::AutoLock lock(lock_);
 
   Tracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return false;
   }
   if (tracker->ShareToProcess2(plane, process_handle, new_handle))
     return true;
   DPLOG(ERROR) << "Error mapping memory";
   return false;
 }
 
-std::unique_ptr<VideoCaptureBufferPool::BufferHandle>
-VideoCaptureBufferPool::GetBufferHandle(int buffer_id) {
+std::unique_ptr<VideoCaptureBufferPoolImpl::BufferHandle>
+VideoCaptureBufferPoolImpl::GetBufferHandle(int buffer_id) {
   base::AutoLock lock(lock_);
 
   Tracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return std::unique_ptr<BufferHandle>();
   }
 
   DCHECK(tracker->held_by_producer());
   return tracker->GetBufferHandle();
 }
 
-int VideoCaptureBufferPool::ReserveForProducer(const gfx::Size& dimensions,
-                                               media::VideoPixelFormat format,
-                                               media::VideoPixelStorage storage,
-                                               int* buffer_id_to_drop) {
+int VideoCaptureBufferPoolImpl::ReserveForProducer(
+    const gfx::Size& dimensions,
+    media::VideoPixelFormat format,
+    media::VideoPixelStorage storage,
+    int* buffer_id_to_drop) {
   base::AutoLock lock(lock_);
   return ReserveForProducerInternal(dimensions, format, storage,
                                     buffer_id_to_drop);
 }
 
-void VideoCaptureBufferPool::RelinquishProducerReservation(int buffer_id) {
+void VideoCaptureBufferPoolImpl::RelinquishProducerReservation(int buffer_id) {
   base::AutoLock lock(lock_);
   Tracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return;
   }
   DCHECK(tracker->held_by_producer());
   tracker->set_held_by_producer(false);
   last_relinquished_buffer_id_ = buffer_id;
 }
 
-void VideoCaptureBufferPool::HoldForConsumers(
-    int buffer_id,
-    int num_clients) {
+void VideoCaptureBufferPoolImpl::HoldForConsumers(int buffer_id,
+                                                  int num_clients) {
   base::AutoLock lock(lock_);
   Tracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return;
   }
   DCHECK(tracker->held_by_producer());
   DCHECK(!tracker->consumer_hold_count());
 
   tracker->set_consumer_hold_count(num_clients);
   // Note: |held_by_producer()| will stay true until
   // RelinquishProducerReservation() (usually called by destructor of the object
   // wrapping this tracker, e.g. a media::VideoFrame).
 }
 
-void VideoCaptureBufferPool::RelinquishConsumerHold(int buffer_id,
-                                                    int num_clients) {
+void VideoCaptureBufferPoolImpl::RelinquishConsumerHold(int buffer_id,
+                                                        int num_clients) {
   base::AutoLock lock(lock_);
   Tracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return;
   }
   DCHECK_GE(tracker->consumer_hold_count(), num_clients);
 
   tracker->set_consumer_hold_count(tracker->consumer_hold_count() -
                                    num_clients);
 }
 
-int VideoCaptureBufferPool::ResurrectLastForProducer(
+int VideoCaptureBufferPoolImpl::ResurrectLastForProducer(
     const gfx::Size& dimensions,
     media::VideoPixelFormat format,
     media::VideoPixelStorage storage) {
   base::AutoLock lock(lock_);
 
   // Return early if the last relinquished buffer has been re-used already.
   if (last_relinquished_buffer_id_ == kInvalidId)
     return kInvalidId;
 
   // If there are no consumers reading from this buffer, then it's safe to
   // provide this buffer back to the producer (because the producer may
   // potentially modify the content). Check that the expected dimensions,
   // format, and storage match.
   TrackerMap::iterator it = trackers_.find(last_relinquished_buffer_id_);
   DCHECK(it != trackers_.end());
   DCHECK(!it->second->held_by_producer());
   if (it->second->consumer_hold_count() == 0 &&
       it->second->dimensions() == dimensions &&
       it->second->pixel_format() == format &&
       it->second->storage_type() == storage) {
     it->second->set_held_by_producer(true);
     const int resurrected_buffer_id = last_relinquished_buffer_id_;
     last_relinquished_buffer_id_ = kInvalidId;
     return resurrected_buffer_id;
   }
 
   return kInvalidId;
 }
 
-double VideoCaptureBufferPool::GetBufferPoolUtilization() const {
+double VideoCaptureBufferPoolImpl::GetBufferPoolUtilization() const {
   base::AutoLock lock(lock_);
   int num_buffers_held = 0;
   for (const auto& entry : trackers_) {
     Tracker* const tracker = entry.second;
     if (tracker->held_by_producer() || tracker->consumer_hold_count() > 0)
       ++num_buffers_held;
   }
   return static_cast<double>(num_buffers_held) / count_;
 }
 
-int VideoCaptureBufferPool::ReserveForProducerInternal(
+int VideoCaptureBufferPoolImpl::ReserveForProducerInternal(
     const gfx::Size& dimensions,
     media::VideoPixelFormat pixel_format,
     media::VideoPixelStorage storage_type,
     int* buffer_id_to_drop) {
   lock_.AssertAcquired();
 
   const size_t size_in_pixels = dimensions.GetArea();
   // Look for a tracker that's allocated, big enough, and not in use. Track the
   // largest one that's not big enough, in case we have to reallocate a tracker.
   *buffer_id_to_drop = kInvalidId;
@@ skipping 57 matching lines @@
     DLOG(ERROR) << "Error initializing Tracker";
     return kInvalidId;
   }
 
   tracker->set_held_by_producer(true);
   trackers_[buffer_id] = tracker.release();
 
   return buffer_id;
 }
 
-VideoCaptureBufferPool::Tracker* VideoCaptureBufferPool::GetTracker(
+VideoCaptureBufferPoolImpl::Tracker* VideoCaptureBufferPoolImpl::GetTracker(
     int buffer_id) {
   TrackerMap::const_iterator it = trackers_.find(buffer_id);
   return (it == trackers_.end()) ? NULL : it->second;
 }
 
 }  // namespace content