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

content/child/child_thread_impl_browsertest.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/discardable_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/time/time.h"
 #include "content/child/child_discardable_shared_memory_manager.h"
@@ skipping 140 matching lines @@
                        DISABLED_Map) {
   gfx::BufferFormat format = ::testing::get<1>(GetParam());
   gfx::Size buffer_size(4, 4);
 
   scoped_ptr<gfx::GpuMemoryBuffer> buffer =
       child_gpu_memory_buffer_manager()->AllocateGpuMemoryBuffer(
           buffer_size, format, gfx::BufferUsage::MAP);
   ASSERT_TRUE(buffer);
   EXPECT_EQ(format, buffer->GetFormat());
 
-  size_t num_planes = gfx::NumberOfPlanesForBufferFormat(format);
-
   // Map buffer planes.
-  scoped_ptr<void* []> planes(new void* [num_planes]);
-  bool rv = buffer->Map(planes.get());
-  ASSERT_TRUE(rv);
-
-  // Get strides.
-  scoped_ptr<int[]> strides(new int[num_planes]);
-  buffer->GetStride(strides.get());
+  ASSERT_TRUE(buffer->Map());
 
   // Write to buffer and check result.
+  size_t num_planes = gfx::NumberOfPlanesForBufferFormat(format);
   for (size_t plane = 0; plane < num_planes; ++plane) {
-    size_t row_size_in_bytes = 0;
-    EXPECT_TRUE(gfx::RowSizeForBufferFormatChecked(buffer_size.width(), format,
-                                                   plane, &row_size_in_bytes));
+    ASSERT_TRUE(buffer->memory(plane));
+    ASSERT_TRUE(buffer->stride(plane));
+    size_t row_size_in_bytes =
+        gfx::RowSizeForBufferFormat(buffer_size.width(), format, plane);
+    EXPECT_GT(row_size_in_bytes, 0u);
 
     scoped_ptr<char[]> data(new char[row_size_in_bytes]);
     memset(data.get(), 0x2a + plane, row_size_in_bytes);
     size_t height = buffer_size.height() /
                     gfx::SubsamplingFactorForBufferFormat(format, plane);
     for (size_t y = 0; y < height; ++y) {
       // Copy |data| to row |y| of |plane| and verify result.
-      memcpy(static_cast<char*>(planes[plane]) + y * strides[plane], data.get(),
-             row_size_in_bytes);
-      EXPECT_EQ(memcmp(static_cast<char*>(planes[plane]) + y * strides[plane],
-                       data.get(), row_size_in_bytes),
-                0);
+      memcpy(
+          static_cast<char*>(buffer->memory(plane)) + y * buffer->stride(plane),
+          data.get(), row_size_in_bytes);
+      EXPECT_EQ(0, memcmp(static_cast<char*>(buffer->memory(plane)) +
+                              y * buffer->stride(plane),
+                          data.get(), row_size_in_bytes));
     }
   }
 
   buffer->Unmap();
 }
 
 INSTANTIATE_TEST_CASE_P(
     ChildThreadImplGpuMemoryBufferBrowserTests,
     ChildThreadImplGpuMemoryBufferBrowserTest,
     ::testing::Combine(::testing::Values(kDisableNativeBuffers,
                                          kEnableNativeBuffers),
                        // These formats are guaranteed to work on all platforms.
                        ::testing::Values(gfx::BufferFormat::R_8,
                                          gfx::BufferFormat::RGBA_4444,
                                          gfx::BufferFormat::RGBA_8888,
                                          gfx::BufferFormat::BGRA_8888,
                                          gfx::BufferFormat::YUV_420)));
 
 }  // namespace
 }  // namespace content