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