Cleanup of passing GpuMemoryBuffer backed video frames

content/renderer/media/video_capture_impl.cc

Index: content/renderer/media/video_capture_impl.cc
diff --git a/content/renderer/media/video_capture_impl.cc b/content/renderer/media/video_capture_impl.cc
index bc1c4bce27116e91c31aeb3666c87984e58508f9..c8ca0f58190d47e5623ce885ed361902d0b856b5 100644
--- a/content/renderer/media/video_capture_impl.cc
+++ b/content/renderer/media/video_capture_impl.cc
@@ -20,7 +20,6 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/child/child_process.h"
 #include "content/common/media/video_capture_messages.h"
-#include "gpu/ipc/client/gpu_memory_buffer_impl.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/limits.h"
 #include "media/base/video_frame.h"
@@ -48,58 +47,6 @@ class VideoCaptureImpl::ClientBuffer
   DISALLOW_COPY_AND_ASSIGN(ClientBuffer);
 };
 
-// A holder of a GpuMemoryBuffer-backed buffer, Map()ed on ctor and Unmap()ed on
-// dtor. Creates and owns GpuMemoryBuffer instances.
-class VideoCaptureImpl::ClientBuffer2
-    : public base::RefCountedThreadSafe<ClientBuffer2> {
- public:
-  ClientBuffer2(
-      const std::vector<gfx::GpuMemoryBufferHandle>& client_handles,
-      const gfx::Size& size)
-      : handles_(client_handles),
-        size_(size) {
-    const media::VideoPixelFormat format = media::PIXEL_FORMAT_I420;
-    DCHECK_EQ(handles_.size(), media::VideoFrame::NumPlanes(format));
-    for (size_t i = 0; i < handles_.size(); ++i) {
-      const size_t width = media::VideoFrame::Columns(i, format, size_.width());
-      const size_t height = media::VideoFrame::Rows(i, format, size_.height());
-      buffers_.push_back(gpu::GpuMemoryBufferImpl::CreateFromHandle(
-          handles_[i], gfx::Size(width, height), gfx::BufferFormat::R_8,
-          gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
-          base::Bind(&ClientBuffer2::DestroyGpuMemoryBuffer,
-                     base::Unretained(this))));
-      bool rv = buffers_[i]->Map();
-      DCHECK(rv);
-      data_[i] = reinterpret_cast<uint8_t*>(buffers_[i]->memory(0u));
-      strides_[i] = width;
-    }
-  }
-
-  uint8_t* data(int plane) const { return data_[plane]; }
-  int32_t stride(int plane) const { return strides_[plane]; }
-  std::vector<gfx::GpuMemoryBufferHandle> gpu_memory_buffer_handles() {
-    return handles_;
-  }
-
- private:
-  friend class base::RefCountedThreadSafe<ClientBuffer2>;
-
-  virtual ~ClientBuffer2() {
-    for (auto* buffer : buffers_)
-      buffer->Unmap();
-  }
-
-  void DestroyGpuMemoryBuffer(const gpu::SyncToken& sync_token) {}
-
-  const std::vector<gfx::GpuMemoryBufferHandle> handles_;
-  const gfx::Size size_;
-  ScopedVector<gfx::GpuMemoryBuffer> buffers_;
-  uint8_t* data_[media::VideoFrame::kMaxPlanes];
-  int32_t strides_[media::VideoFrame::kMaxPlanes];
-
-  DISALLOW_COPY_AND_ASSIGN(ClientBuffer2);
-};
-
 VideoCaptureImpl::ClientInfo::ClientInfo() {}
 VideoCaptureImpl::ClientInfo::ClientInfo(const ClientInfo& other) = default;
 VideoCaptureImpl::ClientInfo::~ClientInfo() {}
@@ -203,7 +150,6 @@ void VideoCaptureImpl::StopCapture(int client_id) {
   DVLOG(1) << "StopCapture: No more client, stopping ...";
   StopDevice();
   client_buffers_.clear();
-  client_buffer2s_.clear();
   weak_factory_.InvalidateWeakPtrs();
 }
 
@@ -256,24 +202,6 @@ void VideoCaptureImpl::OnBufferCreated(base::SharedMemoryHandle handle,
   DCHECK(inserted);
 }
 
-void VideoCaptureImpl::OnBufferCreated2(
-    const std::vector<gfx::GpuMemoryBufferHandle>& handles,
-    const gfx::Size& size,
-    int buffer_id) {
-  DCHECK(io_task_runner_->BelongsToCurrentThread());
-
-  // In case client calls StopCapture before the arrival of created buffer,
-  // just close this buffer and return.
-  if (state_ != VIDEO_CAPTURE_STATE_STARTED)
-    return;
-
-  const bool inserted =
-      client_buffer2s_.insert(std::make_pair(buffer_id,
-                                             new ClientBuffer2(handles, size)))
-          .second;
-  DCHECK(inserted);
-}
-
 void VideoCaptureImpl::OnBufferDestroyed(int buffer_id) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
@@ -282,13 +210,6 @@ void VideoCaptureImpl::OnBufferDestroyed(int buffer_id) {
     DCHECK(!cb_iter->second.get() || cb_iter->second->HasOneRef())
         << "Instructed to delete buffer we are still using.";
     client_buffers_.erase(cb_iter);
-  } else {
-    const auto& cb2_iter = client_buffer2s_.find(buffer_id);
-    if (cb2_iter != client_buffer2s_.end()) {
-      DCHECK(!cb2_iter->second.get() || cb2_iter->second->HasOneRef())
-          << "Instructed to delete buffer we are still using.";
-      client_buffer2s_.erase(cb2_iter);
-    }
   }
 }
 
@@ -301,15 +222,13 @@ void VideoCaptureImpl::OnBufferReceived(
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
+  // Crash in debug builds since the host should not have provided a buffer
+  // with an unsupported pixel format or storage type.
+  DCHECK_EQ(media::PIXEL_FORMAT_I420, pixel_format);
+  DCHECK(storage_type == media::VideoFrame::STORAGE_SHMEM);
   if (state_ != VIDEO_CAPTURE_STATE_STARTED ||
       pixel_format != media::PIXEL_FORMAT_I420 ||
-      (storage_type != media::VideoFrame::STORAGE_SHMEM &&
-       storage_type != media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS)) {
-    // Crash in debug builds since the host should not have provided a buffer
-    // with an unsupported pixel format or storage type.
-    DCHECK_EQ(media::PIXEL_FORMAT_I420, pixel_format);
-    DCHECK(storage_type == media::VideoFrame::STORAGE_SHMEM ||
-           storage_type == media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS);
+      storage_type != media::VideoFrame::STORAGE_SHMEM) {
     Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id,
                                              gpu::SyncToken(), -1.0));
     return;
@@ -340,56 +259,26 @@ void VideoCaptureImpl::OnBufferReceived(
                        (reference_time - base::TimeTicks()).InMicroseconds(),
                        "time_delta", timestamp.InMicroseconds());
 
-  scoped_refptr<media::VideoFrame> frame;
-  BufferFinishedCallback buffer_finished_callback;
-  std::unique_ptr<gpu::SyncToken> release_sync_token(new gpu::SyncToken);
-  switch (storage_type) {
-    case media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS: {
-      const auto& iter = client_buffer2s_.find(buffer_id);
-      DCHECK(iter != client_buffer2s_.end());
-      scoped_refptr<ClientBuffer2> buffer = iter->second;
-      const auto& handles = buffer->gpu_memory_buffer_handles();
-      frame = media::VideoFrame::WrapExternalYuvGpuMemoryBuffers(
-          media::PIXEL_FORMAT_I420, coded_size, gfx::Rect(coded_size),
-          coded_size, buffer->stride(media::VideoFrame::kYPlane),
-          buffer->stride(media::VideoFrame::kUPlane),
-          buffer->stride(media::VideoFrame::kVPlane),
-          buffer->data(media::VideoFrame::kYPlane),
-          buffer->data(media::VideoFrame::kUPlane),
-          buffer->data(media::VideoFrame::kVPlane),
-          handles[media::VideoFrame::kYPlane],
-          handles[media::VideoFrame::kUPlane],
-          handles[media::VideoFrame::kVPlane], timestamp);
-      buffer_finished_callback = media::BindToCurrentLoop(
-          base::Bind(&VideoCaptureImpl::OnClientBufferFinished2,
-                     weak_factory_.GetWeakPtr(), buffer_id, buffer));
-      break;
-    }
-    case media::VideoFrame::STORAGE_SHMEM: {
-      const auto& iter = client_buffers_.find(buffer_id);
-      DCHECK(iter != client_buffers_.end());
-      const scoped_refptr<ClientBuffer> buffer = iter->second;
-      frame = media::VideoFrame::WrapExternalSharedMemory(
+  const auto& iter = client_buffers_.find(buffer_id);
+  DCHECK(iter != client_buffers_.end());
+  const scoped_refptr<ClientBuffer> buffer = iter->second;
+  scoped_refptr<media::VideoFrame> frame =
+      media::VideoFrame::WrapExternalSharedMemory(
           pixel_format, coded_size, visible_rect,
           gfx::Size(visible_rect.width(), visible_rect.height()),
           reinterpret_cast<uint8_t*>(buffer->buffer()->memory()),
           buffer->buffer_size(), buffer->buffer()->handle(),
           0 /* shared_memory_offset */, timestamp);
-      buffer_finished_callback = media::BindToCurrentLoop(
-          base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
-                     weak_factory_.GetWeakPtr(), buffer_id, buffer));
-      break;
-    }
-    default:
-      NOTREACHED();
-      break;
-  }
   if (!frame) {
     Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id,
                                              gpu::SyncToken(), -1.0));
     return;
   }
 
+  BufferFinishedCallback buffer_finished_callback = media::BindToCurrentLoop(
+      base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
+                 weak_factory_.GetWeakPtr(), buffer_id, buffer));
+  std::unique_ptr<gpu::SyncToken> release_sync_token(new gpu::SyncToken);
   frame->AddDestructionObserver(
       base::Bind(&VideoCaptureImpl::DidFinishConsumingFrame, frame->metadata(),
                  base::Passed(&release_sync_token), buffer_finished_callback));
@@ -412,14 +301,6 @@ void VideoCaptureImpl::OnClientBufferFinished(
                                            release_sync_token,
                                            consumer_resource_utilization));
 }
-void VideoCaptureImpl::OnClientBufferFinished2(
-    int buffer_id,
-    const scoped_refptr<ClientBuffer2>& gpu_memory_buffer /* ignored_buffer */,
-    const gpu::SyncToken& release_sync_token,
-    double consumer_resource_utilization) {
-  OnClientBufferFinished(buffer_id, scoped_refptr<ClientBuffer>(),
-                         release_sync_token, consumer_resource_utilization);
-}
 
 void VideoCaptureImpl::OnStateChanged(VideoCaptureState state) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
@@ -433,7 +314,6 @@ void VideoCaptureImpl::OnStateChanged(VideoCaptureState state) {
       state_ = VIDEO_CAPTURE_STATE_STOPPED;
       DVLOG(1) << "OnStateChanged: stopped!, device_id = " << device_id_;
       client_buffers_.clear();
-      client_buffer2s_.clear();
       weak_factory_.InvalidateWeakPtrs();
       if (!clients_.empty() || !clients_pending_on_restart_.empty())
         RestartCapture();