content: Add GpuMemoryBuffer MemoryDumpProvider implementation.

content/common/gpu/client/gpu_memory_buffer_impl_unittest.cc

 // Copyright 2014 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/common/gpu/client/gpu_memory_buffer_impl.h"
 
 #include "base/bind.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 92 matching lines @@
     scoped_ptr<void*[]> mapped_buffers(new void*[num_planes]);
     bool rv = buffer->Map(mapped_buffers.get());
     ASSERT_TRUE(rv);
     EXPECT_TRUE(buffer->IsMapped());
 
     // Get strides.
     scoped_ptr<int[]> strides(new int[num_planes]);
     buffer->GetStride(strides.get());
 
     // Copy and compare mapped buffers.
-    for (size_t i = 0; i < num_planes; ++i) {
-      size_t width_in_bytes = 0u;
-      EXPECT_TRUE(GpuMemoryBufferImpl::StrideInBytes(
-          buffer_size.width(), configuration.format, i, &width_in_bytes));
-      EXPECT_GT(width_in_bytes, 0u);
+    for (size_t plane = 0; plane < num_planes; ++plane) {
+      size_t row_size_in_bytes = 0;
+      EXPECT_TRUE(GpuMemoryBufferImpl::RowSizeInBytes(
+          buffer_size.width(), configuration.format, plane,
+          &row_size_in_bytes));
+      EXPECT_GT(row_size_in_bytes, 0u);
 
-      scoped_ptr<char[]> data(new char[width_in_bytes]);
-      memset(data.get(), 0x2a + i, width_in_bytes);
-      memcpy(mapped_buffers[i], data.get(), width_in_bytes);
-      EXPECT_EQ(memcmp(mapped_buffers[i], data.get(), width_in_bytes), 0);
+      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() /
+          GpuMemoryBufferImpl::SubsamplingFactor(configuration.format, plane);
+      for (size_t y = 0; y < height; ++y) {
+        memcpy(static_cast<char*>(mapped_buffers[plane]) + y * strides[plane],
+               data.get(), row_size_in_bytes);
+        EXPECT_EQ(memcmp(static_cast<char*>(mapped_buffers[plane]) +

[Daniele Castagna, 2015/04/27 19:07:47]

Not sure what you're testing here, just that copying data into the buffer
actually works?
It seems that memcpy is being tested here. :/

[reveman, 2015/04/27 19:30:30]

We're testing the storage and the memory mapping, just like before, but now
we're actually making sure that we can copy and read-back data for the full
buffer and not just the first row. This is a relatively useful test. Whether
we're using memcpy or some other method to write the data is not really
relevant.

It seemed like a good idea to improve this test while I was touching this code
but I can leave it for a follow up if you prefer?

[Daniele Castagna, 2015/04/27 19:43:56]

Just looking at the code, and seeing
memcpy(target, pointer, size);
EXPECT_EQ(memcmp(target, pointer, size));

It's not really clear to me what could go wrong to make that test fail, and that
makes hard to understand what the test is about.

Maybe unmap and remap before the memcmp?

No need to change it here in this CL.

[reveman, 2015/04/27 20:28:08]

It could crash and it could fail if there's something wrong with how this memory
was mapped. e.g. the implementation didn't allocate enough memory for the
buffer.

I'll add comment to make this more clear.
Maybe. I'd prefer a separate test for that as I'm not sure we can require all
implementations work this way. A buffer queue implementation like SurfaceTexture
might return a new buffer on the second map.
 
Ok, cool but please don't hold back any suggestions if you feel like the current
code is less than ideal. 

+                             y * strides[plane],
+                         data.get(), row_size_in_bytes),
+                  0);
+      }
     }
 
     buffer->Unmap();
     EXPECT_FALSE(buffer->IsMapped());
   }
 }
 
 std::vector<gfx::GpuMemoryBufferType> GetSupportedGpuMemoryBufferTypes() {
   std::vector<gfx::GpuMemoryBufferType> supported_types;
   GpuMemoryBufferFactory::GetSupportedTypes(&supported_types);
   return supported_types;
 }
 
 INSTANTIATE_TEST_CASE_P(
     GpuMemoryBufferImplTests,
     GpuMemoryBufferImplTest,
     ::testing::ValuesIn(GetSupportedGpuMemoryBufferTypes()));
 
 }  // namespace
 }  // namespace content