gpu/command_buffer/service/gles2_cmd_decoder_unittest_buffers.cc

   1 // Copyright 2015 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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
   6 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
   7
   8 using ::gfx::MockGLInterface;
   9 using ::testing::_;
  10 using ::testing::Return;
  11 using ::testing::SetArgPointee;
  12
  13 namespace gpu {
  14 namespace gles2 {
  15
  16 using namespace cmds;
  17
  18 namespace {
  19
  20 }  // namespace anonymous
  21
  22 TEST_P(GLES2DecoderTest, MapBufferRangeUnmapBufferReadSucceeds) {
  23   const GLenum kTarget = GL_ARRAY_BUFFER;
  24   const GLintptr kOffset = 10;
  25   const GLsizeiptr kSize = 64;
  26   const GLbitfield kAccess = GL_MAP_READ_BIT;
  27
  28   uint32_t result_shm_id = kSharedMemoryId;
  29   uint32_t result_shm_offset = kSharedMemoryOffset;
  30   uint32_t data_shm_id = kSharedMemoryId;
  31   // uint32_t is Result for both MapBufferRange and UnmapBuffer commands.
  32   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(uint32_t);
  33
  34   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
  35
  36   std::vector<int8_t> data(kSize);
  37   for (GLsizeiptr ii = 0; ii < kSize; ++ii) {
  38     data[ii] = static_cast<int8_t>(ii % 255);
  39   }
  40
  41   {  // MapBufferRange
  42     EXPECT_CALL(*gl_,
  43                 MapBufferRange(kTarget, kOffset, kSize, kAccess))
  44         .WillOnce(Return(&data[0]))
  45         .RetiresOnSaturation();
  46
  47     typedef MapBufferRange::Result Result;
  48     Result* result = GetSharedMemoryAs<Result*>();
  49
  50     MapBufferRange cmd;
  51     cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
  52              result_shm_id, result_shm_offset);
  53     decoder_->set_unsafe_es3_apis_enabled(false);
  54     *result = 0;
  55     EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
  56     EXPECT_EQ(0u, *result);
  57     decoder_->set_unsafe_es3_apis_enabled(true);
  58     *result = 0;
  59     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  60     int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
  61     EXPECT_EQ(0, memcmp(&data[0], mem, kSize));
  62     EXPECT_EQ(1u, *result);
  63   }
  64
  65   {  // UnmapBuffer
  66     EXPECT_CALL(*gl_, UnmapBuffer(kTarget))
  67         .WillOnce(Return(GL_TRUE))
  68         .RetiresOnSaturation();
  69
  70     UnmapBuffer cmd;
  71     cmd.Init(kTarget);
  72     decoder_->set_unsafe_es3_apis_enabled(false);
  73     EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
  74     decoder_->set_unsafe_es3_apis_enabled(true);
  75     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  76   }
  77
  78   EXPECT_EQ(GL_NO_ERROR, GetGLError());
  79 }
  80
  81 TEST_P(GLES2DecoderTest, MapBufferRangeUnmapBufferWriteSucceeds) {
  82   const GLenum kTarget = GL_ARRAY_BUFFER;
  83   const GLintptr kOffset = 10;
  84   const GLsizeiptr kSize = 64;
  85   const GLbitfield kAccess = GL_MAP_WRITE_BIT;
  86   const GLbitfield kMappedAccess = GL_MAP_WRITE_BIT | GL_MAP_READ_BIT;
  87
  88   uint32_t result_shm_id = kSharedMemoryId;
  89   uint32_t result_shm_offset = kSharedMemoryOffset;
  90   uint32_t data_shm_id = kSharedMemoryId;
  91   // uint32_t is Result for both MapBufferRange and UnmapBuffer commands.
  92   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(uint32_t);
  93
  94   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
  95
  96   std::vector<int8_t> data(kSize);
  97   for (GLsizeiptr ii = 0; ii < kSize; ++ii) {
  98     data[ii] = static_cast<int8_t>(ii % 255);
  99   }
 100
 101   {  // MapBufferRange succeeds
 102     EXPECT_CALL(*gl_,
 103                 MapBufferRange(kTarget, kOffset, kSize, kMappedAccess))
 104         .WillOnce(Return(&data[0]))
 105         .RetiresOnSaturation();
 106
 107     typedef MapBufferRange::Result Result;
 108     Result* result = GetSharedMemoryAs<Result*>();
 109
 110     MapBufferRange cmd;
 111     cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
 112              result_shm_id, result_shm_offset);
 113     decoder_->set_unsafe_es3_apis_enabled(false);
 114     *result = 0;
 115     EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 116     EXPECT_EQ(0u, *result);
 117     decoder_->set_unsafe_es3_apis_enabled(true);
 118     *result = 0;
 119     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 120     int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
 121     EXPECT_EQ(0, memcmp(&data[0], mem, kSize));
 122     EXPECT_EQ(1u, *result);
 123   }
 124
 125   { // UnmapBuffer succeeds
 126     EXPECT_CALL(*gl_, UnmapBuffer(kTarget))
 127         .WillOnce(Return(GL_TRUE))
 128         .RetiresOnSaturation();
 129
 130     UnmapBuffer cmd;
 131     cmd.Init(kTarget);
 132     decoder_->set_unsafe_es3_apis_enabled(false);
 133     EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 134     decoder_->set_unsafe_es3_apis_enabled(true);
 135     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 136   }
 137
 138   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 139 }
 140
 141 TEST_P(GLES2DecoderTest, MapBufferRangeNotInitFails) {
 142   const GLenum kTarget = GL_ARRAY_BUFFER;
 143   const GLintptr kOffset = 10;
 144   const GLsizeiptr kSize = 64;
 145   const GLbitfield kAccess = GL_MAP_READ_BIT;
 146   std::vector<int8_t> data(kSize);
 147
 148   typedef MapBufferRange::Result Result;
 149   Result* result = GetSharedMemoryAs<Result*>();
 150   *result = 1;  // Any value other than 0.
 151   uint32_t result_shm_id = kSharedMemoryId;
 152   uint32_t result_shm_offset = kSharedMemoryOffset;
 153   uint32_t data_shm_id = kSharedMemoryId;
 154   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 155
 156   MapBufferRange cmd;
 157   cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
 158            result_shm_id, result_shm_offset);
 159   decoder_->set_unsafe_es3_apis_enabled(true);
 160   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 161 }
 162
 163 TEST_P(GLES2DecoderTest, MapBufferRangeWriteInvalidateRangeSucceeds) {
 164   const GLenum kTarget = GL_ARRAY_BUFFER;
 165   const GLintptr kOffset = 10;
 166   const GLsizeiptr kSize = 64;
 167   // With MAP_INVALIDATE_RANGE_BIT, no need to append MAP_READ_BIT.
 168   const GLbitfield kAccess = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT;
 169
 170   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
 171
 172   std::vector<int8_t> data(kSize);
 173   for (GLsizeiptr ii = 0; ii < kSize; ++ii) {
 174     data[ii] = static_cast<int8_t>(ii % 255);
 175   }
 176   EXPECT_CALL(*gl_,
 177               MapBufferRange(kTarget, kOffset, kSize, kAccess))
 178       .WillOnce(Return(&data[0]))
 179       .RetiresOnSaturation();
 180
 181   typedef MapBufferRange::Result Result;
 182   Result* result = GetSharedMemoryAs<Result*>();
 183   *result = 0;
 184   uint32_t result_shm_id = kSharedMemoryId;
 185   uint32_t result_shm_offset = kSharedMemoryOffset;
 186   uint32_t data_shm_id = kSharedMemoryId;
 187   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 188
 189   int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
 190   memset(mem, 72, kSize);  // Init to a random value other than 0.
 191
 192   MapBufferRange cmd;
 193   cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
 194            result_shm_id, result_shm_offset);
 195   decoder_->set_unsafe_es3_apis_enabled(true);
 196   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 197 }
 198
 199 TEST_P(GLES2DecoderTest, MapBufferRangeWriteInvalidateBufferSucceeds) {
 200   // Test INVALIDATE_BUFFER_BIT is mapped to INVALIDATE_RANGE_BIT.
 201   const GLenum kTarget = GL_ARRAY_BUFFER;
 202   const GLintptr kOffset = 10;
 203   const GLsizeiptr kSize = 64;
 204   const GLbitfield kAccess = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT;
 205   // With MAP_INVALIDATE_BUFFER_BIT, no need to append MAP_READ_BIT.
 206   const GLbitfield kFilteredAccess =
 207       GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT;
 208
 209   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
 210
 211   std::vector<int8_t> data(kSize);
 212   for (GLsizeiptr ii = 0; ii < kSize; ++ii) {
 213     data[ii] = static_cast<int8_t>(ii % 255);
 214   }
 215   EXPECT_CALL(*gl_,
 216               MapBufferRange(kTarget, kOffset, kSize, kFilteredAccess))
 217       .WillOnce(Return(&data[0]))
 218       .RetiresOnSaturation();
 219
 220   typedef MapBufferRange::Result Result;
 221   Result* result = GetSharedMemoryAs<Result*>();
 222   *result = 0;
 223   uint32_t result_shm_id = kSharedMemoryId;
 224   uint32_t result_shm_offset = kSharedMemoryOffset;
 225   uint32_t data_shm_id = kSharedMemoryId;
 226   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 227
 228   int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
 229   memset(mem, 72, kSize);  // Init to a random value other than 0.
 230
 231   MapBufferRange cmd;
 232   cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
 233            result_shm_id, result_shm_offset);
 234   decoder_->set_unsafe_es3_apis_enabled(true);
 235   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 236 }
 237
 238 TEST_P(GLES2DecoderTest, MapBufferRangeWriteUnsynchronizedBit) {
 239   // Test UNSYNCHRONIZED_BIT is filtered out.
 240   const GLenum kTarget = GL_ARRAY_BUFFER;
 241   const GLintptr kOffset = 10;
 242   const GLsizeiptr kSize = 64;
 243   const GLbitfield kAccess = GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT;
 244   const GLbitfield kFilteredAccess = GL_MAP_WRITE_BIT | GL_MAP_READ_BIT;
 245
 246   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
 247
 248   std::vector<int8_t> data(kSize);
 249   for (GLsizeiptr ii = 0; ii < kSize; ++ii) {
 250     data[ii] = static_cast<int8_t>(ii % 255);
 251   }
 252   EXPECT_CALL(*gl_,
 253               MapBufferRange(kTarget, kOffset, kSize, kFilteredAccess))
 254       .WillOnce(Return(&data[0]))
 255       .RetiresOnSaturation();
 256
 257   typedef MapBufferRange::Result Result;
 258   Result* result = GetSharedMemoryAs<Result*>();
 259   *result = 0;
 260   uint32_t result_shm_id = kSharedMemoryId;
 261   uint32_t result_shm_offset = kSharedMemoryOffset;
 262   uint32_t data_shm_id = kSharedMemoryId;
 263   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 264
 265   int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
 266   memset(mem, 72, kSize);  // Init to a random value other than 0.
 267
 268   MapBufferRange cmd;
 269   cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
 270            result_shm_id, result_shm_offset);
 271   decoder_->set_unsafe_es3_apis_enabled(true);
 272   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 273   EXPECT_EQ(0, memcmp(&data[0], mem, kSize));
 274 }
 275
 276 TEST_P(GLES2DecoderTest, MapBufferRangeWithError) {
 277   const GLenum kTarget = GL_ARRAY_BUFFER;
 278   const GLintptr kOffset = 10;
 279   const GLsizeiptr kSize = 64;
 280   const GLbitfield kAccess = GL_MAP_READ_BIT;
 281   std::vector<int8_t> data(kSize);
 282   for (GLsizeiptr ii = 0; ii < kSize; ++ii) {
 283     data[ii] = static_cast<int8_t>(ii % 255);
 284   }
 285   EXPECT_CALL(*gl_,
 286               MapBufferRange(kTarget, kOffset, kSize, kAccess))
 287       .WillOnce(Return(nullptr))  // Return nullptr to indicate a GL error.
 288       .RetiresOnSaturation();
 289
 290   typedef MapBufferRange::Result Result;
 291   Result* result = GetSharedMemoryAs<Result*>();
 292   *result = 0;
 293   uint32_t result_shm_id = kSharedMemoryId;
 294   uint32_t result_shm_offset = kSharedMemoryOffset;
 295   uint32_t data_shm_id = kSharedMemoryId;
 296   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 297
 298   int8_t* mem = reinterpret_cast<int8_t*>(&result[1]);
 299   memset(mem, 72, kSize);  // Init to a random value other than 0.
 300
 301   MapBufferRange cmd;
 302   cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
 303            result_shm_id, result_shm_offset);
 304   decoder_->set_unsafe_es3_apis_enabled(true);
 305   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 306   memset(&data[0], 72, kSize);
 307   // Mem is untouched.
 308   EXPECT_EQ(0, memcmp(&data[0], mem, kSize));
 309   EXPECT_EQ(0u, *result);
 310 }
 311
 312 TEST_P(GLES2DecoderTest, MapBufferRangeBadSharedMemoryFails) {
 313   const GLenum kTarget = GL_ARRAY_BUFFER;
 314   const GLintptr kOffset = 10;
 315   const GLsizeiptr kSize = 64;
 316   const GLbitfield kAccess = GL_MAP_READ_BIT;
 317   std::vector<int8_t> data(kSize);
 318   for (GLsizeiptr ii = 0; ii < kSize; ++ii) {
 319     data[ii] = static_cast<int8_t>(ii % 255);
 320   }
 321
 322   typedef MapBufferRange::Result Result;
 323   Result* result = GetSharedMemoryAs<Result*>();
 324   *result = 0;
 325   uint32_t result_shm_id = kSharedMemoryId;
 326   uint32_t result_shm_offset = kSharedMemoryOffset;
 327   uint32_t data_shm_id = kSharedMemoryId;
 328   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(*result);
 329
 330   decoder_->set_unsafe_es3_apis_enabled(true);
 331   MapBufferRange cmd;
 332   cmd.Init(kTarget, kOffset, kSize, kAccess,
 333            kInvalidSharedMemoryId, data_shm_offset,
 334            result_shm_id, result_shm_offset);
 335   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 336   cmd.Init(kTarget, kOffset, kSize, kAccess,
 337            data_shm_id, data_shm_offset,
 338            kInvalidSharedMemoryId, result_shm_offset);
 339   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 340   cmd.Init(kTarget, kOffset, kSize, kAccess,
 341            data_shm_id, kInvalidSharedMemoryOffset,
 342            result_shm_id, result_shm_offset);
 343   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 344   cmd.Init(kTarget, kOffset, kSize, kAccess,
 345            data_shm_id, data_shm_offset,
 346            result_shm_id, kInvalidSharedMemoryOffset);
 347   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 348 }
 349
 350 TEST_P(GLES2DecoderTest, UnmapBufferWriteNotMappedFails) {
 351   const GLenum kTarget = GL_ARRAY_BUFFER;
 352
 353   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
 354
 355   UnmapBuffer cmd;
 356   cmd.Init(kTarget);
 357   decoder_->set_unsafe_es3_apis_enabled(true);
 358   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 359   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 360 }
 361
 362 TEST_P(GLES2DecoderTest, UnmapBufferWriteNoBoundBufferFails) {
 363   const GLenum kTarget = GL_ARRAY_BUFFER;
 364
 365   UnmapBuffer cmd;
 366   cmd.Init(kTarget);
 367   decoder_->set_unsafe_es3_apis_enabled(true);
 368   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 369   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 370 }
 371
 372 TEST_P(GLES2DecoderTest, BufferDataDestroysDataStore) {
 373   const GLenum kTarget = GL_ARRAY_BUFFER;
 374   const GLintptr kOffset = 10;
 375   const GLsizeiptr kSize = 64;
 376   const GLbitfield kAccess = GL_MAP_WRITE_BIT;
 377   const GLbitfield kFilteredAccess = GL_MAP_WRITE_BIT | GL_MAP_READ_BIT;
 378
 379   uint32_t result_shm_id = kSharedMemoryId;
 380   uint32_t result_shm_offset = kSharedMemoryOffset;
 381   uint32_t data_shm_id = kSharedMemoryId;
 382   // uint32_t is Result for both MapBufferRange and UnmapBuffer commands.
 383   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(uint32_t);
 384
 385   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
 386
 387   std::vector<int8_t> data(kSize);
 388
 389   decoder_->set_unsafe_es3_apis_enabled(true);
 390
 391   {  // MapBufferRange succeeds
 392     EXPECT_CALL(*gl_,
 393                 MapBufferRange(kTarget, kOffset, kSize, kFilteredAccess))
 394         .WillOnce(Return(&data[0]))
 395         .RetiresOnSaturation();
 396
 397     typedef MapBufferRange::Result Result;
 398     Result* result = GetSharedMemoryAs<Result*>();
 399
 400     MapBufferRange cmd;
 401     cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
 402              result_shm_id, result_shm_offset);
 403     *result = 0;
 404     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 405     EXPECT_EQ(1u, *result);
 406   }
 407
 408   {  // BufferData unmaps the data store.
 409     DoBufferData(kTarget, kSize * 2);
 410     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 411   }
 412
 413   {  // UnmapBuffer fails.
 414     UnmapBuffer cmd;
 415     cmd.Init(kTarget);
 416     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 417     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 418   }
 419 }
 420
 421 TEST_P(GLES2DecoderTest, DeleteBuffersDestroysDataStore) {
 422   const GLenum kTarget = GL_ARRAY_BUFFER;
 423   const GLintptr kOffset = 10;
 424   const GLsizeiptr kSize = 64;
 425   const GLbitfield kAccess = GL_MAP_WRITE_BIT;
 426   const GLbitfield kFilteredAccess = GL_MAP_WRITE_BIT | GL_MAP_READ_BIT;
 427
 428   uint32_t result_shm_id = kSharedMemoryId;
 429   uint32_t result_shm_offset = kSharedMemoryOffset;
 430   uint32_t data_shm_id = kSharedMemoryId;
 431   // uint32_t is Result for both MapBufferRange and UnmapBuffer commands.
 432   uint32_t data_shm_offset = kSharedMemoryOffset + sizeof(uint32_t);
 433
 434   DoBindBuffer(kTarget, client_buffer_id_, kServiceBufferId);
 435
 436   std::vector<int8_t> data(kSize);
 437
 438   decoder_->set_unsafe_es3_apis_enabled(true);
 439
 440   {  // MapBufferRange succeeds
 441     EXPECT_CALL(*gl_,
 442                 MapBufferRange(kTarget, kOffset, kSize, kFilteredAccess))
 443         .WillOnce(Return(&data[0]))
 444         .RetiresOnSaturation();
 445
 446     typedef MapBufferRange::Result Result;
 447     Result* result = GetSharedMemoryAs<Result*>();
 448
 449     MapBufferRange cmd;
 450     cmd.Init(kTarget, kOffset, kSize, kAccess, data_shm_id, data_shm_offset,
 451              result_shm_id, result_shm_offset);
 452     *result = 0;
 453     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 454     EXPECT_EQ(1u, *result);
 455   }
 456
 457   {  // DeleteBuffers unmaps the data store.
 458     DoDeleteBuffer(client_buffer_id_, kServiceBufferId);
 459     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 460   }
 461
 462   {  // UnmapBuffer fails.
 463     UnmapBuffer cmd;
 464     cmd.Init(kTarget);
 465     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 466     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 467   }
 468 }
 469
 470 }  // namespace gles2
 471 }  // namespace gpu