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_.DoCommands(
171        1, (const void*)&cmd, ComputeNumEntries(sizeof(cmd)), 0);
172  }
173
174  template <typename T>
175  error::Error ExecuteImmediateCmd(const T& cmd, size_t data_size) {
176    COMPILE_ASSERT(T::kArgFlags == cmd::kAtLeastN, Cmd_kArgFlags_not_kAtLeastN);
177    return decoder_.DoCommands(
178        1, (const void*)&cmd, ComputeNumEntries(sizeof(cmd) + data_size), 0);
179  }
180
181  MockCommandBufferEngine engine_;
182  TestCommonDecoder decoder_;
183};
184
185TEST_F(CommonDecoderTest, Initialize) {
186  EXPECT_EQ(0, engine_.GetGetOffset());
187}
188
189TEST_F(CommonDecoderTest, DoCommonCommandInvalidCommand) {
190  EXPECT_EQ(error::kUnknownCommand, decoder_.DoCommand(999999, 0, NULL));
191}
192
193TEST_F(CommonDecoderTest, HandleNoop) {
194  cmd::Noop cmd;
195  const uint32 kSkipCount = 5;
196  cmd.Init(kSkipCount);
197  EXPECT_EQ(error::kNoError,
198            ExecuteImmediateCmd(
199                cmd, kSkipCount * kCommandBufferEntrySize));
200  const uint32 kSkipCount2 = 1;
201  cmd.Init(kSkipCount2);
202  EXPECT_EQ(error::kNoError,
203            ExecuteImmediateCmd(
204                cmd, kSkipCount2 * kCommandBufferEntrySize));
205}
206
207TEST_F(CommonDecoderTest, SetToken) {
208  cmd::SetToken cmd;
209  const int32 kTokenId = 123;
210  EXPECT_EQ(0, engine_.token());
211  cmd.Init(kTokenId);
212  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
213  EXPECT_EQ(kTokenId, engine_.token());
214}
215
216TEST_F(CommonDecoderTest, SetBucketSize) {
217  cmd::SetBucketSize cmd;
218  const uint32 kBucketId = 123;
219  const uint32 kBucketLength1 = 1234;
220  const uint32 kBucketLength2 = 78;
221  // Check the bucket does not exist.
222  EXPECT_TRUE(NULL == decoder_.GetBucket(kBucketId));
223  // Check we can create one.
224  cmd.Init(kBucketId, kBucketLength1);
225  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
226  CommonDecoder::Bucket* bucket;
227  bucket = decoder_.GetBucket(kBucketId);
228  EXPECT_TRUE(NULL != bucket);
229  EXPECT_EQ(kBucketLength1, bucket->size());
230  // Check we can change it.
231  cmd.Init(kBucketId, kBucketLength2);
232  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
233  bucket = decoder_.GetBucket(kBucketId);
234  EXPECT_TRUE(NULL != bucket);
235  EXPECT_EQ(kBucketLength2, bucket->size());
236  // Check we can delete it.
237  cmd.Init(kBucketId, 0);
238  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
239  bucket = decoder_.GetBucket(kBucketId);
240  EXPECT_EQ(0u, bucket->size());
241}
242
243TEST_F(CommonDecoderTest, SetBucketData) {
244  cmd::SetBucketSize size_cmd;
245  cmd::SetBucketData cmd;
246
247  static const char kData[] = "1234567890123456789";
248
249  const uint32 kBucketId = 123;
250  const uint32 kInvalidBucketId = 124;
251
252  size_cmd.Init(kBucketId, sizeof(kData));
253  EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd));
254  CommonDecoder::Bucket* bucket = decoder_.GetBucket(kBucketId);
255  // Check the data is not there.
256  EXPECT_NE(0, memcmp(bucket->GetData(0, sizeof(kData)), kData, sizeof(kData)));
257
258  // Check we can set it.
259  const uint32 kSomeOffsetInSharedMemory = 50;
260  void* memory = engine_.GetSharedMemoryAs<void*>(kSomeOffsetInSharedMemory);
261  memcpy(memory, kData, sizeof(kData));
262  cmd.Init(kBucketId, 0, sizeof(kData),
263           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
264  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
265  EXPECT_EQ(0, memcmp(bucket->GetData(0, sizeof(kData)), kData, sizeof(kData)));
266
267  // Check we can set it partially.
268  static const char kData2[] = "ABCEDFG";
269  const uint32 kSomeOffsetInBucket = 5;
270  memcpy(memory, kData2, sizeof(kData2));
271  cmd.Init(kBucketId, kSomeOffsetInBucket, sizeof(kData2),
272           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
273  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
274  EXPECT_EQ(0, memcmp(bucket->GetData(kSomeOffsetInBucket, sizeof(kData2)),
275                      kData2, sizeof(kData2)));
276  const char* bucket_data = bucket->GetDataAs<const char*>(0, sizeof(kData));
277  // Check that nothing was affected outside of updated area.
278  EXPECT_EQ(kData[kSomeOffsetInBucket - 1],
279            bucket_data[kSomeOffsetInBucket - 1]);
280  EXPECT_EQ(kData[kSomeOffsetInBucket + sizeof(kData2)],
281            bucket_data[kSomeOffsetInBucket + sizeof(kData2)]);
282
283  // Check that it fails if the bucket_id is invalid
284  cmd.Init(kInvalidBucketId, kSomeOffsetInBucket, sizeof(kData2),
285           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
286  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
287
288  // Check that it fails if the offset is out of range.
289  cmd.Init(kBucketId, bucket->size(), 1,
290           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
291  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
292
293  // Check that it fails if the size is out of range.
294  cmd.Init(kBucketId, 0, bucket->size() + 1,
295           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
296  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
297}
298
299TEST_F(CommonDecoderTest, SetBucketDataImmediate) {
300  cmd::SetBucketSize size_cmd;
301  int8 buffer[1024];
302  cmd::SetBucketDataImmediate& cmd =
303      *reinterpret_cast<cmd::SetBucketDataImmediate*>(&buffer);
304
305  static const char kData[] = "1234567890123456789";
306
307  const uint32 kBucketId = 123;
308  const uint32 kInvalidBucketId = 124;
309
310  size_cmd.Init(kBucketId, sizeof(kData));
311  EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd));
312  CommonDecoder::Bucket* bucket = decoder_.GetBucket(kBucketId);
313  // Check the data is not there.
314  EXPECT_NE(0, memcmp(bucket->GetData(0, sizeof(kData)), kData, sizeof(kData)));
315
316  // Check we can set it.
317  void* memory = &buffer[0] + sizeof(cmd);
318  memcpy(memory, kData, sizeof(kData));
319  cmd.Init(kBucketId, 0, sizeof(kData));
320  EXPECT_EQ(error::kNoError,
321            ExecuteImmediateCmd(cmd, sizeof(kData)));
322  EXPECT_EQ(0, memcmp(bucket->GetData(0, sizeof(kData)), kData, sizeof(kData)));
323
324  // Check we can set it partially.
325  static const char kData2[] = "ABCEDFG";
326  const uint32 kSomeOffsetInBucket = 5;
327  memcpy(memory, kData2, sizeof(kData2));
328  cmd.Init(kBucketId, kSomeOffsetInBucket, sizeof(kData2));
329  EXPECT_EQ(error::kNoError,
330            ExecuteImmediateCmd(cmd, sizeof(kData2)));
331  EXPECT_EQ(0, memcmp(bucket->GetData(kSomeOffsetInBucket, sizeof(kData2)),
332                      kData2, sizeof(kData2)));
333  const char* bucket_data = bucket->GetDataAs<const char*>(0, sizeof(kData));
334  // Check that nothing was affected outside of updated area.
335  EXPECT_EQ(kData[kSomeOffsetInBucket - 1],
336            bucket_data[kSomeOffsetInBucket - 1]);
337  EXPECT_EQ(kData[kSomeOffsetInBucket + sizeof(kData2)],
338            bucket_data[kSomeOffsetInBucket + sizeof(kData2)]);
339
340  // Check that it fails if the bucket_id is invalid
341  cmd.Init(kInvalidBucketId, kSomeOffsetInBucket, sizeof(kData2));
342  EXPECT_NE(error::kNoError,
343            ExecuteImmediateCmd(cmd, sizeof(kData2)));
344
345  // Check that it fails if the offset is out of range.
346  cmd.Init(kBucketId, bucket->size(), 1);
347  EXPECT_NE(error::kNoError,
348            ExecuteImmediateCmd(cmd, sizeof(kData2)));
349
350  // Check that it fails if the size is out of range.
351  cmd.Init(kBucketId, 0, bucket->size() + 1);
352  EXPECT_NE(error::kNoError,
353            ExecuteImmediateCmd(cmd, sizeof(kData2)));
354}
355
356TEST_F(CommonDecoderTest, GetBucketStart) {
357  cmd::SetBucketSize size_cmd;
358  cmd::SetBucketData set_cmd;
359  cmd::GetBucketStart cmd;
360
361  static const char kData[] = "1234567890123456789";
362  static const char zero[sizeof(kData)] = { 0, };
363
364  const uint32 kBucketSize = sizeof(kData);
365  const uint32 kBucketId = 123;
366  const uint32 kInvalidBucketId = 124;
367
368  // Put data in the bucket.
369  size_cmd.Init(kBucketId, sizeof(kData));
370  EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd));
371  const uint32 kSomeOffsetInSharedMemory = 50;
372  uint8* start = engine_.GetSharedMemoryAs<uint8*>(kSomeOffsetInSharedMemory);
373  memcpy(start, kData, sizeof(kData));
374  set_cmd.Init(kBucketId, 0, sizeof(kData),
375               MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
376  EXPECT_EQ(error::kNoError, ExecuteCmd(set_cmd));
377
378  // Check that the size is correct with no data buffer.
379  uint32* memory =
380      engine_.GetSharedMemoryAs<uint32*>(kSomeOffsetInSharedMemory);
381  *memory = 0x0;
382  cmd.Init(kBucketId,
383           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
384           0, 0, 0);
385  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
386  EXPECT_EQ(kBucketSize, *memory);
387
388  // Check that the data is copied with data buffer.
389  const uint32 kDataOffsetInSharedMemory = 54;
390  uint8* data = engine_.GetSharedMemoryAs<uint8*>(kDataOffsetInSharedMemory);
391  *memory = 0x0;
392  memset(data, 0, sizeof(kData));
393  cmd.Init(kBucketId,
394           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
395           kBucketSize, MockCommandBufferEngine::kValidShmId,
396           kDataOffsetInSharedMemory);
397  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
398  EXPECT_EQ(kBucketSize, *memory);
399  EXPECT_EQ(0, memcmp(data, kData, kBucketSize));
400
401  // Check that we can get a piece.
402  *memory = 0x0;
403  memset(data, 0, sizeof(kData));
404  const uint32 kPieceSize = kBucketSize / 2;
405  cmd.Init(kBucketId,
406           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
407           kPieceSize, MockCommandBufferEngine::kValidShmId,
408           kDataOffsetInSharedMemory);
409  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
410  EXPECT_EQ(kBucketSize, *memory);
411  EXPECT_EQ(0, memcmp(data, kData, kPieceSize));
412  EXPECT_EQ(0, memcmp(data + kPieceSize, zero, sizeof(kData) - kPieceSize));
413
414  // Check that it fails if the result_id is invalid
415  cmd.Init(kInvalidBucketId,
416           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
417           0, 0, 0);
418  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
419
420  // Check that it fails if the data_id is invalid
421  cmd.Init(kBucketId,
422           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
423           1, MockCommandBufferEngine::kInvalidShmId, 0);
424  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
425
426  // Check that it fails if the data_size is invalid
427  cmd.Init(kBucketId,
428           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
429           1, 0, 0);
430  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
431  cmd.Init(kBucketId,
432           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
433           MockCommandBufferEngine::kBufferSize + 1,
434           MockCommandBufferEngine::kValidShmId, 0);
435  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
436
437  // Check that it fails if the data_offset is invalid
438  cmd.Init(kBucketId,
439           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
440           0, 0, 1);
441  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
442  cmd.Init(kBucketId,
443           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
444           MockCommandBufferEngine::kBufferSize,
445           MockCommandBufferEngine::kValidShmId, 1);
446  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
447
448  // Check that it fails if the result size is not set to zero
449  *memory = 0x1;
450  cmd.Init(kBucketId,
451           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory,
452           0, 0, 0);
453  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
454}
455
456TEST_F(CommonDecoderTest, GetBucketData) {
457  cmd::SetBucketSize size_cmd;
458  cmd::SetBucketData set_cmd;
459  cmd::GetBucketData cmd;
460
461  static const char kData[] = "1234567890123456789";
462  static const char zero[sizeof(kData)] = { 0, };
463
464  const uint32 kBucketId = 123;
465  const uint32 kInvalidBucketId = 124;
466
467  size_cmd.Init(kBucketId, sizeof(kData));
468  EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd));
469  const uint32 kSomeOffsetInSharedMemory = 50;
470  uint8* memory = engine_.GetSharedMemoryAs<uint8*>(kSomeOffsetInSharedMemory);
471  memcpy(memory, kData, sizeof(kData));
472  set_cmd.Init(kBucketId, 0, sizeof(kData),
473               MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
474  EXPECT_EQ(error::kNoError, ExecuteCmd(set_cmd));
475
476  // Check we can get the whole thing.
477  memset(memory, 0, sizeof(kData));
478  cmd.Init(kBucketId, 0, sizeof(kData),
479           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
480  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
481  EXPECT_EQ(0, memcmp(memory, kData, sizeof(kData)));
482
483  // Check we can get a piece.
484  const uint32 kSomeOffsetInBucket = 5;
485  const uint32 kLengthOfPiece = 6;
486  const uint8 kSentinel = 0xff;
487  memset(memory, 0, sizeof(kData));
488  memory[-1] = kSentinel;
489  cmd.Init(kBucketId, kSomeOffsetInBucket, kLengthOfPiece,
490           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
491  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
492  EXPECT_EQ(0, memcmp(memory, kData + kSomeOffsetInBucket, kLengthOfPiece));
493  EXPECT_EQ(0, memcmp(memory + kLengthOfPiece, zero,
494                      sizeof(kData) - kLengthOfPiece));
495  EXPECT_EQ(kSentinel, memory[-1]);
496
497  // Check that it fails if the bucket_id is invalid
498  cmd.Init(kInvalidBucketId, kSomeOffsetInBucket, sizeof(kData),
499           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
500  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
501
502  // Check that it fails if the offset is invalid
503  cmd.Init(kBucketId, sizeof(kData) + 1, 1,
504           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
505  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
506
507  // Check that it fails if the size is invalid
508  cmd.Init(kBucketId, 0, sizeof(kData) + 1,
509           MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
510  EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
511}
512
513}  // namespace gpu
514