Reland: GpuMemoryBuffer interface change: Map(**) to Map() and memory(plane); stride(plane)

content/browser/renderer_host/media/video_capture_buffer_pool.cc

 // Copyright (c) 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 "content/browser/renderer_host/media/video_capture_buffer_pool.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
@@ skipping 50 matching lines @@
 #if defined(OS_POSIX)
   const base::SharedMemoryHandle handle_;
 #endif
 };
 
 // A holder of a GpuMemoryBuffer-backed buffer. Holds weak references to
 // GpuMemoryBuffer-backed buffers and provides accessors to their data.
 class GpuMemoryBufferBufferHandle final
     : public VideoCaptureBufferPool::BufferHandle {
  public:
-  GpuMemoryBufferBufferHandle(std::vector<void*>* data,
+  GpuMemoryBufferBufferHandle(const std::vector<void*>& data,
                               const gfx::Size& dimensions,
                               ScopedVector<gfx::GpuMemoryBuffer>* gmbs)
       : data_(data), dimensions_(dimensions), gmbs_(gmbs) {
 #ifndef NDEBUG
-    DCHECK_EQ(data->size(), gmbs->size());
+    DCHECK_EQ(data.size(), gmbs->size());
     for (const auto& gmb : *gmbs)
       DCHECK(gmb);
-    for (const auto& data_ptr : *data)
+    for (const auto& data_ptr : data)
       DCHECK(data_ptr);
 #endif
   }
   ~GpuMemoryBufferBufferHandle() override {}
 
   gfx::Size dimensions() const override { return dimensions_; }
   size_t mapped_size() const override { return dimensions_.GetArea(); }
   void* data(int plane) override {
     DCHECK_GE(plane, media::VideoFrame::kYPlane);
-    DCHECK_LT(plane, static_cast<int>(data_->size()));
-    return data_->at(plane);
+    DCHECK_LT(plane, static_cast<int>(data_.size()));
+    return data_.at(plane);
   }
   ClientBuffer AsClientBuffer(int plane) override {
     DCHECK_GE(plane, media::VideoFrame::kYPlane);
     DCHECK_LT(plane, static_cast<int>(gmbs_->size()));
     return (*gmbs_)[plane]->AsClientBuffer();
   }
 #if defined(OS_POSIX)
   base::FileDescriptor AsPlatformFile() override {
     NOTREACHED();
     return base::FileDescriptor();
   }
 #endif
 
  private:
-  std::vector<void*>* data_;
+  const std::vector<void*> data_;
   const gfx::Size dimensions_;
   ScopedVector<gfx::GpuMemoryBuffer>* const gmbs_;
 };
 
 // Tracker specifics for SharedMemory.
 class VideoCaptureBufferPool::SharedMemTracker final : public Tracker {
  public:
   SharedMemTracker();
   bool Init(media::VideoPixelFormat format,
             media::VideoPixelStorage storage_type,
@@ skipping 24 matching lines @@
 // associated pixel dimensions.
 class VideoCaptureBufferPool::GpuMemoryBufferTracker final : public Tracker {
  public:
   GpuMemoryBufferTracker();
   bool Init(media::VideoPixelFormat format,
             media::VideoPixelStorage storage_type,
             const gfx::Size& dimensions) override;
   ~GpuMemoryBufferTracker() override;
 
   scoped_ptr<BufferHandle> GetBufferHandle() override {
+    std::vector<void*> data;
+    DCHECK_EQ(gpu_memory_buffers_.size(),
+              media::VideoFrame::NumPlanes(pixel_format()));
+    for (const auto& gmb : gpu_memory_buffers_)
+      data.push_back(gmb->memory(0));
     return make_scoped_ptr(new GpuMemoryBufferBufferHandle(
-        &data_, dimensions_, &gpu_memory_buffers_));
+        data, dimensions_, &gpu_memory_buffers_));
   }
   bool ShareToProcess(base::ProcessHandle process_handle,
                       base::SharedMemoryHandle* new_handle) override {
     NOTREACHED();
     return false;
   }
   bool ShareToProcess2(int plane,
                        base::ProcessHandle process_handle,
                        gfx::GpuMemoryBufferHandle* new_handle) override;
 
  private:
-  std::vector<void*> data_;
   gfx::Size dimensions_;
   // Owned references to GpuMemoryBuffers.
   ScopedVector<gfx::GpuMemoryBuffer> gpu_memory_buffers_;
 };
 
 VideoCaptureBufferPool::SharedMemTracker::SharedMemTracker() : Tracker() {}
 
 bool VideoCaptureBufferPool::SharedMemTracker::Init(
     media::VideoPixelFormat format,
     media::VideoPixelStorage storage_type,
@@ skipping 32 matching lines @@
   // point.
   DCHECK_EQ(format, media::PIXEL_FORMAT_I420);
   set_pixel_format(format);
   set_storage_type(storage_type);
   set_pixel_count(dimensions.GetArea());
   // |dimensions| can be 0x0 for trackers that do not require memory backing.
   if (dimensions.GetArea() == 0u)
     return true;
   dimensions_ = dimensions;
 
-  const media::VideoPixelFormat video_format = media::PIXEL_FORMAT_I420;
-  const size_t num_planes = media::VideoFrame::NumPlanes(video_format);
+  const size_t num_planes = media::VideoFrame::NumPlanes(pixel_format());
   for (size_t i = 0; i < num_planes; ++i) {
     const gfx::Size& size =
-        media::VideoFrame::PlaneSize(video_format, i, dimensions);
+        media::VideoFrame::PlaneSize(pixel_format(), i, dimensions);
     gpu_memory_buffers_.push_back(
         BrowserGpuMemoryBufferManager::current()->AllocateGpuMemoryBuffer(
             size,
             gfx::BufferFormat::R_8,
             gfx::BufferUsage::MAP));
 
     DLOG_IF(ERROR, !gpu_memory_buffers_[i]) << "Allocating GpuMemoryBuffer";
-    if (!gpu_memory_buffers_[i])
+    if (!gpu_memory_buffers_[i] || !gpu_memory_buffers_[i]->Map())
       return false;
-
-    void* temp_data = nullptr;
-    gpu_memory_buffers_[i]->Map(&temp_data);
-    DCHECK(temp_data);
-    data_.push_back(temp_data);
   }
   return true;
 }
 
 bool VideoCaptureBufferPool::GpuMemoryBufferTracker::ShareToProcess2(
     int plane,
     base::ProcessHandle process_handle,
     gfx::GpuMemoryBufferHandle* new_handle) {
   DCHECK_LE(plane, static_cast<int>(gpu_memory_buffers_.size()));
 
@@ skipping 215 matching lines @@
   return buffer_id;
 }
 
 VideoCaptureBufferPool::Tracker* VideoCaptureBufferPool::GetTracker(
     int buffer_id) {
   TrackerMap::const_iterator it = trackers_.find(buffer_id);
   return (it == trackers_.end()) ? NULL : it->second;
 }
 
 }  // namespace content