Cleanup of passing GpuMemoryBuffer backed video frames

media/base/video_frame.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 "media/base/video_frame.h"
 
 #include <algorithm>
 #include <climits>
 
 #include "base/atomic_sequence_num.h"
@@ skipping 39 matching lines @@
     case VideoFrame::STORAGE_UNOWNED_MEMORY:
       return "UNOWNED_MEMORY";
     case VideoFrame::STORAGE_OWNED_MEMORY:
       return "OWNED_MEMORY";
     case VideoFrame::STORAGE_SHMEM:
       return "SHMEM";
 #if defined(OS_LINUX)
     case VideoFrame::STORAGE_DMABUFS:
       return "DMABUFS";
 #endif
-    case VideoFrame::STORAGE_GPU_MEMORY_BUFFERS:
-      return "GPU_MEMORY_BUFFERS";
     case VideoFrame::STORAGE_MOJO_SHARED_BUFFER:
       return "MOJO_SHARED_BUFFER";
   }
 
   NOTREACHED() << "Invalid StorageType provided: " << storage_type;
   return "INVALID";
 }
 
 // Returns true if |frame| is accesible mapped in the VideoFrame memory space.
 // static
 static bool IsStorageTypeMappable(VideoFrame::StorageType storage_type) {
   return
 #if defined(OS_LINUX)
       // This is not strictly needed but makes explicit that, at VideoFrame
       // level, DmaBufs are not mappable from userspace.
       storage_type != VideoFrame::STORAGE_DMABUFS &&
 #endif
       (storage_type == VideoFrame::STORAGE_UNOWNED_MEMORY ||
        storage_type == VideoFrame::STORAGE_OWNED_MEMORY ||
        storage_type == VideoFrame::STORAGE_SHMEM ||
-       storage_type == VideoFrame::STORAGE_GPU_MEMORY_BUFFERS ||
        storage_type == VideoFrame::STORAGE_MOJO_SHARED_BUFFER);
 }
 
 // Checks if |source_format| can be wrapped into a |target_format| frame.
 static bool AreValidPixelFormatsForWrap(VideoPixelFormat source_format,
                                         VideoPixelFormat target_format) {
   if (source_format == target_format)
     return true;
 
   // It is possible to add other planar to planar format conversions here if the
@@ skipping 146 matching lines @@
   frame->strides_[kYPlane] = y_stride;
   frame->strides_[kUPlane] = u_stride;
   frame->strides_[kVPlane] = v_stride;
   frame->data_[kYPlane] = y_data;
   frame->data_[kUPlane] = u_data;
   frame->data_[kVPlane] = v_data;
   return frame;
 }
 
 // static
-scoped_refptr<VideoFrame> VideoFrame::WrapExternalYuvGpuMemoryBuffers(
-    VideoPixelFormat format,
-    const gfx::Size& coded_size,
-    const gfx::Rect& visible_rect,
-    const gfx::Size& natural_size,
-    int32_t y_stride,
-    int32_t u_stride,
-    int32_t v_stride,
-    uint8_t* y_data,
-    uint8_t* u_data,
-    uint8_t* v_data,
-    const gfx::GpuMemoryBufferHandle& y_handle,
-    const gfx::GpuMemoryBufferHandle& u_handle,
-    const gfx::GpuMemoryBufferHandle& v_handle,
-    base::TimeDelta timestamp) {
-  const StorageType storage = STORAGE_GPU_MEMORY_BUFFERS;
-  if (!IsValidConfig(format, storage, coded_size, visible_rect, natural_size)) {
-    LOG(DFATAL) << __func__ << " Invalid config."
-                << ConfigToString(format, storage, coded_size, visible_rect,
-                                  natural_size);
-    return nullptr;
-  }
-
-  scoped_refptr<VideoFrame> frame(new VideoFrame(
-      format, storage, coded_size, visible_rect, natural_size, timestamp));
-  frame->strides_[kYPlane] = y_stride;
-  frame->strides_[kUPlane] = u_stride;
-  frame->strides_[kVPlane] = v_stride;
-  frame->data_[kYPlane] = y_data;
-  frame->data_[kUPlane] = u_data;
-  frame->data_[kVPlane] = v_data;
-  frame->gpu_memory_buffer_handles_.push_back(y_handle);
-  frame->gpu_memory_buffer_handles_.push_back(u_handle);
-  frame->gpu_memory_buffer_handles_.push_back(v_handle);
-  return frame;
-}
-
-// static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalYuvaData(
     VideoPixelFormat format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     int32_t y_stride,
     int32_t u_stride,
     int32_t v_stride,
     int32_t a_stride,
     uint8_t* y_data,
@@ skipping 418 matching lines @@
   DCHECK(shared_memory_handle_ != base::SharedMemory::NULLHandle());
   return shared_memory_handle_;
 }
 
 size_t VideoFrame::shared_memory_offset() const {
   DCHECK_EQ(storage_type_, STORAGE_SHMEM);
   DCHECK(shared_memory_handle_ != base::SharedMemory::NULLHandle());
   return shared_memory_offset_;
 }
 
-const std::vector<gfx::GpuMemoryBufferHandle>&
-VideoFrame::gpu_memory_buffer_handles() const {
-  DCHECK_EQ(storage_type_, STORAGE_GPU_MEMORY_BUFFERS);
-  DCHECK(!gpu_memory_buffer_handles_.empty());
-  return gpu_memory_buffer_handles_;
-}
-
 #if defined(OS_LINUX)
 int VideoFrame::dmabuf_fd(size_t plane) const {
   DCHECK_EQ(storage_type_, STORAGE_DMABUFS);
   DCHECK(IsValidPlane(plane, format_));
   return dmabuf_fds_[plane].get();
 }
 
 bool VideoFrame::DuplicateFileDescriptors(const std::vector<int>& in_fds) {
   // TODO(mcasas): Support offsets for e.g. multiplanar inside a single |in_fd|.
 
@@ skipping 401 matching lines @@
   if (zero_initialize_memory)
     memset(data, 0, data_size);
 
   for (size_t plane = 0; plane < NumPlanes(format_); ++plane)
     data_[plane] = data + offset[plane];
 
   AddDestructionObserver(base::Bind(&base::AlignedFree, data));
 }
 
 }  // namespace media