Extract nested and private classes from VideoCaptureBufferPool

content/browser/renderer_host/media/video_capture_buffer_pool.cc

Index: content/browser/renderer_host/media/video_capture_buffer_pool.cc
diff --git a/content/browser/renderer_host/media/video_capture_buffer_pool.cc b/content/browser/renderer_host/media/video_capture_buffer_pool.cc
index 963e72bbdbf8c246fd75a37d7486583d14a1150d..e4347d8962d85b9d101fbf42ce8388d84c406f32 100644
--- a/content/browser/renderer_host/media/video_capture_buffer_pool.cc
+++ b/content/browser/renderer_host/media/video_capture_buffer_pool.cc
@@ -10,238 +10,12 @@
 #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 "content/browser/renderer_host/media/video_capture_buffer_tracker.h"
+#include "content/browser/renderer_host/media/video_capture_buffer_tracker_factory.h"
 #include "ui/gfx/buffer_format_util.h"
 
 namespace content {
 
-// Tracker specifics for SharedMemory.
-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.
-    set_max_pixel_count(dimensions.GetArea());
-    set_pixel_format(format);
-    set_storage_type(storage_type);
-    mapped_size_ =
-        media::VideoCaptureFormat(dimensions, 0.0f, format, storage_type)
-            .ImageAllocationSize();
-    if (!mapped_size_)
-      return true;
-    return shared_memory_.CreateAndMapAnonymous(mapped_size_);
-  }
-
-  std::unique_ptr<BufferHandle> GetBufferHandle() override {
-    return base::MakeUnique<SharedMemBufferHandle>(this);
-  }
-  bool ShareToProcess(base::ProcessHandle process_handle,
-                      base::SharedMemoryHandle* new_handle) override {
-    return shared_memory_.ShareToProcess(process_handle, new_handle);
-  }
-  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 VideoCaptureBufferPoolImpl::BufferHandle {
-   public:
-    // |tracker| must outlive SimpleBufferHandle. This is ensured since a
-    // tracker is pinned until ownership of this SimpleBufferHandle is returned
-    // 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();
-    }
-    ClientBuffer AsClientBuffer(int plane) override {
-      NOTREACHED();
-      return nullptr;
-    }
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
-    base::FileDescriptor AsPlatformFile() override {
-      return tracker_->shared_memory_.handle();
-    }
-#endif
-
-   private:
-    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 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,
-            media::VideoPixelStorage storage_type,
-            base::Lock* lock) override {
-    DVLOG(2) << "allocating GMB for " << dimensions.ToString();
-    // BrowserGpuMemoryBufferManager::current() may not be accessed on IO
-    // Thread.
-    DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
-    DCHECK(BrowserGpuMemoryBufferManager::current());
-    // This class is only expected to be called with I420 buffer requests at
-    // this point.
-    DCHECK_EQ(format, media::PIXEL_FORMAT_I420);
-    set_dimensions(dimensions);
-    set_max_pixel_count(dimensions.GetArea());
-    set_pixel_format(format);
-    set_storage_type(storage_type);
-    // |dimensions| can be 0x0 for trackers that do not require memory backing.
-    if (dimensions.GetArea() == 0u)
-      return true;
-
-    base::AutoUnlock auto_unlock(*lock);
-    const size_t num_planes = media::VideoFrame::NumPlanes(pixel_format());
-    for (size_t i = 0; i < num_planes; ++i) {
-      const gfx::Size& size =
-          media::VideoFrame::PlaneSize(pixel_format(), i, dimensions);
-      gpu_memory_buffers_.push_back(
-          BrowserGpuMemoryBufferManager::current()->AllocateGpuMemoryBuffer(
-              size, gfx::BufferFormat::R_8,
-              gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
-              gpu::kNullSurfaceHandle));
-
-      DLOG_IF(ERROR, !gpu_memory_buffers_[i]) << "Allocating GpuMemoryBuffer";
-      if (!gpu_memory_buffers_[i] || !gpu_memory_buffers_[i]->Map())
-        return false;
-    }
-    return true;
-  }
-
-  std::unique_ptr<BufferHandle> GetBufferHandle() override {
-    DCHECK_EQ(gpu_memory_buffers_.size(),
-              media::VideoFrame::NumPlanes(pixel_format()));
-    return base::MakeUnique<GpuMemoryBufferBufferHandle>(this);
-  }
-
-  bool ShareToProcess(base::ProcessHandle process_handle,
-                      base::SharedMemoryHandle* new_handle) override {
-    NOTREACHED();
-    return false;
-  }
-
-  bool ShareToProcess2(int plane,
-                       base::ProcessHandle process_handle,
-                       gfx::GpuMemoryBufferHandle* new_handle) override {
-    DCHECK_LE(plane, static_cast<int>(gpu_memory_buffers_.size()));
-
-    const auto& current_gmb_handle = gpu_memory_buffers_[plane]->GetHandle();
-    switch (current_gmb_handle.type) {
-      case gfx::EMPTY_BUFFER:
-        NOTREACHED();
-        return false;
-      case gfx::SHARED_MEMORY_BUFFER: {
-        DCHECK(base::SharedMemory::IsHandleValid(current_gmb_handle.handle));
-        base::SharedMemory shared_memory(
-            base::SharedMemory::DuplicateHandle(current_gmb_handle.handle),
-            false);
-        shared_memory.ShareToProcess(process_handle, &new_handle->handle);
-        DCHECK(base::SharedMemory::IsHandleValid(new_handle->handle));
-        new_handle->type = gfx::SHARED_MEMORY_BUFFER;
-        return true;
-      }
-      case gfx::IO_SURFACE_BUFFER:
-      case gfx::SURFACE_TEXTURE_BUFFER:
-      case gfx::OZONE_NATIVE_PIXMAP:
-        *new_handle = current_gmb_handle;
-        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 VideoCaptureBufferPoolImpl::BufferHandle {
-   public:
-    // |tracker| must outlive GpuMemoryBufferBufferHandle. This is ensured since
-    // a tracker is pinned until ownership of this GpuMemoryBufferBufferHandle
-    // 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);
-      DCHECK_LT(plane, static_cast<int>(tracker_->gpu_memory_buffers_.size()));
-      DCHECK(tracker_->gpu_memory_buffers_[plane]);
-      return tracker_->gpu_memory_buffers_[plane]->memory(0);
-    }
-    ClientBuffer AsClientBuffer(int plane) override {
-      DCHECK_GE(plane, 0);
-      DCHECK_LT(plane, static_cast<int>(tracker_->gpu_memory_buffers_.size()));
-      return tracker_->gpu_memory_buffers_[plane]->AsClientBuffer();
-    }
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
-    base::FileDescriptor AsPlatformFile() override {
-      NOTREACHED();
-      return base::FileDescriptor();
-    }
-#endif
-
-   private:
-    GpuMemoryBufferTracker* const tracker_;
-  };
-
-  // Owned references to GpuMemoryBuffers.
-  std::vector<std::unique_ptr<gfx::GpuMemoryBuffer>> gpu_memory_buffers_;
-};
-
-// static
-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<VideoCaptureBufferPoolImpl::Tracker>();
-}
-
-VideoCaptureBufferPoolImpl::Tracker::~Tracker() {}
-
 VideoCaptureBufferPoolImpl::VideoCaptureBufferPoolImpl(int count)
     : count_(count),
       next_buffer_id_(0),
@@ -259,7 +33,7 @@ bool VideoCaptureBufferPoolImpl::ShareToProcess(
     base::SharedMemoryHandle* new_handle) {
   base::AutoLock lock(lock_);
 
-  Tracker* tracker = GetTracker(buffer_id);
+  VideoCaptureBufferTracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return false;
@@ -277,7 +51,7 @@ bool VideoCaptureBufferPoolImpl::ShareToProcess2(
     gfx::GpuMemoryBufferHandle* new_handle) {
   base::AutoLock lock(lock_);
 
-  Tracker* tracker = GetTracker(buffer_id);
+  VideoCaptureBufferTracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return false;
@@ -288,14 +62,14 @@ bool VideoCaptureBufferPoolImpl::ShareToProcess2(
   return false;
 }
 
-std::unique_ptr<VideoCaptureBufferPoolImpl::BufferHandle>
+std::unique_ptr<VideoCaptureBufferHandle>
 VideoCaptureBufferPoolImpl::GetBufferHandle(int buffer_id) {
   base::AutoLock lock(lock_);
 
-  Tracker* tracker = GetTracker(buffer_id);
+  VideoCaptureBufferTracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
-    return std::unique_ptr<BufferHandle>();
+    return std::unique_ptr<VideoCaptureBufferHandle>();
   }
 
   DCHECK(tracker->held_by_producer());
@@ -314,7 +88,7 @@ int VideoCaptureBufferPoolImpl::ReserveForProducer(
 
 void VideoCaptureBufferPoolImpl::RelinquishProducerReservation(int buffer_id) {
   base::AutoLock lock(lock_);
-  Tracker* tracker = GetTracker(buffer_id);
+  VideoCaptureBufferTracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return;
@@ -327,7 +101,7 @@ void VideoCaptureBufferPoolImpl::RelinquishProducerReservation(int buffer_id) {
 void VideoCaptureBufferPoolImpl::HoldForConsumers(int buffer_id,
                                                   int num_clients) {
   base::AutoLock lock(lock_);
-  Tracker* tracker = GetTracker(buffer_id);
+  VideoCaptureBufferTracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return;
@@ -344,7 +118,7 @@ void VideoCaptureBufferPoolImpl::HoldForConsumers(int buffer_id,
 void VideoCaptureBufferPoolImpl::RelinquishConsumerHold(int buffer_id,
                                                         int num_clients) {
   base::AutoLock lock(lock_);
-  Tracker* tracker = GetTracker(buffer_id);
+  VideoCaptureBufferTracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
     return;
@@ -389,7 +163,7 @@ double VideoCaptureBufferPoolImpl::GetBufferPoolUtilization() const {
   base::AutoLock lock(lock_);
   int num_buffers_held = 0;
   for (const auto& entry : trackers_) {
-    Tracker* const tracker = entry.second;
+    VideoCaptureBufferTracker* const tracker = entry.second;
     if (tracker->held_by_producer() || tracker->consumer_hold_count() > 0)
       ++num_buffers_held;
   }
@@ -412,7 +186,7 @@ int VideoCaptureBufferPoolImpl::ReserveForProducerInternal(
   TrackerMap::iterator tracker_to_drop = trackers_.end();
   for (TrackerMap::iterator it = trackers_.begin(); it != trackers_.end();
        ++it) {
-    Tracker* const tracker = it->second;
+    VideoCaptureBufferTracker* const tracker = it->second;
     if (!tracker->consumer_hold_count() && !tracker->held_by_producer()) {
       if (tracker->max_pixel_count() >= size_in_pixels &&
           (tracker->pixel_format() == pixel_format) &&
@@ -460,11 +234,12 @@ int VideoCaptureBufferPoolImpl::ReserveForProducerInternal(
   // Create the new tracker.
   const int buffer_id = next_buffer_id_++;
 
-  std::unique_ptr<Tracker> tracker = Tracker::CreateTracker(storage_type);
+  std::unique_ptr<VideoCaptureBufferTracker> tracker =
+      VideoCaptureBufferTrackerFactory::CreateTracker(storage_type);
   // TODO(emircan): We pass the lock here to solve GMB allocation issue, see
   // crbug.com/545238.
   if (!tracker->Init(dimensions, pixel_format, storage_type, &lock_)) {
-    DLOG(ERROR) << "Error initializing Tracker";
+    DLOG(ERROR) << "Error initializing VideoCaptureBufferTracker";
     return kInvalidId;
   }
 
@@ -474,7 +249,7 @@ int VideoCaptureBufferPoolImpl::ReserveForProducerInternal(
   return buffer_id;
 }
 
-VideoCaptureBufferPoolImpl::Tracker* VideoCaptureBufferPoolImpl::GetTracker(
+VideoCaptureBufferTracker* VideoCaptureBufferPoolImpl::GetTracker(
     int buffer_id) {
   TrackerMap::const_iterator it = trackers_.find(buffer_id);
   return (it == trackers_.end()) ? NULL : it->second;