Cleanup of passing GpuMemoryBuffer backed video frames

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 409 matching lines @@
     std::unique_ptr<base::DictionaryValue> metadata(
         new base::DictionaryValue());
     frame->metadata()->MergeInternalValuesInto(metadata.get());
 
     // Only I420 pixel format is currently supported.
     DCHECK_EQ(frame->format(), media::PIXEL_FORMAT_I420)
         << "Unsupported pixel format: "
         << media::VideoPixelFormatToString(frame->format());
 
     // Sanity-checks to confirm |frame| is actually being backed by |buffer|.
-    DCHECK(frame->storage_type() == media::VideoFrame::STORAGE_SHMEM ||
-           (frame->storage_type() ==
-                media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS));
+    DCHECK(frame->storage_type() == media::VideoFrame::STORAGE_SHMEM);
     DCHECK(frame->data(media::VideoFrame::kYPlane) >= buffer->data(0) &&
            (frame->data(media::VideoFrame::kYPlane) <
             (reinterpret_cast<const uint8_t*>(buffer->data(0)) +
              buffer->mapped_size())))
         << "VideoFrame does not appear to be backed by Buffer";
 
     for (const auto& client : controller_clients_) {
       if (client->session_closed || client->paused)
         continue;
 
@@ skipping 62 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: {
-      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;
-        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);
-      client->event_handler->OnBufferCreated(
-          client->controller_id, remote_handle, buffer->mapped_size(),
-          buffer_id);
-      break;
-    }
-    default:
-      NOTREACHED();
-      break;
-  }
+  DCHECK_EQ(media::VideoFrame::STORAGE_SHMEM, frame->storage_type());
+
+  base::SharedMemoryHandle remote_handle;
+  buffer_pool_->ShareToProcess(buffer_id, client->render_process_handle,
+                               &remote_handle);
+  client->event_handler->OnBufferCreated(client->controller_id, remote_handle,
+                                         buffer->mapped_size(), buffer_id);
 }
 
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     VideoCaptureControllerID id,
     VideoCaptureControllerEventHandler* handler,
     const ControllerClients& clients) {
   for (const auto& client : clients) {
     if (client->controller_id == id && client->event_handler == handler)
       return client.get();
   }
   return nullptr;
 }
 
 VideoCaptureController::ControllerClient* VideoCaptureController::FindClient(
     int session_id,
     const ControllerClients& clients) {
   for (const auto& client : clients) {
     if (client->session_id == session_id)
       return client.get();
   }
   return nullptr;
 }
 
 }  // namespace content