Cleanup of passing GpuMemoryBuffer backed video frames

content/renderer/media/video_capture_impl.cc

 // Copyright (c) 2012 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.
 //
 // Notes about usage of this object by VideoCaptureImplManager.
 //
 // VideoCaptureImplManager access this object by using a Unretained()
 // binding and tasks on the IO thread. It is then important that
 // VideoCaptureImpl never post task to itself. All operations must be
 // synchronous.
 
 #include "content/renderer/media/video_capture_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #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"
 
 namespace content {
 
 // A holder of a memory-backed buffer and accessors to it.
 class VideoCaptureImpl::ClientBuffer
     : public base::RefCountedThreadSafe<ClientBuffer> {
  public:
   ClientBuffer(std::unique_ptr<base::SharedMemory> buffer, size_t buffer_size)
       : buffer_(std::move(buffer)), buffer_size_(buffer_size) {}
 
   base::SharedMemory* buffer() const { return buffer_.get(); }
   size_t buffer_size() const { return buffer_size_; }
 
  private:
   friend class base::RefCountedThreadSafe<ClientBuffer>;
 
   virtual ~ClientBuffer() {}
 
   const std::unique_ptr<base::SharedMemory> buffer_;
   const size_t buffer_size_;
 
   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() {}
 
 VideoCaptureImpl::VideoCaptureImpl(
     media::VideoCaptureSessionId session_id,
     VideoCaptureMessageFilter* filter,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
     : message_filter_(filter),
       device_id_(0),
@@ skipping 83 matching lines @@
     if (!RemoveClient(client_id, &clients_pending_on_restart_)) {
       RemoveClient(client_id, &clients_);
     }
   }
 
   if (!clients_.empty())
     return;
   DVLOG(1) << "StopCapture: No more client, stopping ...";
   StopDevice();
   client_buffers_.clear();
-  client_buffer2s_.clear();
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void VideoCaptureImpl::RequestRefreshFrame() {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   GetVideoCaptureHost()->RequestRefreshFrame(device_id_);
 }
 
 void VideoCaptureImpl::GetDeviceSupportedFormats(
     const VideoCaptureDeviceFormatsCB& callback) {
@@ skipping 32 matching lines @@
     return;
   }
   const bool inserted =
       client_buffers_.insert(std::make_pair(
                                  buffer_id,
                                  new ClientBuffer(std::move(shm), length)))
           .second;
   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());
 
   const auto& cb_iter = client_buffers_.find(buffer_id);
   if (cb_iter != client_buffers_.end()) {
     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);
-    }
   }
 }
 
 void VideoCaptureImpl::OnBufferReceived(
     int buffer_id,
     base::TimeDelta timestamp,
     const base::DictionaryValue& metadata,
     media::VideoPixelFormat pixel_format,
     media::VideoFrame::StorageType storage_type,
     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;
   }
 
   base::TimeTicks reference_time;
   media::VideoFrameMetadata frame_metadata;
   frame_metadata.MergeInternalValuesFrom(metadata);
   const bool success = frame_metadata.GetTimeTicks(
       media::VideoFrameMetadata::REFERENCE_TIME, &reference_time);
@@ skipping 10 matching lines @@
     timestamp = reference_time - first_frame_ref_time_;
 
   // TODO(qiangchen): Change the metric name to "reference_time" and
   // "timestamp", so that we have consistent naming everywhere.
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
   TRACE_EVENT_INSTANT2("cast_perf_test", "OnBufferReceived",
                        TRACE_EVENT_SCOPE_THREAD, "timestamp",
                        (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));
 
   frame->metadata()->MergeInternalValuesFrom(metadata);
 
   // TODO(qiangchen): Dive into the full code path to let frame metadata hold
   // reference time rather than using an extra parameter.
   for (const auto& client : clients_)
     client.second.deliver_frame_cb.Run(frame, reference_time);
 }
 
 void VideoCaptureImpl::OnClientBufferFinished(
     int buffer_id,
     const scoped_refptr<ClientBuffer>& /* ignored_buffer */,
     const gpu::SyncToken& release_sync_token,
     double consumer_resource_utilization) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id,
                                            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());
 
   switch (state) {
     case VIDEO_CAPTURE_STATE_STARTED:
       // Camera has started in the browser process. Since we have already
       // told all clients that we have started there's nothing to do.
       break;
     case VIDEO_CAPTURE_STATE_STOPPED:
       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();
       break;
     case VIDEO_CAPTURE_STATE_PAUSED:
     case VIDEO_CAPTURE_STATE_RESUMED:
       for (const auto& client : clients_)
         client.second.state_update_cb.Run(state);
       break;
     case VIDEO_CAPTURE_STATE_ERROR:
@@ skipping 127 matching lines @@
   double consumer_resource_utilization = -1.0;
   if (!metadata->GetDouble(media::VideoFrameMetadata::RESOURCE_UTILIZATION,
                            &consumer_resource_utilization)) {
     consumer_resource_utilization = -1.0;
   }
 
   callback_to_io_thread.Run(*release_sync_token, consumer_resource_utilization);
 }
 
 }  // namespace content