1// Copyright (c) 2012 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/common_decoder.h" 6#include "gpu/command_buffer/service/cmd_buffer_engine.h" 7#include "testing/gtest/include/gtest/gtest.h" 8 9namespace gpu { 10 11TEST(CommonDecoderBucket, Basic) { 12 CommonDecoder::Bucket bucket; 13 EXPECT_EQ(0u, bucket.size()); 14 EXPECT_TRUE(NULL == bucket.GetData(0, 0)); 15} 16 17TEST(CommonDecoderBucket, Size) { 18 CommonDecoder::Bucket bucket; 19 bucket.SetSize(24); 20 EXPECT_EQ(24u, bucket.size()); 21 bucket.SetSize(12); 22 EXPECT_EQ(12u, bucket.size()); 23} 24 25TEST(CommonDecoderBucket, GetData) { 26 CommonDecoder::Bucket bucket; 27 28 bucket.SetSize(24); 29 EXPECT_TRUE(NULL != bucket.GetData(0, 0)); 30 EXPECT_TRUE(NULL != bucket.GetData(24, 0)); 31 EXPECT_TRUE(NULL == bucket.GetData(25, 0)); 32 EXPECT_TRUE(NULL != bucket.GetData(0, 24)); 33 EXPECT_TRUE(NULL == bucket.GetData(0, 25)); 34 bucket.SetSize(23); 35 EXPECT_TRUE(NULL == bucket.GetData(0, 24)); 36} 37 38TEST(CommonDecoderBucket, SetData) { 39 CommonDecoder::Bucket bucket; 40 static const char data[] = "testing"; 41 42 bucket.SetSize(10); 43 EXPECT_TRUE(bucket.SetData(data, 0, sizeof(data))); 44 EXPECT_EQ(0, memcmp(data, bucket.GetData(0, sizeof(data)), sizeof(data))); 45 EXPECT_TRUE(bucket.SetData(data, 2, sizeof(data))); 46 EXPECT_EQ(0, memcmp(data, bucket.GetData(2, sizeof(data)), sizeof(data))); 47 EXPECT_FALSE(bucket.SetData(data, 0, sizeof(data) * 2)); 48 EXPECT_FALSE(bucket.SetData(data, 5, sizeof(data))); 49} 50 51class TestCommonDecoder : public CommonDecoder { 52 public: 53 // Overridden from AsyncAPIInterface 54 virtual const char* GetCommandName(unsigned int command_id) const OVERRIDE { 55 return GetCommonCommandName(static_cast<cmd::CommandId>(command_id)); 56 } 57 58 // Overridden from AsyncAPIInterface 59 virtual error::Error DoCommand( 60 unsigned int command, 61 unsigned int arg_count, 62 const void* cmd_data) OVERRIDE { 63 return DoCommonCommand(command, arg_count, cmd_data); 64 } 65 66 CommonDecoder::Bucket* GetBucket(uint32 id) const { 67 return CommonDecoder::GetBucket(id); 68 } 69}; 70 71class MockCommandBufferEngine : public CommandBufferEngine { 72 public: 73 static const int32 kStartValidShmId = 1; 74 static const int32 kValidShmId = 2; 75 static const int32 kInvalidShmId = 3; 76 static const size_t kBufferSize = 1024; 77 static const int32 kValidOffset = kBufferSize / 2; 78 static const int32 kInvalidOffset = kBufferSize; 79 80 MockCommandBufferEngine() 81 : CommandBufferEngine(), 82 token_(), 83 get_offset_(0) { 84 scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory()); 85 shared_memory->CreateAndMapAnonymous(kBufferSize); 86 buffer_ = MakeBufferFromSharedMemory(shared_memory.Pass(), kBufferSize); 87 } 88 89 // Overridden from CommandBufferEngine. 90 virtual scoped_refptr<gpu::Buffer> GetSharedMemoryBuffer(int32 shm_id) 91 OVERRIDE { 92 if (IsValidSharedMemoryId(shm_id)) 93 return buffer_; 94 return NULL; 95 } 96 97 template <typename T> 98 T GetSharedMemoryAs(uint32 offset) { 99 DCHECK_LT(offset, kBufferSize); 100 int8* buffer_memory = static_cast<int8*>(buffer_->memory()); 101 return reinterpret_cast<T>(&buffer_memory[offset]); 102 } 103 104 int32 GetSharedMemoryOffset(const void* memory) { 105 int8* buffer_memory = static_cast<int8*>(buffer_->memory()); 106 ptrdiff_t offset = static_cast<const int8*>(memory) - &buffer_memory[0]; 107 DCHECK_GE(offset, 0); 108 DCHECK_LT(static_cast<size_t>(offset), kBufferSize); 109 return static_cast<int32>(offset); 110 } 111 112 // Overridden from CommandBufferEngine. 113 virtual void set_token(int32 token) OVERRIDE { 114 token_ = token; 115 } 116 117 int32 token() const { 118 return token_; 119 } 120 121 // Overridden from CommandBufferEngine. 122 virtual bool SetGetBuffer(int32 transfer_buffer_id) OVERRIDE { 123 NOTREACHED(); 124 return false; 125 } 126 127 // Overridden from CommandBufferEngine. 128 virtual bool SetGetOffset(int32 offset) OVERRIDE { 129 if (static_cast<size_t>(offset) < kBufferSize) { 130 get_offset_ = offset; 131 return true; 132 } 133 return false; 134 } 135 136 // Overridden from CommandBufferEngine. 137 virtual int32 GetGetOffset() OVERRIDE { 138 return get_offset_; 139 } 140 141 private: 142 bool IsValidSharedMemoryId(int32 shm_id) { 143 return shm_id == kValidShmId || shm_id == kStartValidShmId; 144 } 145 146 scoped_refptr<gpu::Buffer> buffer_; 147 int32 token_; 148 int32 get_offset_; 149}; 150 151const int32 MockCommandBufferEngine::kStartValidShmId; 152const int32 MockCommandBufferEngine::kValidShmId; 153const int32 MockCommandBufferEngine::kInvalidShmId; 154const size_t MockCommandBufferEngine::kBufferSize; 155const int32 MockCommandBufferEngine::kValidOffset; 156const int32 MockCommandBufferEngine::kInvalidOffset; 157 158class CommonDecoderTest : public testing::Test { 159 protected: 160 virtual void SetUp() { 161 decoder_.set_engine(&engine_); 162 } 163 164 virtual void TearDown() { 165 } 166 167 template <typename T> 168 error::Error ExecuteCmd(const T& cmd) { 169 COMPILE_ASSERT(T::kArgFlags == cmd::kFixed, Cmd_kArgFlags_not_kFixed); 170 return decoder_.DoCommand(cmd.kCmdId, 171 ComputeNumEntries(sizeof(cmd)) - 1, 172 &cmd); 173 } 174 175 template <typename T> 176 error::Error ExecuteImmediateCmd(const T& cmd, size_t data_size) { 177 COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN); 178 return decoder_.DoCommand(cmd.kCmdId, 179 ComputeNumEntries(sizeof(cmd) + data_size) - 1, 180 &cmd); 181 } 182 183 MockCommandBufferEngine engine_; 184 TestCommonDecoder decoder_; 185}; 186 187TEST_F(CommonDecoderTest, Initialize) { 188 EXPECT_EQ(0, engine_.GetGetOffset()); 189} 190 191TEST_F(CommonDecoderTest, DoCommonCommandInvalidCommand) { 192 EXPECT_EQ(error::kUnknownCommand, decoder_.DoCommand(999999, 0, NULL)); 193} 194 195TEST_F(CommonDecoderTest, HandleNoop) { 196 cmd::Noop cmd; 197 const uint32 kSkipCount = 5; 198 cmd.Init(kSkipCount); 199 EXPECT_EQ(error::kNoError, 200 ExecuteImmediateCmd( 201 cmd, kSkipCount * kCommandBufferEntrySize)); 202 const uint32 kSkipCount2 = 1; 203 cmd.Init(kSkipCount2); 204 EXPECT_EQ(error::kNoError, 205 ExecuteImmediateCmd( 206 cmd, kSkipCount2 * kCommandBufferEntrySize)); 207} 208 209TEST_F(CommonDecoderTest, SetToken) { 210 cmd::SetToken cmd; 211 const int32 kTokenId = 123; 212 EXPECT_EQ(0, engine_.token()); 213 cmd.Init(kTokenId); 214 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 215 EXPECT_EQ(kTokenId, engine_.token()); 216} 217 218TEST_F(CommonDecoderTest, SetBucketSize) { 219 cmd::SetBucketSize cmd; 220 const uint32 kBucketId = 123; 221 const uint32 kBucketLength1 = 1234; 222 const uint32 kBucketLength2 = 78; 223 // Check the bucket does not exist. 224 EXPECT_TRUE(NULL == decoder_.GetBucket(kBucketId)); 225 // Check we can create one. 226 cmd.Init(kBucketId, kBucketLength1); 227 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 228 CommonDecoder::Bucket* bucket; 229 bucket = decoder_.GetBucket(kBucketId); 230 EXPECT_TRUE(NULL != bucket); 231 EXPECT_EQ(kBucketLength1, bucket->size()); 232 // Check we can change it. 233 cmd.Init(kBucketId, kBucketLength2); 234 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 235 bucket = decoder_.GetBucket(kBucketId); 236 EXPECT_TRUE(NULL != bucket); 237 EXPECT_EQ(kBucketLength2, bucket->size()); 238 // Check we can delete it. 239 cmd.Init(kBucketId, 0); 240 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 241 bucket = decoder_.GetBucket(kBucketId); 242 EXPECT_EQ(0u, bucket->size()); 243} 244 245TEST_F(CommonDecoderTest, SetBucketData) { 246 cmd::SetBucketSize size_cmd; 247 cmd::SetBucketData cmd; 248 249 static const char kData[] = "1234567890123456789"; 250 251 const uint32 kBucketId = 123; 252 const uint32 kInvalidBucketId = 124; 253 254 size_cmd.Init(kBucketId, sizeof(kData)); 255 EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd)); 256 CommonDecoder::Bucket* bucket = decoder_.GetBucket(kBucketId); 257 // Check the data is not there. 258 EXPECT_NE(0, memcmp(bucket->GetData(0, sizeof(kData)), kData, sizeof(kData))); 259 260 // Check we can set it. 261 const uint32 kSomeOffsetInSharedMemory = 50; 262 void* memory = engine_.GetSharedMemoryAs<void*>(kSomeOffsetInSharedMemory); 263 memcpy(memory, kData, sizeof(kData)); 264 cmd.Init(kBucketId, 0, sizeof(kData), 265 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 266 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 267 EXPECT_EQ(0, memcmp(bucket->GetData(0, sizeof(kData)), kData, sizeof(kData))); 268 269 // Check we can set it partially. 270 static const char kData2[] = "ABCEDFG"; 271 const uint32 kSomeOffsetInBucket = 5; 272 memcpy(memory, kData2, sizeof(kData2)); 273 cmd.Init(kBucketId, kSomeOffsetInBucket, sizeof(kData2), 274 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 275 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 276 EXPECT_EQ(0, memcmp(bucket->GetData(kSomeOffsetInBucket, sizeof(kData2)), 277 kData2, sizeof(kData2))); 278 const char* bucket_data = bucket->GetDataAs<const char*>(0, sizeof(kData)); 279 // Check that nothing was affected outside of updated area. 280 EXPECT_EQ(kData[kSomeOffsetInBucket - 1], 281 bucket_data[kSomeOffsetInBucket - 1]); 282 EXPECT_EQ(kData[kSomeOffsetInBucket + sizeof(kData2)], 283 bucket_data[kSomeOffsetInBucket + sizeof(kData2)]); 284 285 // Check that it fails if the bucket_id is invalid 286 cmd.Init(kInvalidBucketId, kSomeOffsetInBucket, sizeof(kData2), 287 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 288 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 289 290 // Check that it fails if the offset is out of range. 291 cmd.Init(kBucketId, bucket->size(), 1, 292 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 293 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 294 295 // Check that it fails if the size is out of range. 296 cmd.Init(kBucketId, 0, bucket->size() + 1, 297 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 298 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 299} 300 301TEST_F(CommonDecoderTest, SetBucketDataImmediate) { 302 cmd::SetBucketSize size_cmd; 303 int8 buffer[1024]; 304 cmd::SetBucketDataImmediate& cmd = 305 *reinterpret_cast<cmd::SetBucketDataImmediate*>(&buffer); 306 307 static const char kData[] = "1234567890123456789"; 308 309 const uint32 kBucketId = 123; 310 const uint32 kInvalidBucketId = 124; 311 312 size_cmd.Init(kBucketId, sizeof(kData)); 313 EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd)); 314 CommonDecoder::Bucket* bucket = decoder_.GetBucket(kBucketId); 315 // Check the data is not there. 316 EXPECT_NE(0, memcmp(bucket->GetData(0, sizeof(kData)), kData, sizeof(kData))); 317 318 // Check we can set it. 319 void* memory = &buffer[0] + sizeof(cmd); 320 memcpy(memory, kData, sizeof(kData)); 321 cmd.Init(kBucketId, 0, sizeof(kData)); 322 EXPECT_EQ(error::kNoError, 323 ExecuteImmediateCmd(cmd, sizeof(kData))); 324 EXPECT_EQ(0, memcmp(bucket->GetData(0, sizeof(kData)), kData, sizeof(kData))); 325 326 // Check we can set it partially. 327 static const char kData2[] = "ABCEDFG"; 328 const uint32 kSomeOffsetInBucket = 5; 329 memcpy(memory, kData2, sizeof(kData2)); 330 cmd.Init(kBucketId, kSomeOffsetInBucket, sizeof(kData2)); 331 EXPECT_EQ(error::kNoError, 332 ExecuteImmediateCmd(cmd, sizeof(kData2))); 333 EXPECT_EQ(0, memcmp(bucket->GetData(kSomeOffsetInBucket, sizeof(kData2)), 334 kData2, sizeof(kData2))); 335 const char* bucket_data = bucket->GetDataAs<const char*>(0, sizeof(kData)); 336 // Check that nothing was affected outside of updated area. 337 EXPECT_EQ(kData[kSomeOffsetInBucket - 1], 338 bucket_data[kSomeOffsetInBucket - 1]); 339 EXPECT_EQ(kData[kSomeOffsetInBucket + sizeof(kData2)], 340 bucket_data[kSomeOffsetInBucket + sizeof(kData2)]); 341 342 // Check that it fails if the bucket_id is invalid 343 cmd.Init(kInvalidBucketId, kSomeOffsetInBucket, sizeof(kData2)); 344 EXPECT_NE(error::kNoError, 345 ExecuteImmediateCmd(cmd, sizeof(kData2))); 346 347 // Check that it fails if the offset is out of range. 348 cmd.Init(kBucketId, bucket->size(), 1); 349 EXPECT_NE(error::kNoError, 350 ExecuteImmediateCmd(cmd, sizeof(kData2))); 351 352 // Check that it fails if the size is out of range. 353 cmd.Init(kBucketId, 0, bucket->size() + 1); 354 EXPECT_NE(error::kNoError, 355 ExecuteImmediateCmd(cmd, sizeof(kData2))); 356} 357 358TEST_F(CommonDecoderTest, GetBucketStart) { 359 cmd::SetBucketSize size_cmd; 360 cmd::SetBucketData set_cmd; 361 cmd::GetBucketStart cmd; 362 363 static const char kData[] = "1234567890123456789"; 364 static const char zero[sizeof(kData)] = { 0, }; 365 366 const uint32 kBucketSize = sizeof(kData); 367 const uint32 kBucketId = 123; 368 const uint32 kInvalidBucketId = 124; 369 370 // Put data in the bucket. 371 size_cmd.Init(kBucketId, sizeof(kData)); 372 EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd)); 373 const uint32 kSomeOffsetInSharedMemory = 50; 374 uint8* start = engine_.GetSharedMemoryAs<uint8*>(kSomeOffsetInSharedMemory); 375 memcpy(start, kData, sizeof(kData)); 376 set_cmd.Init(kBucketId, 0, sizeof(kData), 377 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 378 EXPECT_EQ(error::kNoError, ExecuteCmd(set_cmd)); 379 380 // Check that the size is correct with no data buffer. 381 uint32* memory = 382 engine_.GetSharedMemoryAs<uint32*>(kSomeOffsetInSharedMemory); 383 *memory = 0x0; 384 cmd.Init(kBucketId, 385 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory, 386 0, 0, 0); 387 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 388 EXPECT_EQ(kBucketSize, *memory); 389 390 // Check that the data is copied with data buffer. 391 const uint32 kDataOffsetInSharedMemory = 54; 392 uint8* data = engine_.GetSharedMemoryAs<uint8*>(kDataOffsetInSharedMemory); 393 *memory = 0x0; 394 memset(data, 0, sizeof(kData)); 395 cmd.Init(kBucketId, 396 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory, 397 kBucketSize, MockCommandBufferEngine::kValidShmId, 398 kDataOffsetInSharedMemory); 399 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 400 EXPECT_EQ(kBucketSize, *memory); 401 EXPECT_EQ(0, memcmp(data, kData, kBucketSize)); 402 403 // Check that we can get a piece. 404 *memory = 0x0; 405 memset(data, 0, sizeof(kData)); 406 const uint32 kPieceSize = kBucketSize / 2; 407 cmd.Init(kBucketId, 408 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory, 409 kPieceSize, MockCommandBufferEngine::kValidShmId, 410 kDataOffsetInSharedMemory); 411 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 412 EXPECT_EQ(kBucketSize, *memory); 413 EXPECT_EQ(0, memcmp(data, kData, kPieceSize)); 414 EXPECT_EQ(0, memcmp(data + kPieceSize, zero, sizeof(kData) - kPieceSize)); 415 416 // Check that it fails if the result_id is invalid 417 cmd.Init(kInvalidBucketId, 418 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory, 419 0, 0, 0); 420 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 421 422 // Check that it fails if the data_id is invalid 423 cmd.Init(kBucketId, 424 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory, 425 1, MockCommandBufferEngine::kInvalidShmId, 0); 426 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 427 428 // Check that it fails if the data_size is invalid 429 cmd.Init(kBucketId, 430 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory, 431 1, 0, 0); 432 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 433 cmd.Init(kBucketId, 434 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory, 435 MockCommandBufferEngine::kBufferSize + 1, 436 MockCommandBufferEngine::kValidShmId, 0); 437 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 438 439 // Check that it fails if the data_offset is invalid 440 cmd.Init(kBucketId, 441 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory, 442 0, 0, 1); 443 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 444 cmd.Init(kBucketId, 445 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory, 446 MockCommandBufferEngine::kBufferSize, 447 MockCommandBufferEngine::kValidShmId, 1); 448 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 449 450 // Check that it fails if the result size is not set to zero 451 *memory = 0x1; 452 cmd.Init(kBucketId, 453 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory, 454 0, 0, 0); 455 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 456} 457 458TEST_F(CommonDecoderTest, GetBucketData) { 459 cmd::SetBucketSize size_cmd; 460 cmd::SetBucketData set_cmd; 461 cmd::GetBucketData cmd; 462 463 static const char kData[] = "1234567890123456789"; 464 static const char zero[sizeof(kData)] = { 0, }; 465 466 const uint32 kBucketId = 123; 467 const uint32 kInvalidBucketId = 124; 468 469 size_cmd.Init(kBucketId, sizeof(kData)); 470 EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd)); 471 const uint32 kSomeOffsetInSharedMemory = 50; 472 uint8* memory = engine_.GetSharedMemoryAs<uint8*>(kSomeOffsetInSharedMemory); 473 memcpy(memory, kData, sizeof(kData)); 474 set_cmd.Init(kBucketId, 0, sizeof(kData), 475 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 476 EXPECT_EQ(error::kNoError, ExecuteCmd(set_cmd)); 477 478 // Check we can get the whole thing. 479 memset(memory, 0, sizeof(kData)); 480 cmd.Init(kBucketId, 0, sizeof(kData), 481 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 482 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 483 EXPECT_EQ(0, memcmp(memory, kData, sizeof(kData))); 484 485 // Check we can get a piece. 486 const uint32 kSomeOffsetInBucket = 5; 487 const uint32 kLengthOfPiece = 6; 488 const uint8 kSentinel = 0xff; 489 memset(memory, 0, sizeof(kData)); 490 memory[-1] = kSentinel; 491 cmd.Init(kBucketId, kSomeOffsetInBucket, kLengthOfPiece, 492 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 493 EXPECT_EQ(error::kNoError, ExecuteCmd(cmd)); 494 EXPECT_EQ(0, memcmp(memory, kData + kSomeOffsetInBucket, kLengthOfPiece)); 495 EXPECT_EQ(0, memcmp(memory + kLengthOfPiece, zero, 496 sizeof(kData) - kLengthOfPiece)); 497 EXPECT_EQ(kSentinel, memory[-1]); 498 499 // Check that it fails if the bucket_id is invalid 500 cmd.Init(kInvalidBucketId, kSomeOffsetInBucket, sizeof(kData), 501 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 502 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 503 504 // Check that it fails if the offset is invalid 505 cmd.Init(kBucketId, sizeof(kData) + 1, 1, 506 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 507 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 508 509 // Check that it fails if the size is invalid 510 cmd.Init(kBucketId, 0, sizeof(kData) + 1, 511 MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory); 512 EXPECT_NE(error::kNoError, ExecuteCmd(cmd)); 513} 514 515} // namespace gpu 516