content/common/gpu/client/gpu_memory_buffer_impl_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/common/gpu/client/gpu_memory_buffer_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "content/common/gpu/gpu_memory_buffer_factory.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 namespace content {
  12 namespace {
  13
  14 const int kClientId = 1;
  15
  16 class GpuMemoryBufferImplTest
  17     : public testing::TestWithParam<gfx::GpuMemoryBufferType> {
  18  public:
  19   GpuMemoryBufferImplTest() : buffer_count_(0), factory_(nullptr) {}
  20
  21   // Overridden from testing::Test:
  22   void SetUp() override {
  23     factory_ = GpuMemoryBufferFactory::Create(GetParam());
  24     factory_->GetSupportedGpuMemoryBufferConfigurations(
  25         &supported_configurations_);
  26   }
  27   void TearDown() override { factory_.reset(); }
  28
  29   gfx::GpuMemoryBufferHandle CreateGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
  30                                                    const gfx::Size& size,
  31                                                    gfx::BufferFormat format,
  32                                                    gfx::BufferUsage usage) {
  33     ++buffer_count_;
  34     return factory_->CreateGpuMemoryBuffer(id, size, format, usage, kClientId,
  35                                            gfx::kNullPluginWindow);
  36   }
  37
  38   void DestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id, uint32 sync_point) {
  39     factory_->DestroyGpuMemoryBuffer(id, kClientId);
  40     DCHECK_GT(buffer_count_, 0);
  41     --buffer_count_;
  42   }
  43
  44   std::vector<GpuMemoryBufferFactory::Configuration> supported_configurations_;
  45   int buffer_count_;
  46
  47  private:
  48   scoped_ptr<GpuMemoryBufferFactory> factory_;
  49 };
  50
  51 TEST_P(GpuMemoryBufferImplTest, CreateFromHandle) {
  52   const int kBufferId = 1;
  53
  54   gfx::Size buffer_size(8, 8);
  55
  56   for (auto configuration : supported_configurations_) {
  57     scoped_ptr<GpuMemoryBufferImpl> buffer(
  58         GpuMemoryBufferImpl::CreateFromHandle(
  59             CreateGpuMemoryBuffer(kBufferId, buffer_size, configuration.format,
  60                                   configuration.usage),
  61             buffer_size, configuration.format, configuration.usage,
  62             base::Bind(&GpuMemoryBufferImplTest::DestroyGpuMemoryBuffer,
  63                        base::Unretained(this), kBufferId)));
  64     EXPECT_EQ(1, buffer_count_);
  65     ASSERT_TRUE(buffer);
  66     EXPECT_EQ(buffer->GetFormat(), configuration.format);
  67
  68     // Check if destruction callback is executed when deleting the buffer.
  69     buffer.reset();
  70     EXPECT_EQ(0, buffer_count_);
  71   }
  72 }
  73
  74 TEST_P(GpuMemoryBufferImplTest, Map) {
  75   const int kBufferId = 1;
  76
  77   // Use a multiple of 4 for both dimensions to support compressed formats.
  78   gfx::Size buffer_size(4, 4);
  79
  80   for (auto configuration : supported_configurations_) {
  81     if (configuration.usage != gfx::BufferUsage::MAP)
  82       continue;
  83
  84     scoped_ptr<GpuMemoryBufferImpl> buffer(
  85         GpuMemoryBufferImpl::CreateFromHandle(
  86             CreateGpuMemoryBuffer(kBufferId, buffer_size, configuration.format,
  87                                   configuration.usage),
  88             buffer_size, configuration.format, configuration.usage,
  89             base::Bind(&GpuMemoryBufferImplTest::DestroyGpuMemoryBuffer,
  90                        base::Unretained(this), kBufferId)));
  91     ASSERT_TRUE(buffer);
  92     EXPECT_FALSE(buffer->IsMapped());
  93
  94     size_t num_planes =
  95         GpuMemoryBufferImpl::NumberOfPlanesForGpuMemoryBufferFormat(
  96             configuration.format);
  97
  98     // Map buffer into user space.
  99     scoped_ptr<void*[]> mapped_buffers(new void*[num_planes]);
 100     bool rv = buffer->Map(mapped_buffers.get());
 101     ASSERT_TRUE(rv);
 102     EXPECT_TRUE(buffer->IsMapped());
 103
 104     // Get strides.
 105     scoped_ptr<int[]> strides(new int[num_planes]);
 106     buffer->GetStride(strides.get());
 107
 108     // Copy and compare mapped buffers.
 109     for (size_t plane = 0; plane < num_planes; ++plane) {
 110       size_t row_size_in_bytes = 0;
 111       EXPECT_TRUE(GpuMemoryBufferImpl::RowSizeInBytes(
 112           buffer_size.width(), configuration.format, plane,
 113           &row_size_in_bytes));
 114       EXPECT_GT(row_size_in_bytes, 0u);
 115
 116       scoped_ptr<char[]> data(new char[row_size_in_bytes]);
 117       memset(data.get(), 0x2a + plane, row_size_in_bytes);
 118
 119       size_t height =
 120           buffer_size.height() /
 121           GpuMemoryBufferImpl::SubsamplingFactor(configuration.format, plane);
 122       for (size_t y = 0; y < height; ++y) {
 123         memcpy(static_cast<char*>(mapped_buffers[plane]) + y * strides[plane],
 124                data.get(), row_size_in_bytes);
 125         EXPECT_EQ(memcmp(static_cast<char*>(mapped_buffers[plane]) +
 126                              y * strides[plane],
 127                          data.get(), row_size_in_bytes),
 128                   0);
 129       }
 130     }
 131
 132     buffer->Unmap();
 133     EXPECT_FALSE(buffer->IsMapped());
 134   }
 135 }
 136
 137 TEST_P(GpuMemoryBufferImplTest, PersistentMap) {
 138   const int kBufferId = 1;
 139
 140   // Use a multiple of 4 for both dimensions to support compressed formats.
 141   gfx::Size buffer_size(4, 4);
 142
 143   for (auto configuration : supported_configurations_) {
 144     if (configuration.usage != gfx::BufferUsage::PERSISTENT_MAP)
 145       continue;
 146
 147     scoped_ptr<GpuMemoryBufferImpl> buffer(
 148         GpuMemoryBufferImpl::CreateFromHandle(
 149             CreateGpuMemoryBuffer(kBufferId, buffer_size, configuration.format,
 150                                   configuration.usage),
 151             buffer_size, configuration.format, configuration.usage,
 152             base::Bind(&GpuMemoryBufferImplTest::DestroyGpuMemoryBuffer,
 153                        base::Unretained(this), kBufferId)));
 154     ASSERT_TRUE(buffer);
 155     EXPECT_FALSE(buffer->IsMapped());
 156
 157     size_t num_planes =
 158         GpuMemoryBufferImpl::NumberOfPlanesForGpuMemoryBufferFormat(
 159             configuration.format);
 160
 161     // Map buffer into user space.
 162     scoped_ptr<void* []> mapped_buffers(new void* [num_planes]);
 163     bool rv = buffer->Map(mapped_buffers.get());
 164     ASSERT_TRUE(rv);
 165     EXPECT_TRUE(buffer->IsMapped());
 166
 167     // Get strides.
 168     scoped_ptr<int[]> strides(new int[num_planes]);
 169     buffer->GetStride(strides.get());
 170
 171     // Copy and compare mapped buffers.
 172     for (size_t plane = 0; plane < num_planes; ++plane) {
 173       size_t row_size_in_bytes;
 174       EXPECT_TRUE(GpuMemoryBufferImpl::RowSizeInBytes(
 175           buffer_size.width(), configuration.format, plane,
 176           &row_size_in_bytes));
 177
 178       scoped_ptr<char[]> data(new char[row_size_in_bytes]);
 179       memset(data.get(), 0x2a + plane, row_size_in_bytes);
 180
 181       size_t height =
 182           buffer_size.height() /
 183           GpuMemoryBufferImpl::SubsamplingFactor(configuration.format, plane);
 184       for (size_t y = 0; y < height; ++y) {
 185         memcpy(static_cast<char*>(mapped_buffers[plane]) + y * strides[plane],
 186                data.get(), row_size_in_bytes);
 187         EXPECT_EQ(memcmp(static_cast<char*>(mapped_buffers[plane]) +
 188                              y * strides[plane],
 189                          data.get(), row_size_in_bytes),
 190                   0);
 191       }
 192     }
 193
 194     buffer->Unmap();
 195     EXPECT_FALSE(buffer->IsMapped());
 196
 197     // Remap the buffer, and compare again. It should contain the same data.
 198     rv = buffer->Map(mapped_buffers.get());
 199     ASSERT_TRUE(rv);
 200     EXPECT_TRUE(buffer->IsMapped());
 201
 202     buffer->GetStride(strides.get());
 203
 204     for (size_t plane = 0; plane < num_planes; ++plane) {
 205       size_t row_size_in_bytes;
 206       EXPECT_TRUE(GpuMemoryBufferImpl::RowSizeInBytes(
 207           buffer_size.width(), configuration.format, plane,
 208           &row_size_in_bytes));
 209
 210       scoped_ptr<char[]> data(new char[row_size_in_bytes]);
 211       memset(data.get(), 0x2a + plane, row_size_in_bytes);
 212
 213       size_t height =
 214           buffer_size.height() /
 215           GpuMemoryBufferImpl::SubsamplingFactor(configuration.format, plane);
 216       for (size_t y = 0; y < height; ++y) {
 217         EXPECT_EQ(memcmp(static_cast<char*>(mapped_buffers[plane]) +
 218                              y * strides[plane],
 219                          data.get(), row_size_in_bytes),
 220                   0);
 221       }
 222     }
 223
 224     buffer->Unmap();
 225     EXPECT_FALSE(buffer->IsMapped());
 226   }
 227 }
 228
 229 std::vector<gfx::GpuMemoryBufferType> GetSupportedGpuMemoryBufferTypes() {
 230   std::vector<gfx::GpuMemoryBufferType> supported_types;
 231   GpuMemoryBufferFactory::GetSupportedTypes(&supported_types);
 232   return supported_types;
 233 }
 234
 235 INSTANTIATE_TEST_CASE_P(
 236     GpuMemoryBufferImplTests,
 237     GpuMemoryBufferImplTest,
 238     ::testing::ValuesIn(GetSupportedGpuMemoryBufferTypes()));
 239
 240 }  // namespace
 241 }  // namespace content