Cleanup of video capture into GpuMemoryBuffer

content/browser/renderer_host/media/video_capture_controller.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.
 
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 201 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::AddClient() -- id=" << id
            << ", session_id=" << session_id
            << ", params.requested_format="
            << media::VideoCaptureFormat::ToString(params.requested_format);
 
   // Check that requested VideoCaptureParams are valid and supported.  If not,
   // report an error immediately and punt.
   if (!params.IsValid() ||
       params.requested_format.pixel_format != media::PIXEL_FORMAT_I420 ||
-      (params.requested_format.pixel_storage != media::PIXEL_STORAGE_CPU &&
-       params.requested_format.pixel_storage !=
-           media::PIXEL_STORAGE_GPUMEMORYBUFFER)) {
+      params.requested_format.pixel_storage != media::PIXEL_STORAGE_CPU) {
     // Crash in debug builds since the renderer should not have asked for
     // invalid or unsupported parameters.
     LOG(DFATAL) << "Invalid or unsupported video capture parameters requested: "
                 << media::VideoCaptureFormat::ToString(params.requested_format);
     event_handler->OnError(id);
     return;
   }
 
   // If this is the first client added to the controller, cache the parameters.
   if (controller_clients_.empty())
@@ skipping 109 matching lines @@
   if (client) {
     client->session_closed = true;
     client->event_handler->OnEnded(client->controller_id);
   }
 }
 
 void VideoCaptureController::ReturnBuffer(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* event_handler,
     int buffer_id,
     const gpu::SyncToken& sync_token,

[mcasas, 2016/10/07 00:56:16]

We can also remove |sync_token| and associated
logic from this file IIUC.

[emircan, 2016/10/07 17:40:12]

As I noted earlier I am cleaning up IPC in CL#2, and sync tokens come from
there, see https://codereview.chromium.org/2395913003/.

     double consumer_resource_utilization) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ControllerClient* client = FindClient(id, event_handler, controller_clients_);
 
   // If this buffer is not held by this client, or this client doesn't exist
   // in controller, do nothing.
   ControllerClient::ActiveBufferMap::iterator iter;
   if (!client || (iter = client->active_buffers.find(buffer_id)) ==
                      client->active_buffers.end()) {
@@ skipping 143 matching lines @@
 }
 
 void VideoCaptureController::DoNewBufferOnIOThread(
     ControllerClient* client,
     media::VideoCaptureDevice::Client::Buffer* buffer,
     const scoped_refptr<media::VideoFrame>& frame) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   const int buffer_id = buffer->id();
 
   switch (frame->storage_type()) {
     case media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS: {

[chfremer, 2016/10/06 16:45:00]

I think it is okay to keep the switch, since we are still keeping the enum. But
any reason why we cannot remove the complete case block for the GPU case?

[emircan, 2016/10/07 17:40:12]

I am leaving cleaning up media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS storage
type in CL#2, see https://codereview.chromium.org/2395913003/.

       std::vector<gfx::GpuMemoryBufferHandle> handles;
       const size_t num_planes = media::VideoFrame::NumPlanes(frame->format());
       for (size_t i = 0; i < num_planes; ++i) {
         gfx::GpuMemoryBufferHandle remote_handle;
-        buffer_pool_->ShareToProcess2(
-            buffer_id, i, client->render_process_handle, &remote_handle);
         handles.push_back(remote_handle);
       }
       client->event_handler->OnBufferCreated2(client->controller_id, handles,
                                               buffer->dimensions(), buffer_id);
       break;
     }
     case media::VideoFrame::STORAGE_SHMEM: {
       base::SharedMemoryHandle remote_handle;
       buffer_pool_->ShareToProcess(buffer_id, client->render_process_handle,
                                    &remote_handle);
@@ skipping 23 matching lines @@
     int session_id,
     const ControllerClients& clients) {
   for (const auto& client : clients) {
     if (client->session_id == session_id)
       return client.get();
   }
   return nullptr;
 }
 
 }  // namespace content