Extract nested and private classes from VideoCaptureBufferPool

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 "content/browser/renderer_host/media/video_capture_buffer_handle.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::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),
       last_relinquished_buffer_id_(kInvalidId) {
   DCHECK_GT(count, 0);
 }
 
 VideoCaptureBufferPoolImpl::~VideoCaptureBufferPoolImpl() {
   base::STLDeleteValues(&trackers_);
 }
 
 bool VideoCaptureBufferPoolImpl::ShareToProcess(
     int buffer_id,
     base::ProcessHandle process_handle,
     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;
   }
   if (tracker->ShareToProcess(process_handle, new_handle))
     return true;
   DPLOG(ERROR) << "Error mapping memory";
   return false;
 }
 
 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);
+  VideoCaptureBufferTracker* 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<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());
   return tracker->GetBufferHandle();
 }
 
 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 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;
   }
   DCHECK(tracker->held_by_producer());
   tracker->set_held_by_producer(false);
   last_relinquished_buffer_id_ = 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;
   }
   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 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;
   }
   DCHECK_GE(tracker->consumer_hold_count(), num_clients);
 
   tracker->set_consumer_hold_count(tracker->consumer_hold_count() -
                                    num_clients);
 }
 
@@ skipping 24 matching lines @@
     return resurrected_buffer_id;
   }
 
   return kInvalidId;
 }
 
 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;
   }
   return static_cast<double>(num_buffers_held) / count_;
 }
 
 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;
   size_t largest_size_in_pixels = 0;
   TrackerMap::iterator tracker_of_last_resort = trackers_.end();
   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) &&
           (tracker->storage_type() == storage_type)) {
         if (it->first == last_relinquished_buffer_id_) {
           // This buffer would do just fine, but avoid returning it because the
           // client may want to resurrect it. It will be returned perforce if
           // the pool has reached it's maximum limit (see code below).
           tracker_of_last_resort = it;
           continue;
@@ skipping 27 matching lines @@
     if (tracker_to_drop->first == last_relinquished_buffer_id_)
       last_relinquished_buffer_id_ = kInvalidId;
     *buffer_id_to_drop = tracker_to_drop->first;
     delete tracker_to_drop->second;
     trackers_.erase(tracker_to_drop);
   }
 
   // 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;
   }
 
   tracker->set_held_by_producer(true);
   trackers_[buffer_id] = tracker.release();
 
   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;
 }
 
 }  // namespace content