Cleanup of passing GpuMemoryBuffer backed video frames

media/gpu/ipc/client/gpu_video_encode_accelerator_host.cc

 // Copyright 2013 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 "media/gpu/ipc/client/gpu_video_encode_accelerator_host.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "media/base/video_frame.h"
 #include "media/gpu/gpu_video_accelerator_util.h"
 #include "media/gpu/ipc/common/media_messages.h"
 #include "media/video/video_encode_accelerator.h"
-#include "ui/gfx/gpu_memory_buffer.h"
 
 namespace media {
 
 GpuVideoEncodeAcceleratorHost::GpuVideoEncodeAcceleratorHost(
     gpu::CommandBufferProxyImpl* impl)
     : channel_(impl->channel()),
       encoder_route_id_(MSG_ROUTING_NONE),
       client_(nullptr),
       impl_(impl),
       next_frame_id_(0),
@@ skipping 82 matching lines @@
   }
   encoder_route_id_ = route_id;
   return true;
 }
 
 void GpuVideoEncodeAcceleratorHost::Encode(
     const scoped_refptr<VideoFrame>& frame,
     bool force_keyframe) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(PIXEL_FORMAT_I420, frame->format());
+  DCHECK_EQ(VideoFrame::STORAGE_SHMEM, frame->storage_type());
   if (!channel_)
     return;
 
   switch (frame->storage_type()) {
     case VideoFrame::STORAGE_SHMEM:
       EncodeSharedMemoryFrame(frame, force_keyframe);
       break;
-    case VideoFrame::STORAGE_GPU_MEMORY_BUFFERS:
-      EncodeGpuMemoryBufferFrame(frame, force_keyframe);
-      break;
     default:
       PostNotifyError(FROM_HERE, kPlatformFailureError,
                       "Encode(): cannot encode frame with invalid handles");
       return;
   }
 
   frame_map_[next_frame_id_] = frame;
 
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_frame_id_ = (next_frame_id_ + 1) & 0x3FFFFFFF;
@@ skipping 39 matching lines @@
 }
 
 void GpuVideoEncodeAcceleratorHost::OnWillDeleteImpl() {
   DCHECK(CalledOnValidThread());
   impl_ = nullptr;
 
   // The gpu::CommandBufferProxyImpl is going away; error out this VEA.
   OnChannelError();
 }
 
-void GpuVideoEncodeAcceleratorHost::EncodeGpuMemoryBufferFrame(
-    const scoped_refptr<VideoFrame>& frame,
-    bool force_keyframe) {
-  DCHECK_EQ(VideoFrame::NumPlanes(PIXEL_FORMAT_I420),
-            frame->gpu_memory_buffer_handles().size());
-  AcceleratedVideoEncoderMsg_Encode_Params2 params;
-  params.frame_id = next_frame_id_;
-  params.timestamp = frame->timestamp();
-  bool requires_sync_point = false;
-  for (const auto& handle : frame->gpu_memory_buffer_handles()) {
-    gfx::GpuMemoryBufferHandle new_handle =
-        channel_->ShareGpuMemoryBufferToGpuProcess(handle,
-                                                   &requires_sync_point);
-    if (new_handle.is_null()) {
-      PostNotifyError(FROM_HERE, kPlatformFailureError,
-                      "EncodeGpuMemoryBufferFrame(): failed to share gpu "
-                      "memory buffer handle for gpu process");
-      return;
-    }
-    params.gpu_memory_buffer_handles.push_back(new_handle);
-  }
-  params.size = frame->coded_size();
-  params.force_keyframe = force_keyframe;
-
-  Send(new AcceleratedVideoEncoderMsg_Encode2(encoder_route_id_, params));
-}
-
 void GpuVideoEncodeAcceleratorHost::EncodeSharedMemoryFrame(
     const scoped_refptr<VideoFrame>& frame,
     bool force_keyframe) {
   if (!base::SharedMemory::IsHandleValid(frame->shared_memory_handle())) {
     PostNotifyError(FROM_HERE, kPlatformFailureError,
                     "EncodeSharedMemory(): cannot encode frame with invalid "
                     "shared memory handle");
     return;
   }
 
@@ skipping 95 matching lines @@
   weak_this_factory_.InvalidateWeakPtrs();
 
   // Client::NotifyError() may Destroy() |this|, so calling it needs to be the
   // last thing done on this stack!
   VideoEncodeAccelerator::Client* client = nullptr;
   std::swap(client_, client);
   client->NotifyError(error);
 }
 
 }  // namespace media