Add PERSISTENT_MAP usage for GpuMemoryBuffers.

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 120 matching lines @@
                          data.get(), row_size_in_bytes),
                   0);
       }
     }
 
     buffer->Unmap();
     EXPECT_FALSE(buffer->IsMapped());
   }
 }
 
+TEST_P(GpuMemoryBufferImplTest, PersistentMap) {
+  const int kBufferId = 1;
+
+  gfx::Size buffer_size(2, 2);

[reveman, 2015/05/19 16:12:12]

Fyi, nothing new with this patch so I don't mind if you keep it consistent with
the code above but we should probably be using dimensions that are multiple of 4
here to ensure this will work with compressed formats.

[danakj, 2015/05/19 22:19:43]

Do you want me to change both tests to 4? I'll do that.

+
+  for (auto configuration : supported_configurations_) {
+    if (configuration.usage != gfx::GpuMemoryBuffer::PERSISTENT_MAP)
+      continue;
+
+    scoped_ptr<GpuMemoryBufferImpl> buffer(
+        GpuMemoryBufferImpl::CreateFromHandle(
+            CreateGpuMemoryBuffer(kBufferId, buffer_size, configuration.format,
+                                  configuration.usage),
+            buffer_size, configuration.format,
+            base::Bind(&GpuMemoryBufferImplTest::DestroyGpuMemoryBuffer,
+                       base::Unretained(this), kBufferId)));
+    ASSERT_TRUE(buffer);
+    EXPECT_FALSE(buffer->IsMapped());
+
+    size_t num_planes =
+        GpuMemoryBufferImpl::NumberOfPlanesForGpuMemoryBufferFormat(
+            configuration.format);
+
+    // Map buffer into user space.
+    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());
+
+    scoped_ptr<size_t[]> row_sizes_in_bytes(new size_t[num_planes]);
+    for (size_t plane = 0; plane < num_planes; ++plane) {
+      EXPECT_TRUE(GpuMemoryBufferImpl::RowSizeInBytes(
+          buffer_size.width(), configuration.format, plane,
+          &row_sizes_in_bytes[plane]));
+      EXPECT_GT(row_sizes_in_bytes[plane], 0u);
+    }
+
+    // Copy and compare mapped buffers.
+    for (size_t plane = 0; plane < num_planes; ++plane) {
+      size_t row_size_in_bytes = row_sizes_in_bytes[plane];
+
+      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]) +
+                             y * strides[plane],
+                         data.get(), row_size_in_bytes),
+                  0);
+      }
+    }
+
+    buffer->Unmap();
+    EXPECT_FALSE(buffer->IsMapped());
+
+    // Remap the buffer, and compare again. It should contain the same data.
+    rv = buffer->Map(mapped_buffers.get());
+    ASSERT_TRUE(rv);
+    EXPECT_TRUE(buffer->IsMapped());
+
+    scoped_ptr<int[]> remap_strides(new int[num_planes]);
+    buffer->GetStride(remap_strides.get());
+
+    for (size_t plane = 0; plane < num_planes; ++plane) {
+      EXPECT_EQ(strides[plane], remap_strides[plane]);

[reveman, 2015/05/19 16:12:12]

I don't think we should expect this to be true. An implementation could move the
storage and the stride might change.

[danakj, 2015/05/19 22:19:44]

OK, done.

+      size_t row_size_in_bytes = 0;
+      EXPECT_TRUE(GpuMemoryBufferImpl::RowSizeInBytes(
+          buffer_size.width(), configuration.format, plane,
+          &row_size_in_bytes));
+      EXPECT_EQ(row_sizes_in_bytes[plane], row_size_in_bytes);

[reveman, 2015/05/19 16:12:12]

Why are you checking this? row_size_in_bytes can't change as it's unrelated to
the buffer instance.

[danakj, 2015/05/19 22:19:43]

I see, right. Removed.

+
+      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) {
+        EXPECT_EQ(memcmp(static_cast<char*>(mapped_buffers[plane]) +
+                             y * strides[plane],
+                         data.get(), row_size_in_bytes),
+                  0);
+      }
+    }
+  }
+}
+
 std::vector<gfx::GpuMemoryBufferType> GetSupportedGpuMemoryBufferTypes() {
   std::vector<gfx::GpuMemoryBufferType> supported_types;
-  GpuMemoryBufferFactory::GetSupportedTypes(&supported_types);
+  GpuMemoryBufferFactory::GetSupportedTypes(gfx::GpuMemoryBuffer::MAP,
+                                            &supported_types);
+
+  std::vector<gfx::GpuMemoryBufferType> persistent_supported_types;
+  GpuMemoryBufferFactory::GetSupportedTypes(
+      gfx::GpuMemoryBuffer::PERSISTENT_MAP, &persistent_supported_types);
+  supported_types.insert(supported_types.end(),
+                         persistent_supported_types.begin(),
+                         persistent_supported_types.end());
+
   return supported_types;
 }
 
 INSTANTIATE_TEST_CASE_P(
     GpuMemoryBufferImplTests,
     GpuMemoryBufferImplTest,
     ::testing::ValuesIn(GetSupportedGpuMemoryBufferTypes()));
 
 }  // namespace
 }  // namespace content