Pass GpuMemoryBuffer backed VideoFrame from browser to renderer processes

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 cef4d460ae61f79e6e11fe14453cc7352eb78a39..ddfdf61883ad77f04a90cdb4cfe3e5c20356a18f 100644
--- a/content/browser/renderer_host/media/video_capture_buffer_pool.cc
+++ b/content/browser/renderer_host/media/video_capture_buffer_pool.cc
@@ -19,17 +19,24 @@ const int VideoCaptureBufferPool::kInvalidId = -1;
 // A simple holder of a memory-backed buffer and accessors to it.
 class SimpleBufferHandle final : public VideoCaptureBufferPool::BufferHandle {
  public:
-  SimpleBufferHandle(void* data, size_t size, base::SharedMemoryHandle handle)
+  SimpleBufferHandle(void* data,
+                     size_t mapped_size,
+                     base::SharedMemoryHandle handle)
       : data_(data),
-        size_(size)
+        mapped_size_(mapped_size)
 #if defined(OS_POSIX)
-        , handle_(handle)
+        ,
+        handle_(handle)
 #endif
   {
   }
   ~SimpleBufferHandle() override {}
 
-  size_t size() const override { return size_; }
+  gfx::Size dimensions() const override {
+    NOTREACHED();
+    return gfx::Size();
+  }
+  size_t mapped_size() const override { return mapped_size_; }
   void* data(int plane) override {
     DCHECK_EQ(plane, 0);
     return data_;
@@ -50,7 +57,7 @@ class SimpleBufferHandle final : public VideoCaptureBufferPool::BufferHandle {
 
  private:
   void* const data_;
-  const size_t size_;
+  const size_t mapped_size_;
 #if defined(OS_POSIX)
   const base::SharedMemoryHandle handle_;
 #endif
@@ -75,9 +82,8 @@ class GpuMemoryBufferBufferHandle final
   }
   ~GpuMemoryBufferBufferHandle() override {}
 
-  size_t size() const override {
-    return dimensions_.GetArea();
-  }
+  gfx::Size dimensions() const override { return dimensions_; }
+  size_t mapped_size() const override { return dimensions_.GetArea(); }
   void* data(int plane) override {
     DCHECK_GE(plane, media::VideoFrame::kYPlane);
     DCHECK_LT(plane, static_cast<int>(data_->size()));
@@ -109,21 +115,21 @@ class VideoCaptureBufferPool::SharedMemTracker final : public Tracker {
             media::VideoPixelStorage storage_type,
             const gfx::Size& dimensions) override;
 
-  size_t mapped_size() const override { return shared_memory_.mapped_size(); }
-
   scoped_ptr<BufferHandle> GetBufferHandle() override {
     return make_scoped_ptr(new SimpleBufferHandle(
-        shared_memory_.memory(), mapped_size(), shared_memory_.handle()));
+        shared_memory_.memory(), mapped_size_, shared_memory_.handle()));
   }
-
-  bool ShareToProcess(base::ProcessHandle process_handle,
-                      base::SharedMemoryHandle* new_handle) override {
-    return shared_memory_.ShareToProcess(process_handle, new_handle);
+  bool ShareToProcess(int plane,
+                      base::ProcessHandle process_handle,
+                      void* new_handle) override {
+    return shared_memory_.ShareToProcess(
+        process_handle, static_cast<base::SharedMemoryHandle*>(new_handle));

[reveman, 2015/08/26 11:54:04]

can you refactor this to avoid this static_cast and void* return value?

[emircan, 2015/08/26 21:23:11]

Done.

   }
 
  private:
   // 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
@@ -136,18 +142,13 @@ class VideoCaptureBufferPool::GpuMemoryBufferTracker final : public Tracker {
             const gfx::Size& dimensions) override;
   ~GpuMemoryBufferTracker() override;
 
-  size_t mapped_size() const override {
-    NOTREACHED();
-    return 0;
-  }
   scoped_ptr<BufferHandle> GetBufferHandle() override {
     return make_scoped_ptr(new GpuMemoryBufferBufferHandle(
         &data_, dimensions_, &gpu_memory_buffers_));
   }
-  bool ShareToProcess(base::ProcessHandle process_handle,
-                      base::SharedMemoryHandle* new_handle) override {
-    return true;
-  }
+  bool ShareToProcess(int plane,
+                      base::ProcessHandle process_handle,
+                      void* new_handle) override;
 
  private:
   std::vector<void*> data_;
@@ -156,8 +157,7 @@ class VideoCaptureBufferPool::GpuMemoryBufferTracker final : public Tracker {
   ScopedVector<gfx::GpuMemoryBuffer> gpu_memory_buffers_;
 };
 
-VideoCaptureBufferPool::SharedMemTracker::SharedMemTracker() : Tracker() {
-}
+VideoCaptureBufferPool::SharedMemTracker::SharedMemTracker() : Tracker() {}
 
 bool VideoCaptureBufferPool::SharedMemTracker::Init(
     media::VideoCapturePixelFormat format,
@@ -168,12 +168,12 @@ bool VideoCaptureBufferPool::SharedMemTracker::Init(
   set_storage_type(storage_type);
   // |dimensions| can be 0x0 for trackers that do not require memory backing.
   set_pixel_count(dimensions.GetArea());
-  const size_t byte_count =
+  mapped_size_ =
       media::VideoCaptureFormat(dimensions, 0.0f, format, storage_type)
           .ImageAllocationSize();
-  if (!byte_count)
+  if (!mapped_size_)
     return true;
-  return shared_memory_.CreateAndMapAnonymous(byte_count);
+  return shared_memory_.CreateAndMapAnonymous(mapped_size_);
 }
 
 VideoCaptureBufferPool::GpuMemoryBufferTracker::GpuMemoryBufferTracker()
@@ -229,6 +229,38 @@ bool VideoCaptureBufferPool::GpuMemoryBufferTracker::Init(
   return true;
 }
 
+bool VideoCaptureBufferPool::GpuMemoryBufferTracker::ShareToProcess(
+    int plane,
+    base::ProcessHandle process_handle,
+    void* new_handle) {
+   DCHECK_LE(plane, static_cast<int>(gpu_memory_buffers_.size()));
+
+   const auto& current_gmb_handle = gpu_memory_buffers_[plane]->GetHandle();
+   gfx::GpuMemoryBufferHandle* const new_gmb_handle =
+       static_cast<gfx::GpuMemoryBufferHandle*>(new_handle);
+   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_gmb_handle->handle);
+       DCHECK(base::SharedMemory::IsHandleValid(new_gmb_handle->handle));
+       new_gmb_handle->type = gfx::SHARED_MEMORY_BUFFER;
+       return true;
+     }
+     case gfx::IO_SURFACE_BUFFER:
+     case gfx::SURFACE_TEXTURE_BUFFER:
+     case gfx::OZONE_NATIVE_PIXMAP:
+       *new_gmb_handle = current_gmb_handle;
+       return true;
+   }
+   return true;

[reveman, 2015/08/26 11:54:04]

NOTREACHED() before this?

[emircan, 2015/08/26 21:23:11]

Done.

+ }
+
 // static
 scoped_ptr<VideoCaptureBufferPool::Tracker>
 VideoCaptureBufferPool::Tracker::CreateTracker(bool use_gmb) {
@@ -250,24 +282,22 @@ VideoCaptureBufferPool::~VideoCaptureBufferPool() {
   STLDeleteValues(&trackers_);
 }
 
-base::SharedMemoryHandle VideoCaptureBufferPool::ShareToProcess(
+bool VideoCaptureBufferPool::ShareToProcess(
     int buffer_id,
+    int plane,
     base::ProcessHandle process_handle,
-    size_t* memory_size) {
+    void* new_handle) {
   base::AutoLock lock(lock_);
 
   Tracker* tracker = GetTracker(buffer_id);
   if (!tracker) {
     NOTREACHED() << "Invalid buffer_id.";
-    return base::SharedMemory::NULLHandle();
-  }
-  base::SharedMemoryHandle remote_handle;
-  if (tracker->ShareToProcess(process_handle, &remote_handle)) {
-    *memory_size = tracker->mapped_size();
-    return remote_handle;
+    return false;
   }
-  DPLOG(ERROR) << "Error mapping Shared Memory";
-  return base::SharedMemoryHandle();
+  if (tracker->ShareToProcess(plane, process_handle, new_handle))
+    return true;
+  DPLOG(ERROR) << "Error mapping memory";
+  return false;
 }
 
 scoped_ptr<VideoCaptureBufferPool::BufferHandle>