gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc

   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/gles2_cmd_decoder_unittest.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "gpu/command_buffer/common/gles2_cmd_format.h"
  10 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  11 #include "gpu/command_buffer/common/id_allocator.h"
  12 #include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
  13 #include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
  14 #include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
  15 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
  16 #include "gpu/command_buffer/service/context_group.h"
  17 #include "gpu/command_buffer/service/context_state.h"
  18 #include "gpu/command_buffer/service/gl_surface_mock.h"
  19 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
  20 #include "gpu/command_buffer/service/gpu_switches.h"
  21 #include "gpu/command_buffer/service/image_manager.h"
  22 #include "gpu/command_buffer/service/mailbox_manager.h"
  23 #include "gpu/command_buffer/service/mocks.h"
  24 #include "gpu/command_buffer/service/program_manager.h"
  25 #include "gpu/command_buffer/service/test_helper.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27 #include "ui/gl/gl_implementation.h"
  28 #include "ui/gl/gl_mock.h"
  29 #include "ui/gl/gl_surface_stub.h"
  30
  31
  32 #if !defined(GL_DEPTH24_STENCIL8)
  33 #define GL_DEPTH24_STENCIL8 0x88F0
  34 #endif
  35
  36 using ::gfx::MockGLInterface;
  37 using ::testing::_;
  38 using ::testing::AtLeast;
  39 using ::testing::DoAll;
  40 using ::testing::InSequence;
  41 using ::testing::Invoke;
  42 using ::testing::MatcherCast;
  43 using ::testing::Mock;
  44 using ::testing::Pointee;
  45 using ::testing::Return;
  46 using ::testing::SaveArg;
  47 using ::testing::SetArrayArgument;
  48 using ::testing::SetArgumentPointee;
  49 using ::testing::SetArgPointee;
  50 using ::testing::StrEq;
  51 using ::testing::StrictMock;
  52
  53 namespace gpu {
  54 namespace gles2 {
  55
  56 using namespace cmds;
  57
  58 void GLES2DecoderRGBBackbufferTest::SetUp() {
  59   // Test codepath with workaround clear_alpha_in_readpixels because
  60   // ReadPixelsEmulator emulates the incorrect driver behavior.
  61   CommandLine command_line(0, NULL);
  62   command_line.AppendSwitchASCII(
  63       switches::kGpuDriverBugWorkarounds,
  64       base::IntToString(gpu::CLEAR_ALPHA_IN_READPIXELS));
  65   InitState init;
  66   init.gl_version = "3.0";
  67   init.bind_generates_resource = true;
  68   InitDecoderWithCommandLine(init, &command_line);
  69   SetupDefaultProgram();
  70 }
  71
  72 // Override default setup so nothing gets setup.
  73 void GLES2DecoderManualInitTest::SetUp() {
  74 }
  75
  76 void GLES2DecoderManualInitTest::EnableDisableTest(GLenum cap,
  77                                                    bool enable,
  78                                                    bool expect_set) {
  79   if (expect_set) {
  80     SetupExpectationsForEnableDisable(cap, enable);
  81   }
  82   if (enable) {
  83     Enable cmd;
  84     cmd.Init(cap);
  85     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  86     EXPECT_EQ(GL_NO_ERROR, GetGLError());
  87   } else {
  88     Disable cmd;
  89     cmd.Init(cap);
  90     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  91     EXPECT_EQ(GL_NO_ERROR, GetGLError());
  92   }
  93 }
  94
  95 TEST_P(GLES2DecoderTest, GetIntegervCached) {
  96   struct TestInfo {
  97     GLenum pname;
  98     GLint expected;
  99   };
 100   TestInfo tests[] = {
 101       {
 102        GL_MAX_TEXTURE_SIZE, TestHelper::kMaxTextureSize,
 103       },
 104       {
 105        GL_MAX_CUBE_MAP_TEXTURE_SIZE, TestHelper::kMaxCubeMapTextureSize,
 106       },
 107       {
 108        GL_MAX_RENDERBUFFER_SIZE, TestHelper::kMaxRenderbufferSize,
 109       },
 110   };
 111   typedef GetIntegerv::Result Result;
 112   for (size_t ii = 0; ii < sizeof(tests) / sizeof(tests[0]); ++ii) {
 113     const TestInfo& test = tests[ii];
 114     Result* result = static_cast<Result*>(shared_memory_address_);
 115     EXPECT_CALL(*gl_, GetError())
 116         .WillOnce(Return(GL_NO_ERROR))
 117         .WillOnce(Return(GL_NO_ERROR))
 118         .RetiresOnSaturation();
 119     EXPECT_CALL(*gl_, GetIntegerv(test.pname, _)).Times(0);
 120     result->size = 0;
 121     GetIntegerv cmd2;
 122     cmd2.Init(test.pname, shared_memory_id_, shared_memory_offset_);
 123     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
 124     EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(test.pname),
 125               result->GetNumResults());
 126     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 127     EXPECT_EQ(test.expected, result->GetData()[0]);
 128   }
 129 }
 130
 131 TEST_P(GLES2DecoderWithShaderTest, GetMaxValueInBufferCHROMIUM) {
 132   SetupIndexBuffer();
 133   GetMaxValueInBufferCHROMIUM::Result* result =
 134       static_cast<GetMaxValueInBufferCHROMIUM::Result*>(shared_memory_address_);
 135   *result = 0;
 136
 137   GetMaxValueInBufferCHROMIUM cmd;
 138   cmd.Init(client_element_buffer_id_,
 139            kValidIndexRangeCount,
 140            GL_UNSIGNED_SHORT,
 141            kValidIndexRangeStart * 2,
 142            kSharedMemoryId,
 143            kSharedMemoryOffset);
 144   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 145   EXPECT_EQ(7u, *result);
 146   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 147   cmd.Init(client_element_buffer_id_,
 148            kValidIndexRangeCount + 1,
 149            GL_UNSIGNED_SHORT,
 150            kValidIndexRangeStart * 2,
 151            kSharedMemoryId,
 152            kSharedMemoryOffset);
 153   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 154   EXPECT_EQ(100u, *result);
 155   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 156
 157   cmd.Init(kInvalidClientId,
 158            kValidIndexRangeCount,
 159            GL_UNSIGNED_SHORT,
 160            kValidIndexRangeStart * 2,
 161            kSharedMemoryId,
 162            kSharedMemoryOffset);
 163   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 164   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 165   cmd.Init(client_element_buffer_id_,
 166            kOutOfRangeIndexRangeEnd,
 167            GL_UNSIGNED_SHORT,
 168            kValidIndexRangeStart * 2,
 169            kSharedMemoryId,
 170            kSharedMemoryOffset);
 171   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 172   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 173   cmd.Init(client_element_buffer_id_,
 174            kValidIndexRangeCount + 1,
 175            GL_UNSIGNED_SHORT,
 176            kOutOfRangeIndexRangeEnd * 2,
 177            kSharedMemoryId,
 178            kSharedMemoryOffset);
 179   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 180   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 181   cmd.Init(client_element_buffer_id_,
 182            kValidIndexRangeCount + 1,
 183            GL_UNSIGNED_SHORT,
 184            kValidIndexRangeStart * 2,
 185            kSharedMemoryId,
 186            kSharedMemoryOffset);
 187   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 188   cmd.Init(client_buffer_id_,
 189            kValidIndexRangeCount + 1,
 190            GL_UNSIGNED_SHORT,
 191            kValidIndexRangeStart * 2,
 192            kSharedMemoryId,
 193            kSharedMemoryOffset);
 194   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 195   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 196   cmd.Init(client_element_buffer_id_,
 197            kValidIndexRangeCount + 1,
 198            GL_UNSIGNED_SHORT,
 199            kValidIndexRangeStart * 2,
 200            kInvalidSharedMemoryId,
 201            kSharedMemoryOffset);
 202   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 203   cmd.Init(client_element_buffer_id_,
 204            kValidIndexRangeCount + 1,
 205            GL_UNSIGNED_SHORT,
 206            kValidIndexRangeStart * 2,
 207            kSharedMemoryId,
 208            kInvalidSharedMemoryOffset);
 209   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 210 }
 211
 212 TEST_P(GLES2DecoderTest, SharedIds) {
 213   GenSharedIdsCHROMIUM gen_cmd;
 214   RegisterSharedIdsCHROMIUM reg_cmd;
 215   DeleteSharedIdsCHROMIUM del_cmd;
 216
 217   const GLuint kNamespaceId = id_namespaces::kTextures;
 218   const GLuint kExpectedId1 = 1;
 219   const GLuint kExpectedId2 = 2;
 220   const GLuint kExpectedId3 = 4;
 221   const GLuint kRegisterId = 3;
 222   GLuint* ids = GetSharedMemoryAs<GLuint*>();
 223   gen_cmd.Init(kNamespaceId, 0, 2, kSharedMemoryId, kSharedMemoryOffset);
 224   EXPECT_EQ(error::kNoError, ExecuteCmd(gen_cmd));
 225   IdAllocatorInterface* id_allocator = GetIdAllocator(kNamespaceId);
 226   ASSERT_TRUE(id_allocator != NULL);
 227   // This check is implementation dependant but it's kind of hard to check
 228   // otherwise.
 229   EXPECT_EQ(kExpectedId1, ids[0]);
 230   EXPECT_EQ(kExpectedId2, ids[1]);
 231   EXPECT_TRUE(id_allocator->InUse(kExpectedId1));
 232   EXPECT_TRUE(id_allocator->InUse(kExpectedId2));
 233   EXPECT_FALSE(id_allocator->InUse(kRegisterId));
 234   EXPECT_FALSE(id_allocator->InUse(kExpectedId3));
 235
 236   ClearSharedMemory();
 237   ids[0] = kRegisterId;
 238   reg_cmd.Init(kNamespaceId, 1, kSharedMemoryId, kSharedMemoryOffset);
 239   EXPECT_EQ(error::kNoError, ExecuteCmd(reg_cmd));
 240   EXPECT_TRUE(id_allocator->InUse(kExpectedId1));
 241   EXPECT_TRUE(id_allocator->InUse(kExpectedId2));
 242   EXPECT_TRUE(id_allocator->InUse(kRegisterId));
 243   EXPECT_FALSE(id_allocator->InUse(kExpectedId3));
 244
 245   ClearSharedMemory();
 246   gen_cmd.Init(kNamespaceId, 0, 1, kSharedMemoryId, kSharedMemoryOffset);
 247   EXPECT_EQ(error::kNoError, ExecuteCmd(gen_cmd));
 248   EXPECT_EQ(kExpectedId3, ids[0]);
 249   EXPECT_TRUE(id_allocator->InUse(kExpectedId1));
 250   EXPECT_TRUE(id_allocator->InUse(kExpectedId2));
 251   EXPECT_TRUE(id_allocator->InUse(kRegisterId));
 252   EXPECT_TRUE(id_allocator->InUse(kExpectedId3));
 253
 254   ClearSharedMemory();
 255   ids[0] = kExpectedId1;
 256   ids[1] = kRegisterId;
 257   del_cmd.Init(kNamespaceId, 2, kSharedMemoryId, kSharedMemoryOffset);
 258   EXPECT_EQ(error::kNoError, ExecuteCmd(del_cmd));
 259   EXPECT_FALSE(id_allocator->InUse(kExpectedId1));
 260   EXPECT_TRUE(id_allocator->InUse(kExpectedId2));
 261   EXPECT_FALSE(id_allocator->InUse(kRegisterId));
 262   EXPECT_TRUE(id_allocator->InUse(kExpectedId3));
 263
 264   ClearSharedMemory();
 265   ids[0] = kExpectedId3;
 266   ids[1] = kExpectedId2;
 267   del_cmd.Init(kNamespaceId, 2, kSharedMemoryId, kSharedMemoryOffset);
 268   EXPECT_EQ(error::kNoError, ExecuteCmd(del_cmd));
 269   EXPECT_FALSE(id_allocator->InUse(kExpectedId1));
 270   EXPECT_FALSE(id_allocator->InUse(kExpectedId2));
 271   EXPECT_FALSE(id_allocator->InUse(kRegisterId));
 272   EXPECT_FALSE(id_allocator->InUse(kExpectedId3));
 273
 274   // Check passing in an id_offset.
 275   ClearSharedMemory();
 276   const GLuint kOffset = 0xABCDEF;
 277   gen_cmd.Init(kNamespaceId, kOffset, 2, kSharedMemoryId, kSharedMemoryOffset);
 278   EXPECT_EQ(error::kNoError, ExecuteCmd(gen_cmd));
 279   EXPECT_EQ(kOffset, ids[0]);
 280   EXPECT_EQ(kOffset + 1, ids[1]);
 281 }
 282
 283 TEST_P(GLES2DecoderTest, GenSharedIdsCHROMIUMBadArgs) {
 284   const GLuint kNamespaceId = id_namespaces::kTextures;
 285   GenSharedIdsCHROMIUM cmd;
 286   cmd.Init(kNamespaceId, 0, -1, kSharedMemoryId, kSharedMemoryOffset);
 287   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 288   cmd.Init(kNamespaceId, 0, 1, kInvalidSharedMemoryId, kSharedMemoryOffset);
 289   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 290   cmd.Init(kNamespaceId, 0, 1, kSharedMemoryId, kInvalidSharedMemoryOffset);
 291   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 292 }
 293
 294 TEST_P(GLES2DecoderTest, RegisterSharedIdsCHROMIUMBadArgs) {
 295   const GLuint kNamespaceId = id_namespaces::kTextures;
 296   RegisterSharedIdsCHROMIUM cmd;
 297   cmd.Init(kNamespaceId, -1, kSharedMemoryId, kSharedMemoryOffset);
 298   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 299   cmd.Init(kNamespaceId, 1, kInvalidSharedMemoryId, kSharedMemoryOffset);
 300   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 301   cmd.Init(kNamespaceId, 1, kSharedMemoryId, kInvalidSharedMemoryOffset);
 302   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 303 }
 304
 305 TEST_P(GLES2DecoderTest, RegisterSharedIdsCHROMIUMDuplicateIds) {
 306   const GLuint kNamespaceId = id_namespaces::kTextures;
 307   const GLuint kRegisterId = 3;
 308   RegisterSharedIdsCHROMIUM cmd;
 309   GLuint* ids = GetSharedMemoryAs<GLuint*>();
 310   ids[0] = kRegisterId;
 311   cmd.Init(kNamespaceId, 1, kSharedMemoryId, kSharedMemoryOffset);
 312   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 313   cmd.Init(kNamespaceId, 1, kSharedMemoryId, kSharedMemoryOffset);
 314   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 315   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 316 }
 317
 318 TEST_P(GLES2DecoderTest, DeleteSharedIdsCHROMIUMBadArgs) {
 319   const GLuint kNamespaceId = id_namespaces::kTextures;
 320   DeleteSharedIdsCHROMIUM cmd;
 321   cmd.Init(kNamespaceId, -1, kSharedMemoryId, kSharedMemoryOffset);
 322   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 323   cmd.Init(kNamespaceId, 1, kInvalidSharedMemoryId, kSharedMemoryOffset);
 324   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 325   cmd.Init(kNamespaceId, 1, kSharedMemoryId, kInvalidSharedMemoryOffset);
 326   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 327 }
 328
 329 TEST_P(GLES2DecoderTest, IsBuffer) {
 330   EXPECT_FALSE(DoIsBuffer(client_buffer_id_));
 331   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
 332   EXPECT_TRUE(DoIsBuffer(client_buffer_id_));
 333   DoDeleteBuffer(client_buffer_id_, kServiceBufferId);
 334   EXPECT_FALSE(DoIsBuffer(client_buffer_id_));
 335 }
 336
 337 TEST_P(GLES2DecoderTest, IsFramebuffer) {
 338   EXPECT_FALSE(DoIsFramebuffer(client_framebuffer_id_));
 339   DoBindFramebuffer(
 340       GL_FRAMEBUFFER, client_framebuffer_id_, kServiceFramebufferId);
 341   EXPECT_TRUE(DoIsFramebuffer(client_framebuffer_id_));
 342   DoDeleteFramebuffer(client_framebuffer_id_,
 343                       kServiceFramebufferId,
 344                       true,
 345                       GL_FRAMEBUFFER,
 346                       0,
 347                       true,
 348                       GL_FRAMEBUFFER,
 349                       0);
 350   EXPECT_FALSE(DoIsFramebuffer(client_framebuffer_id_));
 351 }
 352
 353 TEST_P(GLES2DecoderTest, IsProgram) {
 354   // IsProgram is true as soon as the program is created.
 355   EXPECT_TRUE(DoIsProgram(client_program_id_));
 356   EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId))
 357       .Times(1)
 358       .RetiresOnSaturation();
 359   DoDeleteProgram(client_program_id_, kServiceProgramId);
 360   EXPECT_FALSE(DoIsProgram(client_program_id_));
 361 }
 362
 363 TEST_P(GLES2DecoderTest, IsRenderbuffer) {
 364   EXPECT_FALSE(DoIsRenderbuffer(client_renderbuffer_id_));
 365   DoBindRenderbuffer(
 366       GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
 367   EXPECT_TRUE(DoIsRenderbuffer(client_renderbuffer_id_));
 368   DoDeleteRenderbuffer(client_renderbuffer_id_, kServiceRenderbufferId);
 369   EXPECT_FALSE(DoIsRenderbuffer(client_renderbuffer_id_));
 370 }
 371
 372 TEST_P(GLES2DecoderTest, IsShader) {
 373   // IsShader is true as soon as the program is created.
 374   EXPECT_TRUE(DoIsShader(client_shader_id_));
 375   DoDeleteShader(client_shader_id_, kServiceShaderId);
 376   EXPECT_FALSE(DoIsShader(client_shader_id_));
 377 }
 378
 379 TEST_P(GLES2DecoderTest, IsTexture) {
 380   EXPECT_FALSE(DoIsTexture(client_texture_id_));
 381   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 382   EXPECT_TRUE(DoIsTexture(client_texture_id_));
 383   DoDeleteTexture(client_texture_id_, kServiceTextureId);
 384   EXPECT_FALSE(DoIsTexture(client_texture_id_));
 385 }
 386
 387 TEST_P(GLES2DecoderTest, GetMultipleIntegervCHROMIUMValidArgs) {
 388   const GLsizei kCount = 3;
 389   GLenum* pnames = GetSharedMemoryAs<GLenum*>();
 390   pnames[0] = GL_DEPTH_WRITEMASK;
 391   pnames[1] = GL_COLOR_WRITEMASK;
 392   pnames[2] = GL_STENCIL_WRITEMASK;
 393   GLint* results =
 394       GetSharedMemoryAsWithOffset<GLint*>(sizeof(*pnames) * kCount);
 395
 396   GLsizei num_results = 0;
 397   for (GLsizei ii = 0; ii < kCount; ++ii) {
 398     num_results += decoder_->GetGLES2Util()->GLGetNumValuesReturned(pnames[ii]);
 399   }
 400   const GLsizei result_size = num_results * sizeof(*results);
 401   memset(results, 0, result_size);
 402
 403   const GLint kSentinel = 0x12345678;
 404   results[num_results] = kSentinel;
 405
 406   GetMultipleIntegervCHROMIUM cmd;
 407   cmd.Init(kSharedMemoryId,
 408            kSharedMemoryOffset,
 409            kCount,
 410            kSharedMemoryId,
 411            kSharedMemoryOffset + sizeof(*pnames) * kCount,
 412            result_size);
 413
 414   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 415   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 416   EXPECT_EQ(1, results[0]);                    // Depth writemask
 417   EXPECT_EQ(1, results[1]);                    // color writemask red
 418   EXPECT_EQ(1, results[2]);                    // color writemask green
 419   EXPECT_EQ(1, results[3]);                    // color writemask blue
 420   EXPECT_EQ(1, results[4]);                    // color writemask alpha
 421   EXPECT_EQ(-1, results[5]);                   // stencil writemask alpha
 422   EXPECT_EQ(kSentinel, results[num_results]);  // End of results
 423 }
 424
 425 TEST_P(GLES2DecoderTest, GetMultipleIntegervCHROMIUMInvalidArgs) {
 426   const GLsizei kCount = 3;
 427   // Offset the pnames because GLGetError will use the first uint32.
 428   const uint32 kPnameOffset = sizeof(uint32);
 429   const uint32 kResultsOffset = kPnameOffset + sizeof(GLint) * kCount;
 430   GLenum* pnames = GetSharedMemoryAsWithOffset<GLenum*>(kPnameOffset);
 431   pnames[0] = GL_DEPTH_WRITEMASK;
 432   pnames[1] = GL_COLOR_WRITEMASK;
 433   pnames[2] = GL_STENCIL_WRITEMASK;
 434   GLint* results = GetSharedMemoryAsWithOffset<GLint*>(kResultsOffset);
 435
 436   GLsizei num_results = 0;
 437   for (GLsizei ii = 0; ii < kCount; ++ii) {
 438     num_results += decoder_->GetGLES2Util()->GLGetNumValuesReturned(pnames[ii]);
 439   }
 440   const GLsizei result_size = num_results * sizeof(*results);
 441   memset(results, 0, result_size);
 442
 443   const GLint kSentinel = 0x12345678;
 444   results[num_results] = kSentinel;
 445
 446   GetMultipleIntegervCHROMIUM cmd;
 447   // Check bad pnames pointer.
 448   cmd.Init(kInvalidSharedMemoryId,
 449            kSharedMemoryOffset + kPnameOffset,
 450            kCount,
 451            kSharedMemoryId,
 452            kSharedMemoryOffset + kResultsOffset,
 453            result_size);
 454   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 455   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 456   // Check bad pnames pointer.
 457   cmd.Init(kSharedMemoryId,
 458            kInvalidSharedMemoryOffset,
 459            kCount,
 460            kSharedMemoryId,
 461            kSharedMemoryOffset + kResultsOffset,
 462            result_size);
 463   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 464   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 465   // Check bad count.
 466   cmd.Init(kSharedMemoryId,
 467            kSharedMemoryOffset + kPnameOffset,
 468            static_cast<GLuint>(-1),
 469            kSharedMemoryId,
 470            kSharedMemoryOffset + kResultsOffset,
 471            result_size);
 472   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 473   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 474   // Check bad results pointer.
 475   cmd.Init(kSharedMemoryId,
 476            kSharedMemoryOffset + kPnameOffset,
 477            kCount,
 478            kInvalidSharedMemoryId,
 479            kSharedMemoryOffset + kResultsOffset,
 480            result_size);
 481   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 482   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 483   // Check bad results pointer.
 484   cmd.Init(kSharedMemoryId,
 485            kSharedMemoryOffset + kPnameOffset,
 486            kCount,
 487            kSharedMemoryId,
 488            kInvalidSharedMemoryOffset,
 489            result_size);
 490   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 491   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 492   // Check bad size.
 493   cmd.Init(kSharedMemoryId,
 494            kSharedMemoryOffset + kPnameOffset,
 495            kCount,
 496            kSharedMemoryId,
 497            kSharedMemoryOffset + kResultsOffset,
 498            result_size + 1);
 499   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 500   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 501   // Check bad size.
 502   cmd.Init(kSharedMemoryId,
 503            kSharedMemoryOffset + kPnameOffset,
 504            kCount,
 505            kSharedMemoryId,
 506            kSharedMemoryOffset + kResultsOffset,
 507            result_size - 1);
 508   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 509   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 510   // Check bad enum.
 511   cmd.Init(kSharedMemoryId,
 512            kSharedMemoryOffset + kPnameOffset,
 513            kCount,
 514            kSharedMemoryId,
 515            kSharedMemoryOffset + kResultsOffset,
 516            result_size);
 517   GLenum temp = pnames[2];
 518   pnames[2] = GL_TRUE;
 519   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 520   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 521   pnames[2] = temp;
 522   // Check results area has not been cleared by client.
 523   results[1] = 1;
 524   EXPECT_EQ(error::kInvalidArguments, ExecuteCmd(cmd));
 525   // Check buffer is what we expect
 526   EXPECT_EQ(0, results[0]);
 527   EXPECT_EQ(1, results[1]);
 528   EXPECT_EQ(0, results[2]);
 529   EXPECT_EQ(0, results[3]);
 530   EXPECT_EQ(0, results[4]);
 531   EXPECT_EQ(0, results[5]);
 532   EXPECT_EQ(kSentinel, results[num_results]);  // End of results
 533 }
 534
 535 TEST_P(GLES2DecoderManualInitTest, BindGeneratesResourceFalse) {
 536   InitState init;
 537   init.gl_version = "3.0";
 538   InitDecoder(init);
 539
 540   BindTexture cmd1;
 541   cmd1.Init(GL_TEXTURE_2D, kInvalidClientId);
 542   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
 543   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 544
 545   BindBuffer cmd2;
 546   cmd2.Init(GL_ARRAY_BUFFER, kInvalidClientId);
 547   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
 548   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 549
 550   BindFramebuffer cmd3;
 551   cmd3.Init(GL_FRAMEBUFFER, kInvalidClientId);
 552   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd3));
 553   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 554
 555   BindRenderbuffer cmd4;
 556   cmd4.Init(GL_RENDERBUFFER, kInvalidClientId);
 557   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd4));
 558   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 559 }
 560
 561 TEST_P(GLES2DecoderTest, EnableFeatureCHROMIUMBadBucket) {
 562   const uint32 kBadBucketId = 123;
 563   EnableFeatureCHROMIUM cmd;
 564   cmd.Init(kBadBucketId, shared_memory_id_, shared_memory_offset_);
 565   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 566 }
 567
 568 TEST_P(GLES2DecoderTest, RequestExtensionCHROMIUMBadBucket) {
 569   const uint32 kBadBucketId = 123;
 570   RequestExtensionCHROMIUM cmd;
 571   cmd.Init(kBadBucketId);
 572   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 573 }
 574
 575 TEST_P(GLES2DecoderTest, BeginQueryEXTDisabled) {
 576   // Test something fails if off.
 577 }
 578
 579 TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXT) {
 580   InitState init;
 581   init.extensions = "GL_EXT_occlusion_query_boolean";
 582   init.gl_version = "opengl es 2.0";
 583   init.has_alpha = true;
 584   init.request_alpha = true;
 585   init.bind_generates_resource = true;
 586   InitDecoder(init);
 587
 588   // Test end fails if no begin.
 589   EndQueryEXT end_cmd;
 590   end_cmd.Init(GL_ANY_SAMPLES_PASSED_EXT, 1);
 591   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
 592   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 593
 594   BeginQueryEXT begin_cmd;
 595
 596   // Test id = 0 fails.
 597   begin_cmd.Init(
 598       GL_ANY_SAMPLES_PASSED_EXT, 0, kSharedMemoryId, kSharedMemoryOffset);
 599   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
 600   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 601
 602   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
 603
 604   // Test valid parameters work.
 605   EXPECT_CALL(*gl_, GenQueriesARB(1, _))
 606       .WillOnce(SetArgumentPointee<1>(kNewServiceId))
 607       .RetiresOnSaturation();
 608   EXPECT_CALL(*gl_, BeginQueryARB(GL_ANY_SAMPLES_PASSED_EXT, kNewServiceId))
 609       .Times(1)
 610       .RetiresOnSaturation();
 611
 612   // Query object should not be created untill BeginQueriesEXT.
 613   QueryManager* query_manager = decoder_->GetQueryManager();
 614   ASSERT_TRUE(query_manager != NULL);
 615   QueryManager::Query* query = query_manager->GetQuery(kNewClientId);
 616   EXPECT_TRUE(query == NULL);
 617
 618   // BeginQueryEXT should fail  if id is not generated from GenQueriesEXT.
 619   begin_cmd.Init(GL_ANY_SAMPLES_PASSED_EXT,
 620                  kInvalidClientId,
 621                  kSharedMemoryId,
 622                  kSharedMemoryOffset);
 623   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
 624   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 625
 626   begin_cmd.Init(GL_ANY_SAMPLES_PASSED_EXT,
 627                  kNewClientId,
 628                  kSharedMemoryId,
 629                  kSharedMemoryOffset);
 630   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
 631   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 632
 633   // After BeginQueriesEXT id name should have query object associated with it.
 634   query = query_manager->GetQuery(kNewClientId);
 635   ASSERT_TRUE(query != NULL);
 636   EXPECT_FALSE(query->pending());
 637
 638   // Test trying begin again fails
 639   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
 640   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 641
 642   // Test end fails with different target
 643   end_cmd.Init(GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT, 1);
 644   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
 645   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 646
 647   // Test end succeeds
 648   EXPECT_CALL(*gl_, EndQueryARB(GL_ANY_SAMPLES_PASSED_EXT))
 649       .Times(1)
 650       .RetiresOnSaturation();
 651   end_cmd.Init(GL_ANY_SAMPLES_PASSED_EXT, 1);
 652   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
 653   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 654   EXPECT_TRUE(query->pending());
 655
 656   EXPECT_CALL(*gl_, DeleteQueriesARB(1, _)).Times(1).RetiresOnSaturation();
 657 }
 658
 659 struct QueryType {
 660   GLenum type;
 661   bool is_gl;
 662 };
 663
 664 const QueryType kQueryTypes[] = {
 665     {GL_COMMANDS_ISSUED_CHROMIUM, false},
 666     {GL_LATENCY_QUERY_CHROMIUM, false},
 667     {GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM, false},
 668     {GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, false},
 669     {GL_GET_ERROR_QUERY_CHROMIUM, false},
 670     {GL_COMMANDS_COMPLETED_CHROMIUM, false},
 671     {GL_ANY_SAMPLES_PASSED_EXT, true},
 672 };
 673
 674 static void CheckBeginEndQueryBadMemoryFails(GLES2DecoderTestBase* test,
 675                                              GLuint client_id,
 676                                              GLuint service_id,
 677                                              const QueryType& query_type,
 678                                              int32 shm_id,
 679                                              uint32 shm_offset) {
 680   // We need to reset the decoder on each iteration, because we lose the
 681   // context every time.
 682   GLES2DecoderTestBase::InitState init;
 683   init.extensions = "GL_EXT_occlusion_query_boolean GL_ARB_sync";
 684   init.gl_version = "opengl es 2.0";
 685   init.has_alpha = true;
 686   init.request_alpha = true;
 687   init.bind_generates_resource = true;
 688   test->InitDecoder(init);
 689   ::testing::StrictMock< ::gfx::MockGLInterface>* gl = test->GetGLMock();
 690
 691   BeginQueryEXT begin_cmd;
 692
 693   test->GenHelper<GenQueriesEXTImmediate>(client_id);
 694
 695   if (query_type.is_gl) {
 696     EXPECT_CALL(*gl, GenQueriesARB(1, _))
 697         .WillOnce(SetArgumentPointee<1>(service_id))
 698         .RetiresOnSaturation();
 699     EXPECT_CALL(*gl, BeginQueryARB(query_type.type, service_id))
 700         .Times(1)
 701         .RetiresOnSaturation();
 702   }
 703
 704   // Test bad shared memory fails
 705   begin_cmd.Init(query_type.type, client_id, shm_id, shm_offset);
 706   error::Error error1 = test->ExecuteCmd(begin_cmd);
 707
 708   if (query_type.is_gl) {
 709     EXPECT_CALL(*gl, EndQueryARB(query_type.type))
 710         .Times(1)
 711         .RetiresOnSaturation();
 712   }
 713   if (query_type.type == GL_GET_ERROR_QUERY_CHROMIUM) {
 714     EXPECT_CALL(*gl, GetError())
 715         .WillOnce(Return(GL_NO_ERROR))
 716         .RetiresOnSaturation();
 717   }
 718   GLsync kGlSync = reinterpret_cast<GLsync>(0xdeadbeef);
 719   if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
 720     EXPECT_CALL(*gl, Flush()).RetiresOnSaturation();
 721     EXPECT_CALL(*gl, FenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0))
 722         .WillOnce(Return(kGlSync))
 723         .RetiresOnSaturation();
 724 #if DCHECK_IS_ON
 725     EXPECT_CALL(*gl, IsSync(kGlSync))
 726         .WillOnce(Return(GL_TRUE))
 727         .RetiresOnSaturation();
 728 #endif
 729   }
 730
 731   EndQueryEXT end_cmd;
 732   end_cmd.Init(query_type.type, 1);
 733   error::Error error2 = test->ExecuteCmd(end_cmd);
 734
 735   if (query_type.is_gl) {
 736     EXPECT_CALL(
 737         *gl, GetQueryObjectuivARB(service_id, GL_QUERY_RESULT_AVAILABLE_EXT, _))
 738         .WillOnce(SetArgumentPointee<2>(1))
 739         .RetiresOnSaturation();
 740     EXPECT_CALL(*gl, GetQueryObjectuivARB(service_id, GL_QUERY_RESULT_EXT, _))
 741         .WillOnce(SetArgumentPointee<2>(1))
 742         .RetiresOnSaturation();
 743   }
 744   if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
 745 #if DCHECK_IS_ON
 746     EXPECT_CALL(*gl, IsSync(kGlSync))
 747         .WillOnce(Return(GL_TRUE))
 748         .RetiresOnSaturation();
 749 #endif
 750     EXPECT_CALL(*gl, ClientWaitSync(kGlSync, _, _))
 751         .WillOnce(Return(GL_ALREADY_SIGNALED))
 752         .RetiresOnSaturation();
 753   }
 754
 755   QueryManager* query_manager = test->GetDecoder()->GetQueryManager();
 756   ASSERT_TRUE(query_manager != NULL);
 757   bool process_success = query_manager->ProcessPendingQueries();
 758
 759   EXPECT_TRUE(error1 != error::kNoError || error2 != error::kNoError ||
 760               !process_success);
 761
 762   if (query_type.is_gl) {
 763     EXPECT_CALL(*gl, DeleteQueriesARB(1, _)).Times(1).RetiresOnSaturation();
 764   }
 765   if (query_type.type == GL_COMMANDS_COMPLETED_CHROMIUM) {
 766 #if DCHECK_IS_ON
 767     EXPECT_CALL(*gl, IsSync(kGlSync))
 768         .WillOnce(Return(GL_TRUE))
 769         .RetiresOnSaturation();
 770 #endif
 771     EXPECT_CALL(*gl, DeleteSync(kGlSync)).Times(1).RetiresOnSaturation();
 772   }
 773   test->ResetDecoder();
 774 }
 775
 776 TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryIdFails) {
 777   for (size_t i = 0; i < arraysize(kQueryTypes); ++i) {
 778     CheckBeginEndQueryBadMemoryFails(this,
 779                                      kNewClientId,
 780                                      kNewServiceId,
 781                                      kQueryTypes[i],
 782                                      kInvalidSharedMemoryId,
 783                                      kSharedMemoryOffset);
 784   }
 785 }
 786
 787 TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTBadMemoryOffsetFails) {
 788   for (size_t i = 0; i < arraysize(kQueryTypes); ++i) {
 789     // Out-of-bounds.
 790     CheckBeginEndQueryBadMemoryFails(this,
 791                                      kNewClientId,
 792                                      kNewServiceId,
 793                                      kQueryTypes[i],
 794                                      kSharedMemoryId,
 795                                      kInvalidSharedMemoryOffset);
 796     // Overflow.
 797     CheckBeginEndQueryBadMemoryFails(this,
 798                                      kNewClientId,
 799                                      kNewServiceId,
 800                                      kQueryTypes[i],
 801                                      kSharedMemoryId,
 802                                      0xfffffffcu);
 803   }
 804 }
 805
 806 TEST_P(GLES2DecoderTest, BeginEndQueryEXTCommandsIssuedCHROMIUM) {
 807   BeginQueryEXT begin_cmd;
 808
 809   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
 810
 811   // Test valid parameters work.
 812   begin_cmd.Init(GL_COMMANDS_ISSUED_CHROMIUM,
 813                  kNewClientId,
 814                  kSharedMemoryId,
 815                  kSharedMemoryOffset);
 816   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
 817   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 818
 819   QueryManager* query_manager = decoder_->GetQueryManager();
 820   ASSERT_TRUE(query_manager != NULL);
 821   QueryManager::Query* query = query_manager->GetQuery(kNewClientId);
 822   ASSERT_TRUE(query != NULL);
 823   EXPECT_FALSE(query->pending());
 824
 825   // Test end succeeds
 826   EndQueryEXT end_cmd;
 827   end_cmd.Init(GL_COMMANDS_ISSUED_CHROMIUM, 1);
 828   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
 829   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 830   EXPECT_FALSE(query->pending());
 831 }
 832
 833 TEST_P(GLES2DecoderTest, BeginEndQueryEXTGetErrorQueryCHROMIUM) {
 834   BeginQueryEXT begin_cmd;
 835
 836   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
 837
 838   // Test valid parameters work.
 839   begin_cmd.Init(GL_GET_ERROR_QUERY_CHROMIUM,
 840                  kNewClientId,
 841                  kSharedMemoryId,
 842                  kSharedMemoryOffset);
 843   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
 844   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 845
 846   QueryManager* query_manager = decoder_->GetQueryManager();
 847   ASSERT_TRUE(query_manager != NULL);
 848   QueryManager::Query* query = query_manager->GetQuery(kNewClientId);
 849   ASSERT_TRUE(query != NULL);
 850   EXPECT_FALSE(query->pending());
 851
 852   // Test end succeeds
 853   QuerySync* sync = static_cast<QuerySync*>(shared_memory_address_);
 854
 855   EXPECT_CALL(*gl_, GetError())
 856       .WillOnce(Return(GL_INVALID_VALUE))
 857       .RetiresOnSaturation();
 858
 859   EndQueryEXT end_cmd;
 860   end_cmd.Init(GL_GET_ERROR_QUERY_CHROMIUM, 1);
 861   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
 862   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 863   EXPECT_FALSE(query->pending());
 864   EXPECT_EQ(static_cast<GLenum>(GL_INVALID_VALUE),
 865             static_cast<GLenum>(sync->result));
 866 }
 867
 868 TEST_P(GLES2DecoderManualInitTest, BeginEndQueryEXTCommandsCompletedCHROMIUM) {
 869   InitState init;
 870   init.extensions = "GL_EXT_occlusion_query_boolean GL_ARB_sync";
 871   init.gl_version = "opengl es 2.0";
 872   init.has_alpha = true;
 873   init.request_alpha = true;
 874   init.bind_generates_resource = true;
 875   InitDecoder(init);
 876
 877   GenHelper<GenQueriesEXTImmediate>(kNewClientId);
 878
 879   BeginQueryEXT begin_cmd;
 880   begin_cmd.Init(GL_COMMANDS_COMPLETED_CHROMIUM,
 881                  kNewClientId,
 882                  kSharedMemoryId,
 883                  kSharedMemoryOffset);
 884   EXPECT_EQ(error::kNoError, ExecuteCmd(begin_cmd));
 885   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 886
 887   QueryManager* query_manager = decoder_->GetQueryManager();
 888   ASSERT_TRUE(query_manager != NULL);
 889   QueryManager::Query* query = query_manager->GetQuery(kNewClientId);
 890   ASSERT_TRUE(query != NULL);
 891   EXPECT_FALSE(query->pending());
 892
 893   GLsync kGlSync = reinterpret_cast<GLsync>(0xdeadbeef);
 894   EXPECT_CALL(*gl_, Flush()).RetiresOnSaturation();
 895   EXPECT_CALL(*gl_, FenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0))
 896       .WillOnce(Return(kGlSync))
 897       .RetiresOnSaturation();
 898 #if DCHECK_IS_ON
 899   EXPECT_CALL(*gl_, IsSync(kGlSync))
 900       .WillOnce(Return(GL_TRUE))
 901       .RetiresOnSaturation();
 902 #endif
 903
 904   EndQueryEXT end_cmd;
 905   end_cmd.Init(GL_COMMANDS_COMPLETED_CHROMIUM, 1);
 906   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
 907   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 908   EXPECT_TRUE(query->pending());
 909
 910 #if DCHECK_IS_ON
 911   EXPECT_CALL(*gl_, IsSync(kGlSync))
 912       .WillOnce(Return(GL_TRUE))
 913       .RetiresOnSaturation();
 914 #endif
 915   EXPECT_CALL(*gl_, ClientWaitSync(kGlSync, _, _))
 916       .WillOnce(Return(GL_TIMEOUT_EXPIRED))
 917       .RetiresOnSaturation();
 918   bool process_success = query_manager->ProcessPendingQueries();
 919
 920   EXPECT_TRUE(process_success);
 921   EXPECT_TRUE(query->pending());
 922
 923 #if DCHECK_IS_ON
 924   EXPECT_CALL(*gl_, IsSync(kGlSync))
 925       .WillOnce(Return(GL_TRUE))
 926       .RetiresOnSaturation();
 927 #endif
 928   EXPECT_CALL(*gl_, ClientWaitSync(kGlSync, _, _))
 929       .WillOnce(Return(GL_ALREADY_SIGNALED))
 930       .RetiresOnSaturation();
 931   process_success = query_manager->ProcessPendingQueries();
 932
 933   EXPECT_TRUE(process_success);
 934   EXPECT_FALSE(query->pending());
 935   QuerySync* sync = static_cast<QuerySync*>(shared_memory_address_);
 936   EXPECT_EQ(static_cast<GLenum>(0), static_cast<GLenum>(sync->result));
 937
 938 #if DCHECK_IS_ON
 939   EXPECT_CALL(*gl_, IsSync(kGlSync))
 940       .WillOnce(Return(GL_TRUE))
 941       .RetiresOnSaturation();
 942 #endif
 943   EXPECT_CALL(*gl_, DeleteSync(kGlSync)).Times(1).RetiresOnSaturation();
 944   ResetDecoder();
 945 }
 946
 947 TEST_P(GLES2DecoderTest, IsEnabledReturnsCachedValue) {
 948   // NOTE: There are no expectations because no GL functions should be
 949   // called for DEPTH_TEST or STENCIL_TEST
 950   static const GLenum kStates[] = {
 951       GL_DEPTH_TEST, GL_STENCIL_TEST,
 952   };
 953   for (size_t ii = 0; ii < arraysize(kStates); ++ii) {
 954     Enable enable_cmd;
 955     GLenum state = kStates[ii];
 956     enable_cmd.Init(state);
 957     EXPECT_EQ(error::kNoError, ExecuteCmd(enable_cmd));
 958     IsEnabled::Result* result =
 959         static_cast<IsEnabled::Result*>(shared_memory_address_);
 960     IsEnabled is_enabled_cmd;
 961     is_enabled_cmd.Init(state, shared_memory_id_, shared_memory_offset_);
 962     EXPECT_EQ(error::kNoError, ExecuteCmd(is_enabled_cmd));
 963     EXPECT_NE(0u, *result);
 964     Disable disable_cmd;
 965     disable_cmd.Init(state);
 966     EXPECT_EQ(error::kNoError, ExecuteCmd(disable_cmd));
 967     EXPECT_EQ(error::kNoError, ExecuteCmd(is_enabled_cmd));
 968     EXPECT_EQ(0u, *result);
 969   }
 970 }
 971
 972 TEST_P(GLES2DecoderManualInitTest, GpuMemoryManagerCHROMIUM) {
 973   InitState init;
 974   init.extensions = "GL_ARB_texture_rectangle";
 975   init.gl_version = "3.0";
 976   init.bind_generates_resource = true;
 977   InitDecoder(init);
 978
 979   Texture* texture = GetTexture(client_texture_id_)->texture();
 980   EXPECT_TRUE(texture != NULL);
 981   EXPECT_TRUE(texture->pool() == GL_TEXTURE_POOL_UNMANAGED_CHROMIUM);
 982
 983   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 984
 985   TexParameteri cmd;
 986   cmd.Init(GL_TEXTURE_2D,
 987            GL_TEXTURE_POOL_CHROMIUM,
 988            GL_TEXTURE_POOL_UNMANAGED_CHROMIUM);
 989   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 990   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 991
 992   cmd.Init(GL_TEXTURE_2D,
 993            GL_TEXTURE_POOL_CHROMIUM,
 994            GL_TEXTURE_POOL_MANAGED_CHROMIUM);
 995   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 996   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 997
 998   EXPECT_TRUE(texture->pool() == GL_TEXTURE_POOL_MANAGED_CHROMIUM);
 999
1000   cmd.Init(GL_TEXTURE_2D, GL_TEXTURE_POOL_CHROMIUM, GL_NONE);
1001   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1002   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1003 }
1004
1005 namespace {
1006
1007 class SizeOnlyMemoryTracker : public MemoryTracker {
1008  public:
1009   SizeOnlyMemoryTracker() {
1010     // These are the default textures. 1 for TEXTURE_2D and 6 faces for
1011     // TEXTURE_CUBE_MAP.
1012     const size_t kInitialUnmanagedPoolSize = 7 * 4;
1013     const size_t kInitialManagedPoolSize = 0;
1014     pool_infos_[MemoryTracker::kUnmanaged].initial_size =
1015         kInitialUnmanagedPoolSize;
1016     pool_infos_[MemoryTracker::kManaged].initial_size = kInitialManagedPoolSize;
1017   }
1018
1019   // Ensure a certain amount of GPU memory is free. Returns true on success.
1020   MOCK_METHOD1(EnsureGPUMemoryAvailable, bool(size_t size_needed));
1021
1022   virtual void TrackMemoryAllocatedChange(size_t old_size,
1023                                           size_t new_size,
1024                                           Pool pool) {
1025     PoolInfo& info = pool_infos_[pool];
1026     info.size += new_size - old_size;
1027   }
1028
1029   size_t GetPoolSize(Pool pool) {
1030     const PoolInfo& info = pool_infos_[pool];
1031     return info.size - info.initial_size;
1032   }
1033
1034  private:
1035   virtual ~SizeOnlyMemoryTracker() {}
1036   struct PoolInfo {
1037     PoolInfo() : initial_size(0), size(0) {}
1038     size_t initial_size;
1039     size_t size;
1040   };
1041   std::map<Pool, PoolInfo> pool_infos_;
1042 };
1043
1044 }  // anonymous namespace.
1045
1046 TEST_P(GLES2DecoderManualInitTest, MemoryTrackerInitialSize) {
1047   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
1048       new SizeOnlyMemoryTracker();
1049   set_memory_tracker(memory_tracker.get());
1050   InitState init;
1051   init.gl_version = "3.0";
1052   init.bind_generates_resource = true;
1053   InitDecoder(init);
1054   // Expect that initial size - size is 0.
1055   EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
1056   EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kManaged));
1057 }
1058
1059 TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexImage2D) {
1060   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
1061       new SizeOnlyMemoryTracker();
1062   set_memory_tracker(memory_tracker.get());
1063   InitState init;
1064   init.gl_version = "3.0";
1065   init.bind_generates_resource = true;
1066   InitDecoder(init);
1067   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1068   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
1069       .WillOnce(Return(true))
1070       .RetiresOnSaturation();
1071   DoTexImage2D(GL_TEXTURE_2D,
1072                0,
1073                GL_RGBA,
1074                8,
1075                4,
1076                0,
1077                GL_RGBA,
1078                GL_UNSIGNED_BYTE,
1079                kSharedMemoryId,
1080                kSharedMemoryOffset);
1081   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
1082   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(64))
1083       .WillOnce(Return(true))
1084       .RetiresOnSaturation();
1085   DoTexImage2D(GL_TEXTURE_2D,
1086                0,
1087                GL_RGBA,
1088                4,
1089                4,
1090                0,
1091                GL_RGBA,
1092                GL_UNSIGNED_BYTE,
1093                kSharedMemoryId,
1094                kSharedMemoryOffset);
1095   EXPECT_EQ(64u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
1096   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1097   // Check we get out of memory and no call to glTexImage2D if Ensure fails.
1098   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(64))
1099       .WillOnce(Return(false))
1100       .RetiresOnSaturation();
1101   TexImage2D cmd;
1102   cmd.Init(GL_TEXTURE_2D,
1103            0,
1104            GL_RGBA,
1105            4,
1106            4,
1107            GL_RGBA,
1108            GL_UNSIGNED_BYTE,
1109            kSharedMemoryId,
1110            kSharedMemoryOffset);
1111   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1112   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
1113   EXPECT_EQ(64u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
1114 }
1115
1116 TEST_P(GLES2DecoderManualInitTest, MemoryTrackerTexStorage2DEXT) {
1117   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
1118       new SizeOnlyMemoryTracker();
1119   set_memory_tracker(memory_tracker.get());
1120   InitState init;
1121   init.gl_version = "3.0";
1122   init.bind_generates_resource = true;
1123   InitDecoder(init);
1124   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1125   // Check we get out of memory and no call to glTexStorage2DEXT
1126   // if Ensure fails.
1127   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
1128       .WillOnce(Return(false))
1129       .RetiresOnSaturation();
1130   TexStorage2DEXT cmd;
1131   cmd.Init(GL_TEXTURE_2D, 1, GL_RGBA8, 8, 4);
1132   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1133   EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
1134   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
1135 }
1136
1137 TEST_P(GLES2DecoderManualInitTest, MemoryTrackerCopyTexImage2D) {
1138   GLenum target = GL_TEXTURE_2D;
1139   GLint level = 0;
1140   GLenum internal_format = GL_RGBA;
1141   GLsizei width = 4;
1142   GLsizei height = 8;
1143   GLint border = 0;
1144   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
1145       new SizeOnlyMemoryTracker();
1146   set_memory_tracker(memory_tracker.get());
1147   InitState init;
1148   init.gl_version = "3.0";
1149   init.has_alpha = true;
1150   init.request_alpha = true;
1151   init.bind_generates_resource = true;
1152   InitDecoder(init);
1153   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1154   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
1155       .WillOnce(Return(true))
1156       .RetiresOnSaturation();
1157   EXPECT_CALL(*gl_, GetError())
1158       .WillOnce(Return(GL_NO_ERROR))
1159       .WillOnce(Return(GL_NO_ERROR))
1160       .RetiresOnSaturation();
1161   EXPECT_CALL(*gl_,
1162               CopyTexImage2D(
1163                   target, level, internal_format, 0, 0, width, height, border))
1164       .Times(1)
1165       .RetiresOnSaturation();
1166   CopyTexImage2D cmd;
1167   cmd.Init(target, level, internal_format, 0, 0, width, height);
1168   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1169   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
1170   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1171   // Check we get out of memory and no call to glCopyTexImage2D if Ensure fails.
1172   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
1173       .WillOnce(Return(false))
1174       .RetiresOnSaturation();
1175   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1176   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
1177   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
1178 }
1179
1180 TEST_P(GLES2DecoderManualInitTest, MemoryTrackerRenderbufferStorage) {
1181   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
1182       new SizeOnlyMemoryTracker();
1183   set_memory_tracker(memory_tracker.get());
1184   InitState init;
1185   init.gl_version = "3.0";
1186   init.bind_generates_resource = true;
1187   InitDecoder(init);
1188   DoBindRenderbuffer(
1189       GL_RENDERBUFFER, client_renderbuffer_id_, kServiceRenderbufferId);
1190   EnsureRenderbufferBound(false);
1191   EXPECT_CALL(*gl_, GetError())
1192       .WillOnce(Return(GL_NO_ERROR))
1193       .WillOnce(Return(GL_NO_ERROR))
1194       .RetiresOnSaturation();
1195   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
1196       .WillOnce(Return(true))
1197       .RetiresOnSaturation();
1198   EXPECT_CALL(*gl_, RenderbufferStorageEXT(GL_RENDERBUFFER, GL_RGBA, 8, 4))
1199       .Times(1)
1200       .RetiresOnSaturation();
1201   RenderbufferStorage cmd;
1202   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 8, 4);
1203   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1204   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1205   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
1206   // Check we get out of memory and no call to glRenderbufferStorage if Ensure
1207   // fails.
1208   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
1209       .WillOnce(Return(false))
1210       .RetiresOnSaturation();
1211   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1212   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
1213   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
1214 }
1215
1216 TEST_P(GLES2DecoderManualInitTest, MemoryTrackerBufferData) {
1217   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
1218       new SizeOnlyMemoryTracker();
1219   set_memory_tracker(memory_tracker.get());
1220   InitState init;
1221   init.gl_version = "3.0";
1222   init.bind_generates_resource = true;
1223   InitDecoder(init);
1224   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_, kServiceBufferId);
1225   EXPECT_CALL(*gl_, GetError())
1226       .WillOnce(Return(GL_NO_ERROR))
1227       .WillOnce(Return(GL_NO_ERROR))
1228       .RetiresOnSaturation();
1229   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
1230       .WillOnce(Return(true))
1231       .RetiresOnSaturation();
1232   EXPECT_CALL(*gl_, BufferData(GL_ARRAY_BUFFER, 128, _, GL_STREAM_DRAW))
1233       .Times(1)
1234       .RetiresOnSaturation();
1235   BufferData cmd;
1236   cmd.Init(GL_ARRAY_BUFFER, 128, 0, 0, GL_STREAM_DRAW);
1237   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1238   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1239   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kManaged));
1240   // Check we get out of memory and no call to glBufferData if Ensure
1241   // fails.
1242   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
1243       .WillOnce(Return(false))
1244       .RetiresOnSaturation();
1245   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1246   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
1247   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kManaged));
1248 }
1249
1250 TEST_P(GLES2DecoderManualInitTest, ImmutableCopyTexImage2D) {
1251   const GLenum kTarget = GL_TEXTURE_2D;
1252   const GLint kLevel = 0;
1253   const GLenum kInternalFormat = GL_RGBA;
1254   const GLenum kSizedInternalFormat = GL_RGBA8;
1255   const GLsizei kWidth = 4;
1256   const GLsizei kHeight = 8;
1257   const GLint kBorder = 0;
1258   InitState init;
1259   init.extensions = "GL_EXT_texture_storage";
1260   init.gl_version = "3.0";
1261   init.has_alpha = true;
1262   init.request_alpha = true;
1263   init.bind_generates_resource = true;
1264   InitDecoder(init);
1265   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
1266
1267   // CopyTexImage2D will call arbitrary amount of GetErrors.
1268   EXPECT_CALL(*gl_, GetError())
1269       .Times(AtLeast(1));
1270
1271   EXPECT_CALL(*gl_,
1272               CopyTexImage2D(
1273                   kTarget, kLevel, kInternalFormat, 0, 0, kWidth, kHeight,
1274                   kBorder))
1275       .Times(1);
1276
1277   EXPECT_CALL(*gl_,
1278               TexStorage2DEXT(
1279                   kTarget, kLevel, kSizedInternalFormat, kWidth, kHeight))
1280       .Times(1);
1281   CopyTexImage2D copy_cmd;
1282   copy_cmd.Init(kTarget, kLevel, kInternalFormat, 0, 0, kWidth, kHeight);
1283   EXPECT_EQ(error::kNoError, ExecuteCmd(copy_cmd));
1284   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1285
1286   TexStorage2DEXT storage_cmd;
1287   storage_cmd.Init(kTarget, kLevel, kSizedInternalFormat, kWidth, kHeight);
1288   EXPECT_EQ(error::kNoError, ExecuteCmd(storage_cmd));
1289   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1290
1291   // This should not invoke CopyTexImage2D.
1292   copy_cmd.Init(kTarget, kLevel, kInternalFormat, 0, 0, kWidth, kHeight);
1293   EXPECT_EQ(error::kNoError, ExecuteCmd(copy_cmd));
1294   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1295 }
1296
1297 TEST_P(GLES2DecoderTest, LoseContextCHROMIUMValidArgs) {
1298   EXPECT_CALL(*mock_decoder_, LoseContext(GL_GUILTY_CONTEXT_RESET_ARB))
1299       .Times(1);
1300   cmds::LoseContextCHROMIUM cmd;
1301   cmd.Init(GL_GUILTY_CONTEXT_RESET_ARB, GL_GUILTY_CONTEXT_RESET_ARB);
1302   EXPECT_EQ(error::kLostContext, ExecuteCmd(cmd));
1303   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1304 }
1305
1306 TEST_P(GLES2DecoderTest, LoseContextCHROMIUMInvalidArgs0_0) {
1307   EXPECT_CALL(*mock_decoder_, LoseContext(_))
1308       .Times(0);
1309   cmds::LoseContextCHROMIUM cmd;
1310   cmd.Init(GL_NONE, GL_GUILTY_CONTEXT_RESET_ARB);
1311   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1312   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1313 }
1314
1315 TEST_P(GLES2DecoderTest, LoseContextCHROMIUMInvalidArgs1_0) {
1316   EXPECT_CALL(*mock_decoder_, LoseContext(_))
1317       .Times(0);
1318   cmds::LoseContextCHROMIUM cmd;
1319   cmd.Init(GL_GUILTY_CONTEXT_RESET_ARB, GL_NONE);
1320   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1321   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
1322 }
1323
1324 class GLES2DecoderDoCommandsTest : public GLES2DecoderTest {
1325  public:
1326   GLES2DecoderDoCommandsTest() {
1327     for (int i = 0; i < 3; i++) {
1328       cmds_[i].Init(GL_BLEND);
1329     }
1330     entries_per_cmd_ = ComputeNumEntries(cmds_[0].ComputeSize());
1331   }
1332
1333   void SetExpectationsForNCommands(int num_commands) {
1334     for (int i = 0; i < num_commands; i++)
1335       SetupExpectationsForEnableDisable(GL_BLEND, true);
1336   }
1337
1338  protected:
1339   Enable cmds_[3];
1340   int entries_per_cmd_;
1341 };
1342
1343 // Test that processing with 0 entries does nothing.
1344 TEST_P(GLES2DecoderDoCommandsTest, DoCommandsOneOfZero) {
1345   int num_processed = -1;
1346   SetExpectationsForNCommands(0);
1347   EXPECT_EQ(
1348       error::kNoError,
1349       decoder_->DoCommands(1, &cmds_, entries_per_cmd_ * 0, &num_processed));
1350   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1351   EXPECT_EQ(0, num_processed);
1352 }
1353
1354 // Test processing at granularity of single commands.
1355 TEST_P(GLES2DecoderDoCommandsTest, DoCommandsOneOfOne) {
1356   int num_processed = -1;
1357   SetExpectationsForNCommands(1);
1358   EXPECT_EQ(
1359       error::kNoError,
1360       decoder_->DoCommands(1, &cmds_, entries_per_cmd_ * 1, &num_processed));
1361   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1362   EXPECT_EQ(entries_per_cmd_, num_processed);
1363 }
1364
1365 // Test processing at granularity of multiple commands.
1366 TEST_P(GLES2DecoderDoCommandsTest, DoCommandsThreeOfThree) {
1367   int num_processed = -1;
1368   SetExpectationsForNCommands(3);
1369   EXPECT_EQ(
1370       error::kNoError,
1371       decoder_->DoCommands(3, &cmds_, entries_per_cmd_ * 3, &num_processed));
1372   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1373   EXPECT_EQ(entries_per_cmd_ * 3, num_processed);
1374 }
1375
1376 // Test processing a request smaller than available entries.
1377 TEST_P(GLES2DecoderDoCommandsTest, DoCommandsTwoOfThree) {
1378   int num_processed = -1;
1379   SetExpectationsForNCommands(2);
1380   EXPECT_EQ(
1381       error::kNoError,
1382       decoder_->DoCommands(2, &cmds_, entries_per_cmd_ * 3, &num_processed));
1383   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1384   EXPECT_EQ(entries_per_cmd_ * 2, num_processed);
1385 }
1386
1387 // Test that processing stops on a command with size 0.
1388 TEST_P(GLES2DecoderDoCommandsTest, DoCommandsZeroCmdSize) {
1389   cmds_[1].header.size = 0;
1390   int num_processed = -1;
1391   SetExpectationsForNCommands(1);
1392   EXPECT_EQ(
1393       error::kInvalidSize,
1394       decoder_->DoCommands(2, &cmds_, entries_per_cmd_ * 2, &num_processed));
1395   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1396   EXPECT_EQ(entries_per_cmd_, num_processed);
1397 }
1398
1399 // Test that processing stops on a command with size greater than available.
1400 TEST_P(GLES2DecoderDoCommandsTest, DoCommandsOutOfBounds) {
1401   int num_processed = -1;
1402   SetExpectationsForNCommands(1);
1403   EXPECT_EQ(error::kOutOfBounds,
1404             decoder_->DoCommands(
1405                 2, &cmds_, entries_per_cmd_ * 2 - 1, &num_processed));
1406   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1407   EXPECT_EQ(entries_per_cmd_, num_processed);
1408 }
1409
1410 // Test that commands with bad argument size are skipped without processing.
1411 TEST_P(GLES2DecoderDoCommandsTest, DoCommandsBadArgSize) {
1412   cmds_[1].header.size += 1;
1413   int num_processed = -1;
1414   SetExpectationsForNCommands(1);
1415   EXPECT_EQ(error::kInvalidArguments,
1416             decoder_->DoCommands(
1417                 2, &cmds_, entries_per_cmd_ * 2 + 1, &num_processed));
1418   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1419   EXPECT_EQ(entries_per_cmd_ + cmds_[1].header.size, num_processed);
1420 }
1421
1422 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderTest, ::testing::Bool());
1423
1424 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderWithShaderTest, ::testing::Bool());
1425
1426 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderManualInitTest, ::testing::Bool());
1427
1428 INSTANTIATE_TEST_CASE_P(Service,
1429                         GLES2DecoderRGBBackbufferTest,
1430                         ::testing::Bool());
1431
1432 INSTANTIATE_TEST_CASE_P(Service, GLES2DecoderDoCommandsTest, ::testing::Bool());
1433
1434 }  // namespace gles2
1435 }  // namespace gpu