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

media/video/gpu_memory_buffer_video_frame_pool.cc

 // Copyright 2015 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/video/gpu_memory_buffer_video_frame_pool.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
 #include <algorithm>
@@ skipping 418 matching lines @@
   const size_t planes_per_copy = PlanesPerCopy(output_format_);
   const gfx::Size size = video_frame->visible_rect().size();
   size_t copies = 0;
   for (size_t i = 0; i < num_planes; i += planes_per_copy) {
     const int rows = VideoFrame::Rows(i, output_format_, size.height());
     const int rows_per_copy = RowsPerCopy(i, output_format_, size.width());
     copies += rows / rows_per_copy;
     if (rows % rows_per_copy)
       ++copies;
   }
-  base::Closure copies_done =
+  const base::Closure copies_done =
       base::Bind(&PoolImpl::OnCopiesDone, this, video_frame, frame_resources,
                  frame_ready_cb);
-  base::Closure barrier = base::BarrierClosure(copies, copies_done);
+  const base::Closure barrier = base::BarrierClosure(copies, copies_done);
 
   // Post all the async tasks.
   for (size_t i = 0; i < num_planes; i += planes_per_copy) {
     gfx::GpuMemoryBuffer* buffer =
         frame_resources->plane_resources[i].gpu_memory_buffer.get();
-    uint8* dest_buffers[VideoFrame::kMaxPlanes] = {0};
-    int dest_strides[VideoFrame::kMaxPlanes] = {0};
-    if (buffer) {
-      DCHECK_EQ(planes_per_copy,
-                gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat()));
-      bool rv = buffer->Map(reinterpret_cast<void**>(dest_buffers));
-      DCHECK(rv);
-      buffer->GetStride(dest_strides);
+
+    if (!buffer || !buffer->Map()) {
+      DLOG(ERROR) << "Could not get or Map() buffer";
+      return;
     }
+    DCHECK_EQ(planes_per_copy,
+              gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat()));
 
     const int rows = VideoFrame::Rows(i, output_format_, size.height());
     const int rows_per_copy = RowsPerCopy(i, output_format_, size.width());
 
     for (int row = 0; row < rows; row += rows_per_copy) {
       const int rows_to_copy = std::min(rows_per_copy, rows - row);
       switch (output_format_) {
         case PIXEL_FORMAT_I420: {
           const int bytes_per_row =
               VideoFrame::RowBytes(i, output_format_, size.width());
           worker_task_runner_->PostTask(
               FROM_HERE, base::Bind(&CopyRowsToI420Buffer, row, rows_to_copy,
                                     bytes_per_row, video_frame->visible_data(i),
-                                    video_frame->stride(i), dest_buffers[0],
-                                    dest_strides[0], barrier));
+                                    video_frame->stride(i),
+                                    static_cast<uint8_t*>(buffer->memory(0)),
+                                    buffer->stride(0), barrier));
           break;
         }
         case PIXEL_FORMAT_NV12:
           worker_task_runner_->PostTask(
               FROM_HERE,
-              base::Bind(&CopyRowsToNV12Buffer, row, rows_to_copy,
-                         size.width(), video_frame, dest_buffers[0],
-                         dest_strides[0], dest_buffers[1], dest_strides[1],
-                         barrier));
+              base::Bind(&CopyRowsToNV12Buffer, row, rows_to_copy, size.width(),
+                         video_frame, static_cast<uint8_t*>(buffer->memory(0)),
+                         buffer->stride(0),
+                         static_cast<uint8_t*>(buffer->memory(1)),
+                         buffer->stride(1), barrier));
           break;
         case PIXEL_FORMAT_UYVY:
           worker_task_runner_->PostTask(
               FROM_HERE,
               base::Bind(&CopyRowsToUYVYBuffer, row, rows_to_copy, size.width(),
-                         video_frame, dest_buffers[0], dest_strides[0],
-                         barrier));
+                         video_frame, static_cast<uint8_t*>(buffer->memory(0)),
+                         buffer->stride(0), barrier));
           break;
         default:
           NOTREACHED();
       }
     }
   }
 }
 
 void GpuMemoryBufferVideoFramePool::PoolImpl::
     BindAndCreateMailboxesHardwareFrameResources(
@@ skipping 204 matching lines @@
 }
 
 void GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
   DCHECK(video_frame);
   pool_impl_->CreateHardwareFrame(video_frame, frame_ready_cb);
 }
 
 }  // namespace media