VideoCaptureBufferPool: remove unnecessary |data_| pointers after GpuMemoryBuffer API change

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 46 matching lines @@
 #if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
   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(const std::vector<void*>& data,
-                              const gfx::Size& dimensions,
+  GpuMemoryBufferBufferHandle(const gfx::Size& dimensions,
                               ScopedVector<gfx::GpuMemoryBuffer>* gmbs)
-      : data_(data), dimensions_(dimensions), gmbs_(gmbs) {
-#ifndef NDEBUG
-    DCHECK_EQ(data.size(), gmbs->size());
-    for (const auto& gmb : *gmbs)
-      DCHECK(gmb);
-    for (const auto& data_ptr : data)
-      DCHECK(data_ptr);
-#endif
+      : dimensions_(dimensions), gmbs_(gmbs) {
+    DCHECK(gmbs);
   }
   ~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_GE(plane, 0);
+    DCHECK_LT(plane, static_cast<int>(gmbs_->size()));
+    DCHECK((*gmbs_)[plane]);
+    return (*gmbs_)[plane]->memory(0);
   }
   ClientBuffer AsClientBuffer(int plane) override {
-    DCHECK_GE(plane, media::VideoFrame::kYPlane);
+    DCHECK_GE(plane, 0);
     DCHECK_LT(plane, static_cast<int>(gmbs_->size()));
     return (*gmbs_)[plane]->AsClientBuffer();
   }
 #if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
   base::FileDescriptor AsPlatformFile() override {
     NOTREACHED();
     return base::FileDescriptor();
   }
 #endif
 
  private:
-  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 26 matching lines @@
 class VideoCaptureBufferPool::GpuMemoryBufferTracker final : public Tracker {
  public:
   GpuMemoryBufferTracker();
   bool Init(media::VideoPixelFormat format,
             media::VideoPixelStorage storage_type,
             const gfx::Size& dimensions,
             base::Lock* lock) 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_));
+    return make_scoped_ptr(
+        new GpuMemoryBufferBufferHandle(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;
 
@@ skipping 300 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