gpu/command_buffer/service/gles2_cmd_decoder_unittest_programs.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
   6
   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/service/async_pixel_transfer_delegate_mock.h"
  12 #include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
  13 #include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
  14 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
  15 #include "gpu/command_buffer/service/context_group.h"
  16 #include "gpu/command_buffer/service/context_state.h"
  17 #include "gpu/command_buffer/service/gl_surface_mock.h"
  18 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
  19 #include "gpu/command_buffer/service/image_manager.h"
  20 #include "gpu/command_buffer/service/mailbox_manager.h"
  21 #include "gpu/command_buffer/service/mocks.h"
  22 #include "gpu/command_buffer/service/program_manager.h"
  23 #include "gpu/command_buffer/service/test_helper.h"
  24 #include "gpu/config/gpu_switches.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26 #include "ui/gl/gl_implementation.h"
  27 #include "ui/gl/gl_mock.h"
  28 #include "ui/gl/gl_surface_stub.h"
  29
  30 #if !defined(GL_DEPTH24_STENCIL8)
  31 #define GL_DEPTH24_STENCIL8 0x88F0
  32 #endif
  33
  34 using ::gfx::MockGLInterface;
  35 using ::testing::_;
  36 using ::testing::DoAll;
  37 using ::testing::InSequence;
  38 using ::testing::Invoke;
  39 using ::testing::MatcherCast;
  40 using ::testing::Mock;
  41 using ::testing::Pointee;
  42 using ::testing::Return;
  43 using ::testing::SaveArg;
  44 using ::testing::SetArrayArgument;
  45 using ::testing::SetArgPointee;
  46 using ::testing::StrEq;
  47 using ::testing::StrictMock;
  48
  49 namespace gpu {
  50 namespace gles2 {
  51
  52 using namespace cmds;
  53
  54 TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) {
  55   const uint32 kBucketId = 123;
  56   GetProgramInfoCHROMIUM cmd;
  57   cmd.Init(client_program_id_, kBucketId);
  58   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  59   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
  60   EXPECT_GT(bucket->size(), 0u);
  61 }
  62
  63 TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMInvalidArgs) {
  64   const uint32 kBucketId = 123;
  65   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
  66   EXPECT_TRUE(bucket == NULL);
  67   GetProgramInfoCHROMIUM cmd;
  68   cmd.Init(kInvalidClientId, kBucketId);
  69   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  70   EXPECT_EQ(GL_NO_ERROR, GetGLError());
  71   bucket = decoder_->GetBucket(kBucketId);
  72   ASSERT_TRUE(bucket != NULL);
  73   EXPECT_EQ(sizeof(ProgramInfoHeader), bucket->size());
  74   ProgramInfoHeader* info =
  75       bucket->GetDataAs<ProgramInfoHeader*>(0, sizeof(ProgramInfoHeader));
  76   ASSERT_TRUE(info != 0);
  77   EXPECT_EQ(0u, info->link_status);
  78   EXPECT_EQ(0u, info->num_attribs);
  79   EXPECT_EQ(0u, info->num_uniforms);
  80 }
  81
  82 TEST_P(GLES2DecoderWithShaderTest, GetUniformBlocksCHROMIUMValidArgs) {
  83   const uint32 kBucketId = 123;
  84   GetUniformBlocksCHROMIUM cmd;
  85   cmd.Init(client_program_id_, kBucketId);
  86   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
  87       .WillOnce(SetArgPointee<2>(GL_TRUE))
  88       .RetiresOnSaturation();
  89   EXPECT_CALL(*gl_,
  90               GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORM_BLOCKS, _))
  91       .WillOnce(SetArgPointee<2>(0))
  92       .RetiresOnSaturation();
  93   decoder_->set_unsafe_es3_apis_enabled(true);
  94   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  95   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
  96   EXPECT_EQ(sizeof(UniformBlocksHeader), bucket->size());
  97   UniformBlocksHeader* header =
  98       bucket->GetDataAs<UniformBlocksHeader*>(0, sizeof(UniformBlocksHeader));
  99   EXPECT_TRUE(header != NULL);
 100   EXPECT_EQ(0u, header->num_uniform_blocks);
 101   decoder_->set_unsafe_es3_apis_enabled(false);
 102   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 103 }
 104
 105 TEST_P(GLES2DecoderWithShaderTest, GetUniformBlocksCHROMIUMInvalidArgs) {
 106   const uint32 kBucketId = 123;
 107   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 108   EXPECT_TRUE(bucket == NULL);
 109   GetUniformBlocksCHROMIUM cmd;
 110   cmd.Init(kInvalidClientId, kBucketId);
 111   decoder_->set_unsafe_es3_apis_enabled(true);
 112   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 113   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 114   bucket = decoder_->GetBucket(kBucketId);
 115   ASSERT_TRUE(bucket != NULL);
 116   EXPECT_EQ(sizeof(UniformBlocksHeader), bucket->size());
 117   UniformBlocksHeader* header =
 118       bucket->GetDataAs<UniformBlocksHeader*>(0, sizeof(UniformBlocksHeader));
 119   ASSERT_TRUE(header != NULL);
 120   EXPECT_EQ(0u, header->num_uniform_blocks);
 121 }
 122
 123 TEST_P(GLES2DecoderWithShaderTest, GetUniformsES3CHROMIUMValidArgs) {
 124   const uint32 kBucketId = 123;
 125   GetUniformsES3CHROMIUM cmd;
 126   cmd.Init(client_program_id_, kBucketId);
 127   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
 128       .WillOnce(SetArgPointee<2>(GL_TRUE))
 129       .RetiresOnSaturation();
 130   EXPECT_CALL(*gl_,
 131               GetProgramiv(kServiceProgramId, GL_ACTIVE_UNIFORMS, _))
 132       .WillOnce(SetArgPointee<2>(0))
 133       .RetiresOnSaturation();
 134   decoder_->set_unsafe_es3_apis_enabled(true);
 135   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 136   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 137   EXPECT_EQ(sizeof(UniformsES3Header), bucket->size());
 138   UniformsES3Header* header =
 139       bucket->GetDataAs<UniformsES3Header*>(0, sizeof(UniformsES3Header));
 140   EXPECT_TRUE(header != NULL);
 141   EXPECT_EQ(0u, header->num_uniforms);
 142   decoder_->set_unsafe_es3_apis_enabled(false);
 143   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 144 }
 145
 146 TEST_P(GLES2DecoderWithShaderTest, GetUniformsES3CHROMIUMInvalidArgs) {
 147   const uint32 kBucketId = 123;
 148   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 149   EXPECT_TRUE(bucket == NULL);
 150   GetUniformsES3CHROMIUM cmd;
 151   cmd.Init(kInvalidClientId, kBucketId);
 152   decoder_->set_unsafe_es3_apis_enabled(true);
 153   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 154   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 155   bucket = decoder_->GetBucket(kBucketId);
 156   ASSERT_TRUE(bucket != NULL);
 157   EXPECT_EQ(sizeof(UniformsES3Header), bucket->size());
 158   UniformsES3Header* header =
 159       bucket->GetDataAs<UniformsES3Header*>(0, sizeof(UniformsES3Header));
 160   ASSERT_TRUE(header != NULL);
 161   EXPECT_EQ(0u, header->num_uniforms);
 162 }
 163
 164 TEST_P(GLES2DecoderWithShaderTest,
 165        GetTransformFeedbackVaryingsCHROMIUMValidArgs) {
 166   const uint32 kBucketId = 123;
 167   GetTransformFeedbackVaryingsCHROMIUM cmd;
 168   cmd.Init(client_program_id_, kBucketId);
 169   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
 170       .WillOnce(SetArgPointee<2>(GL_TRUE))
 171       .RetiresOnSaturation();
 172   EXPECT_CALL(*gl_,
 173               GetProgramiv(
 174                   kServiceProgramId, GL_TRANSFORM_FEEDBACK_VARYINGS, _))
 175       .WillOnce(SetArgPointee<2>(0))
 176       .RetiresOnSaturation();
 177   decoder_->set_unsafe_es3_apis_enabled(true);
 178   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 179   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 180   EXPECT_EQ(sizeof(TransformFeedbackVaryingsHeader), bucket->size());
 181   TransformFeedbackVaryingsHeader* header =
 182       bucket->GetDataAs<TransformFeedbackVaryingsHeader*>(
 183           0, sizeof(TransformFeedbackVaryingsHeader));
 184   EXPECT_TRUE(header != NULL);
 185   EXPECT_EQ(0u, header->num_transform_feedback_varyings);
 186   decoder_->set_unsafe_es3_apis_enabled(false);
 187   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 188 }
 189
 190 TEST_P(GLES2DecoderWithShaderTest,
 191        GetTransformFeedbackVaryingsCHROMIUMInvalidArgs) {
 192   const uint32 kBucketId = 123;
 193   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 194   EXPECT_TRUE(bucket == NULL);
 195   GetTransformFeedbackVaryingsCHROMIUM cmd;
 196   cmd.Init(kInvalidClientId, kBucketId);
 197   decoder_->set_unsafe_es3_apis_enabled(true);
 198   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 199   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 200   bucket = decoder_->GetBucket(kBucketId);
 201   ASSERT_TRUE(bucket != NULL);
 202   EXPECT_EQ(sizeof(TransformFeedbackVaryingsHeader), bucket->size());
 203   TransformFeedbackVaryingsHeader* header =
 204       bucket->GetDataAs<TransformFeedbackVaryingsHeader*>(
 205           0, sizeof(TransformFeedbackVaryingsHeader));
 206   ASSERT_TRUE(header != NULL);
 207   EXPECT_EQ(0u, header->num_transform_feedback_varyings);
 208 }
 209
 210 TEST_P(GLES2DecoderWithShaderTest, GetUniformivSucceeds) {
 211   GetUniformiv::Result* result =
 212       static_cast<GetUniformiv::Result*>(shared_memory_address_);
 213   result->size = 0;
 214   GetUniformiv cmd;
 215   cmd.Init(client_program_id_,
 216            kUniform2FakeLocation,
 217            kSharedMemoryId,
 218            kSharedMemoryOffset);
 219   EXPECT_CALL(*gl_, GetUniformiv(kServiceProgramId, kUniform2RealLocation, _))
 220       .Times(1);
 221   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 222   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
 223             result->size);
 224 }
 225
 226 TEST_P(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) {
 227   GetUniformiv::Result* result =
 228       static_cast<GetUniformiv::Result*>(shared_memory_address_);
 229   result->size = 0;
 230   GetUniformiv cmd;
 231   cmd.Init(client_program_id_,
 232            kUniform2ElementFakeLocation,
 233            kSharedMemoryId,
 234            kSharedMemoryOffset);
 235   EXPECT_CALL(*gl_,
 236               GetUniformiv(kServiceProgramId, kUniform2ElementRealLocation, _))
 237       .Times(1);
 238   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 239   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
 240             result->size);
 241 }
 242
 243 TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadProgramFails) {
 244   GetUniformiv::Result* result =
 245       static_cast<GetUniformiv::Result*>(shared_memory_address_);
 246   result->size = 0;
 247   GetUniformiv cmd;
 248   // non-existant program
 249   cmd.Init(kInvalidClientId,
 250            kUniform2FakeLocation,
 251            kSharedMemoryId,
 252            kSharedMemoryOffset);
 253   EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0);
 254   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 255   EXPECT_EQ(0U, result->size);
 256   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 257 // Valid id that is not a program. The GL spec requires a different error for
 258 // this case.
 259 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 260   result->size = kInitialResult;
 261   cmd.Init(client_shader_id_,
 262            kUniform2FakeLocation,
 263            kSharedMemoryId,
 264            kSharedMemoryOffset);
 265   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 266   EXPECT_EQ(0U, result->size);
 267   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 268 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 269   // Unlinked program
 270   EXPECT_CALL(*gl_, CreateProgram())
 271       .Times(1)
 272       .WillOnce(Return(kNewServiceId))
 273       .RetiresOnSaturation();
 274   CreateProgram cmd2;
 275   cmd2.Init(kNewClientId);
 276   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
 277   result->size = kInitialResult;
 278   cmd.Init(kNewClientId,
 279            kUniform2FakeLocation,
 280            kSharedMemoryId,
 281            kSharedMemoryOffset);
 282   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 283   EXPECT_EQ(0U, result->size);
 284   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 285 }
 286
 287 TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadLocationFails) {
 288   GetUniformiv::Result* result =
 289       static_cast<GetUniformiv::Result*>(shared_memory_address_);
 290   result->size = 0;
 291   GetUniformiv cmd;
 292   // invalid location
 293   cmd.Init(client_program_id_,
 294            kInvalidUniformLocation,
 295            kSharedMemoryId,
 296            kSharedMemoryOffset);
 297   EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0);
 298   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 299   EXPECT_EQ(0U, result->size);
 300   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 301 }
 302
 303 TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadSharedMemoryFails) {
 304   GetUniformiv cmd;
 305   cmd.Init(client_program_id_,
 306            kUniform2FakeLocation,
 307            kInvalidSharedMemoryId,
 308            kSharedMemoryOffset);
 309   EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0);
 310   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 311   cmd.Init(client_program_id_,
 312            kUniform2FakeLocation,
 313            kSharedMemoryId,
 314            kInvalidSharedMemoryOffset);
 315   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 316 };
 317
 318 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvSucceeds) {
 319   GetUniformfv::Result* result =
 320       static_cast<GetUniformfv::Result*>(shared_memory_address_);
 321   result->size = 0;
 322   GetUniformfv cmd;
 323   cmd.Init(client_program_id_,
 324            kUniform2FakeLocation,
 325            kSharedMemoryId,
 326            kSharedMemoryOffset);
 327   EXPECT_CALL(*gl_, GetUniformfv(kServiceProgramId, kUniform2RealLocation, _))
 328       .Times(1);
 329   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 330   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
 331             result->size);
 332 }
 333
 334 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) {
 335   GetUniformfv::Result* result =
 336       static_cast<GetUniformfv::Result*>(shared_memory_address_);
 337   result->size = 0;
 338   GetUniformfv cmd;
 339   cmd.Init(client_program_id_,
 340            kUniform2ElementFakeLocation,
 341            kSharedMemoryId,
 342            kSharedMemoryOffset);
 343   EXPECT_CALL(*gl_,
 344               GetUniformfv(kServiceProgramId, kUniform2ElementRealLocation, _))
 345       .Times(1);
 346   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 347   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
 348             result->size);
 349 }
 350
 351 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadProgramFails) {
 352   GetUniformfv::Result* result =
 353       static_cast<GetUniformfv::Result*>(shared_memory_address_);
 354   result->size = 0;
 355   GetUniformfv cmd;
 356   // non-existant program
 357   cmd.Init(kInvalidClientId,
 358            kUniform2FakeLocation,
 359            kSharedMemoryId,
 360            kSharedMemoryOffset);
 361   EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0);
 362   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 363   EXPECT_EQ(0U, result->size);
 364   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 365 // Valid id that is not a program. The GL spec requires a different error for
 366 // this case.
 367 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 368   result->size = kInitialResult;
 369   cmd.Init(client_shader_id_,
 370            kUniform2FakeLocation,
 371            kSharedMemoryId,
 372            kSharedMemoryOffset);
 373   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 374   EXPECT_EQ(0U, result->size);
 375   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 376 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 377   // Unlinked program
 378   EXPECT_CALL(*gl_, CreateProgram())
 379       .Times(1)
 380       .WillOnce(Return(kNewServiceId))
 381       .RetiresOnSaturation();
 382   CreateProgram cmd2;
 383   cmd2.Init(kNewClientId);
 384   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
 385   result->size = kInitialResult;
 386   cmd.Init(kNewClientId,
 387            kUniform2FakeLocation,
 388            kSharedMemoryId,
 389            kSharedMemoryOffset);
 390   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 391   EXPECT_EQ(0U, result->size);
 392   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 393 }
 394
 395 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadLocationFails) {
 396   GetUniformfv::Result* result =
 397       static_cast<GetUniformfv::Result*>(shared_memory_address_);
 398   result->size = 0;
 399   GetUniformfv cmd;
 400   // invalid location
 401   cmd.Init(client_program_id_,
 402            kInvalidUniformLocation,
 403            kSharedMemoryId,
 404            kSharedMemoryOffset);
 405   EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0);
 406   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 407   EXPECT_EQ(0U, result->size);
 408   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 409 }
 410
 411 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadSharedMemoryFails) {
 412   GetUniformfv cmd;
 413   cmd.Init(client_program_id_,
 414            kUniform2FakeLocation,
 415            kInvalidSharedMemoryId,
 416            kSharedMemoryOffset);
 417   EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0);
 418   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 419   cmd.Init(client_program_id_,
 420            kUniform2FakeLocation,
 421            kSharedMemoryId,
 422            kInvalidSharedMemoryOffset);
 423   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 424 };
 425
 426 TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersSucceeds) {
 427   GetAttachedShaders cmd;
 428   typedef GetAttachedShaders::Result Result;
 429   Result* result = static_cast<Result*>(shared_memory_address_);
 430   result->size = 0;
 431   EXPECT_CALL(*gl_, GetAttachedShaders(kServiceProgramId, 1, _, _)).WillOnce(
 432       DoAll(SetArgPointee<2>(1), SetArgPointee<3>(kServiceShaderId)));
 433   cmd.Init(client_program_id_,
 434            shared_memory_id_,
 435            shared_memory_offset_,
 436            Result::ComputeSize(1));
 437   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 438   EXPECT_EQ(1, result->GetNumResults());
 439   EXPECT_EQ(client_shader_id_, result->GetData()[0]);
 440   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 441 }
 442
 443 TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersResultNotInitFail) {
 444   GetAttachedShaders cmd;
 445   typedef GetAttachedShaders::Result Result;
 446   Result* result = static_cast<Result*>(shared_memory_address_);
 447   result->size = 1;
 448   EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0);
 449   cmd.Init(client_program_id_,
 450            shared_memory_id_,
 451            shared_memory_offset_,
 452            Result::ComputeSize(1));
 453   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 454 }
 455
 456 TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersBadProgramFails) {
 457   GetAttachedShaders cmd;
 458   typedef GetAttachedShaders::Result Result;
 459   Result* result = static_cast<Result*>(shared_memory_address_);
 460   result->size = 0;
 461   EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0);
 462   cmd.Init(kInvalidClientId,
 463            shared_memory_id_,
 464            shared_memory_offset_,
 465            Result::ComputeSize(1));
 466   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 467   EXPECT_EQ(0U, result->size);
 468   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 469 }
 470
 471 TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersBadSharedMemoryFails) {
 472   GetAttachedShaders cmd;
 473   typedef GetAttachedShaders::Result Result;
 474   cmd.Init(client_program_id_,
 475            kInvalidSharedMemoryId,
 476            shared_memory_offset_,
 477            Result::ComputeSize(1));
 478   EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0);
 479   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 480   cmd.Init(client_program_id_,
 481            shared_memory_id_,
 482            kInvalidSharedMemoryOffset,
 483            Result::ComputeSize(1));
 484   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 485 }
 486
 487 TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatSucceeds) {
 488   ScopedGLImplementationSetter gl_impl(::gfx::kGLImplementationEGLGLES2);
 489   GetShaderPrecisionFormat cmd;
 490   typedef GetShaderPrecisionFormat::Result Result;
 491   Result* result = static_cast<Result*>(shared_memory_address_);
 492   result->success = 0;
 493   const GLint range[2] = {62, 62};
 494   const GLint precision = 16;
 495   EXPECT_CALL(*gl_, GetShaderPrecisionFormat(_, _, _, _))
 496       .WillOnce(DoAll(SetArrayArgument<2>(range, range + 2),
 497                       SetArgPointee<3>(precision)))
 498       .RetiresOnSaturation();
 499   cmd.Init(GL_VERTEX_SHADER,
 500            GL_HIGH_FLOAT,
 501            shared_memory_id_,
 502            shared_memory_offset_);
 503   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 504   EXPECT_NE(0, result->success);
 505   EXPECT_EQ(range[0], result->min_range);
 506   EXPECT_EQ(range[1], result->max_range);
 507   EXPECT_EQ(precision, result->precision);
 508   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 509 }
 510
 511 TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatResultNotInitFails) {
 512   GetShaderPrecisionFormat cmd;
 513   typedef GetShaderPrecisionFormat::Result Result;
 514   Result* result = static_cast<Result*>(shared_memory_address_);
 515   result->success = 1;
 516   // NOTE: GL might not be called. There is no Desktop OpenGL equivalent
 517   cmd.Init(GL_VERTEX_SHADER,
 518            GL_HIGH_FLOAT,
 519            shared_memory_id_,
 520            shared_memory_offset_);
 521   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 522 }
 523
 524 TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatBadArgsFails) {
 525   typedef GetShaderPrecisionFormat::Result Result;
 526   Result* result = static_cast<Result*>(shared_memory_address_);
 527   result->success = 0;
 528   GetShaderPrecisionFormat cmd;
 529   cmd.Init(
 530       GL_TEXTURE_2D, GL_HIGH_FLOAT, shared_memory_id_, shared_memory_offset_);
 531   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 532   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 533   result->success = 0;
 534   cmd.Init(GL_VERTEX_SHADER,
 535            GL_TEXTURE_2D,
 536            shared_memory_id_,
 537            shared_memory_offset_);
 538   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 539   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 540 }
 541
 542 TEST_P(GLES2DecoderWithShaderTest,
 543        GetShaderPrecisionFormatBadSharedMemoryFails) {
 544   GetShaderPrecisionFormat cmd;
 545   cmd.Init(GL_VERTEX_SHADER,
 546            GL_HIGH_FLOAT,
 547            kInvalidSharedMemoryId,
 548            shared_memory_offset_);
 549   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 550   cmd.Init(GL_VERTEX_SHADER,
 551            GL_TEXTURE_2D,
 552            shared_memory_id_,
 553            kInvalidSharedMemoryOffset);
 554   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 555 }
 556
 557 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) {
 558   const GLuint kUniformIndex = 1;
 559   const uint32 kBucketId = 123;
 560   GetActiveUniform cmd;
 561   typedef GetActiveUniform::Result Result;
 562   Result* result = static_cast<Result*>(shared_memory_address_);
 563   result->success = 0;
 564   cmd.Init(client_program_id_,
 565            kUniformIndex,
 566            kBucketId,
 567            shared_memory_id_,
 568            shared_memory_offset_);
 569   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 570   EXPECT_NE(0, result->success);
 571   EXPECT_EQ(kUniform2Size, result->size);
 572   EXPECT_EQ(kUniform2Type, result->type);
 573   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 574   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 575   ASSERT_TRUE(bucket != NULL);
 576   EXPECT_EQ(
 577       0,
 578       memcmp(
 579           bucket->GetData(0, bucket->size()), kUniform2Name, bucket->size()));
 580 }
 581
 582 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) {
 583   const GLuint kUniformIndex = 1;
 584   const uint32 kBucketId = 123;
 585   GetActiveUniform cmd;
 586   typedef GetActiveUniform::Result Result;
 587   Result* result = static_cast<Result*>(shared_memory_address_);
 588   result->success = 1;
 589   cmd.Init(client_program_id_,
 590            kUniformIndex,
 591            kBucketId,
 592            shared_memory_id_,
 593            shared_memory_offset_);
 594   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 595 }
 596
 597 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) {
 598   const GLuint kUniformIndex = 1;
 599   const uint32 kBucketId = 123;
 600   GetActiveUniform cmd;
 601   typedef GetActiveUniform::Result Result;
 602   Result* result = static_cast<Result*>(shared_memory_address_);
 603   result->success = 0;
 604   cmd.Init(kInvalidClientId,
 605            kUniformIndex,
 606            kBucketId,
 607            shared_memory_id_,
 608            shared_memory_offset_);
 609   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 610   EXPECT_EQ(0, result->success);
 611   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 612 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 613   result->success = 0;
 614   cmd.Init(client_shader_id_,
 615            kUniformIndex,
 616            kBucketId,
 617            shared_memory_id_,
 618            shared_memory_offset_);
 619   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 620   EXPECT_EQ(0, result->success);
 621   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 622 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 623 }
 624
 625 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadIndexFails) {
 626   const uint32 kBucketId = 123;
 627   GetActiveUniform cmd;
 628   typedef GetActiveUniform::Result Result;
 629   Result* result = static_cast<Result*>(shared_memory_address_);
 630   result->success = 0;
 631   cmd.Init(client_program_id_,
 632            kBadUniformIndex,
 633            kBucketId,
 634            shared_memory_id_,
 635            shared_memory_offset_);
 636   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 637   EXPECT_EQ(0, result->success);
 638   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 639 }
 640
 641 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) {
 642   const GLuint kUniformIndex = 1;
 643   const uint32 kBucketId = 123;
 644   GetActiveUniform cmd;
 645   cmd.Init(client_program_id_,
 646            kUniformIndex,
 647            kBucketId,
 648            kInvalidSharedMemoryId,
 649            shared_memory_offset_);
 650   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 651   cmd.Init(client_program_id_,
 652            kUniformIndex,
 653            kBucketId,
 654            shared_memory_id_,
 655            kInvalidSharedMemoryOffset);
 656   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 657 }
 658
 659 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameSucceeds) {
 660   const uint32 kBucketId = 123;
 661   GetActiveUniformBlockName cmd;
 662   typedef GetActiveUniformBlockName::Result Result;
 663   Result* result = static_cast<Result*>(shared_memory_address_);
 664   *result = 0;
 665   cmd.Init(client_program_id_,
 666            0,
 667            kBucketId,
 668            shared_memory_id_,
 669            shared_memory_offset_);
 670   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
 671       .WillOnce(SetArgPointee<2>(GL_TRUE))
 672       .RetiresOnSaturation();
 673   const char kName[] = "HolyCow";
 674   const GLsizei kMaxLength = strlen(kName) + 1;
 675   EXPECT_CALL(*gl_,
 676               GetProgramiv(kServiceProgramId,
 677                            GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, _))
 678       .WillOnce(SetArgPointee<2>(kMaxLength))
 679       .RetiresOnSaturation();
 680   EXPECT_CALL(*gl_,
 681               GetActiveUniformBlockName(kServiceProgramId, 0, _, _, _))
 682       .WillOnce(DoAll(SetArgPointee<3>(strlen(kName)),
 683                       SetArrayArgument<4>(kName, kName + strlen(kName) + 1)))
 684       .RetiresOnSaturation();
 685   decoder_->set_unsafe_es3_apis_enabled(true);
 686   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 687   EXPECT_NE(0, *result);
 688   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 689   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 690   ASSERT_TRUE(bucket != NULL);
 691   EXPECT_EQ(0,
 692             memcmp(bucket->GetData(0, bucket->size()), kName, bucket->size()));
 693   decoder_->set_unsafe_es3_apis_enabled(false);
 694   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 695 }
 696
 697 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameUnlinkedProgram) {
 698   const uint32 kBucketId = 123;
 699   GetActiveUniformBlockName cmd;
 700   typedef GetActiveUniformBlockName::Result Result;
 701   Result* result = static_cast<Result*>(shared_memory_address_);
 702   *result = 0;
 703   cmd.Init(client_program_id_,
 704            0,
 705            kBucketId,
 706            shared_memory_id_,
 707            shared_memory_offset_);
 708   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
 709       .WillOnce(SetArgPointee<2>(GL_FALSE))
 710       .RetiresOnSaturation();
 711   decoder_->set_unsafe_es3_apis_enabled(true);
 712   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 713   EXPECT_EQ(0, *result);
 714   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 715 }
 716
 717 TEST_P(GLES2DecoderWithShaderTest,
 718        GetActiveUniformBlockNameResultNotInitFails) {
 719   const uint32 kBucketId = 123;
 720   GetActiveUniformBlockName cmd;
 721   typedef GetActiveUniformBlockName::Result Result;
 722   Result* result = static_cast<Result*>(shared_memory_address_);
 723   *result = 1;
 724   cmd.Init(client_program_id_,
 725            0,
 726            kBucketId,
 727            shared_memory_id_,
 728            shared_memory_offset_);
 729   decoder_->set_unsafe_es3_apis_enabled(true);
 730   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 731 }
 732
 733 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockNameBadProgramFails) {
 734   const uint32 kBucketId = 123;
 735   GetActiveUniformBlockName cmd;
 736   typedef GetActiveUniformBlockName::Result Result;
 737   Result* result = static_cast<Result*>(shared_memory_address_);
 738   *result = 0;
 739   cmd.Init(kInvalidClientId,
 740            0,
 741            kBucketId,
 742            shared_memory_id_,
 743            shared_memory_offset_);
 744   decoder_->set_unsafe_es3_apis_enabled(true);
 745   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 746   EXPECT_EQ(0, *result);
 747   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 748 }
 749
 750 TEST_P(GLES2DecoderWithShaderTest,
 751        GetActiveUniformBlockNameBadSharedMemoryFails) {
 752   const uint32 kBucketId = 123;
 753   GetActiveUniformBlockName cmd;
 754   decoder_->set_unsafe_es3_apis_enabled(true);
 755   cmd.Init(client_program_id_,
 756            0,
 757            kBucketId,
 758            kInvalidSharedMemoryId,
 759            shared_memory_offset_);
 760   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 761   cmd.Init(client_program_id_,
 762            0,
 763            kBucketId,
 764            shared_memory_id_,
 765            kInvalidSharedMemoryOffset);
 766   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 767 }
 768
 769 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockivSucceeds) {
 770   GetActiveUniformBlockiv cmd;
 771   typedef GetActiveUniformBlockiv::Result Result;
 772   Result* result = static_cast<Result*>(shared_memory_address_);
 773   GLenum kPname[] {
 774     GL_UNIFORM_BLOCK_BINDING,
 775     GL_UNIFORM_BLOCK_DATA_SIZE,
 776     GL_UNIFORM_BLOCK_NAME_LENGTH,
 777     GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS,
 778     GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES,
 779     GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER,
 780     GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER,
 781   };
 782   for (size_t ii = 0; ii < arraysize(kPname); ++ii) {
 783     result->SetNumResults(0);
 784     cmd.Init(client_program_id_,
 785              0,
 786              kPname[ii],
 787              shared_memory_id_,
 788              shared_memory_offset_);
 789     EXPECT_CALL(*gl_, GetError())
 790         .WillOnce(Return(GL_NO_ERROR))
 791         .WillOnce(Return(GL_NO_ERROR))
 792         .RetiresOnSaturation();
 793     EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
 794         .WillOnce(SetArgPointee<2>(GL_TRUE))
 795         .RetiresOnSaturation();
 796     if (kPname[ii] == GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) {
 797       EXPECT_CALL(*gl_, GetError())
 798           .WillOnce(Return(GL_NO_ERROR))
 799           .RetiresOnSaturation();
 800       EXPECT_CALL(*gl_,
 801                   GetActiveUniformBlockiv(kServiceProgramId, 0,
 802                       GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, _))
 803           .WillOnce(SetArgPointee<3>(1))
 804           .RetiresOnSaturation();
 805     }
 806     EXPECT_CALL(*gl_,
 807                 GetActiveUniformBlockiv(
 808                     kServiceProgramId, 0, kPname[ii], _))
 809         .WillOnce(SetArgPointee<3>(1976))
 810         .RetiresOnSaturation();
 811     decoder_->set_unsafe_es3_apis_enabled(true);
 812     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 813     EXPECT_EQ(1, result->GetNumResults());
 814     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 815     EXPECT_EQ(1976, result->GetData()[0]);
 816     decoder_->set_unsafe_es3_apis_enabled(false);
 817     EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
 818   }
 819 }
 820
 821 TEST_P(GLES2DecoderWithShaderTest,
 822        GetActiveUniformBlockivSucceedsZeroUniforms) {
 823   GetActiveUniformBlockiv cmd;
 824   typedef GetActiveUniformBlockiv::Result Result;
 825   Result* result = static_cast<Result*>(shared_memory_address_);
 826   result->SetNumResults(0);
 827   cmd.Init(client_program_id_,
 828            0,
 829            GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES,
 830            shared_memory_id_,
 831            shared_memory_offset_);
 832   EXPECT_CALL(*gl_, GetError())
 833       .WillOnce(Return(GL_NO_ERROR))
 834       .WillOnce(Return(GL_NO_ERROR))
 835       .WillOnce(Return(GL_NO_ERROR))
 836       .RetiresOnSaturation();
 837   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
 838       .WillOnce(SetArgPointee<2>(GL_TRUE))
 839       .RetiresOnSaturation();
 840   EXPECT_CALL(*gl_,
 841               GetActiveUniformBlockiv(
 842                   kServiceProgramId, 0, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, _))
 843       .WillOnce(SetArgPointee<3>(0))
 844       .RetiresOnSaturation();
 845   EXPECT_CALL(*gl_,
 846               GetActiveUniformBlockiv(kServiceProgramId, 0,
 847                   GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, _))
 848       .Times(1)
 849       .RetiresOnSaturation();
 850   decoder_->set_unsafe_es3_apis_enabled(true);
 851   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 852   EXPECT_EQ(0, result->GetNumResults());
 853   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 854 }
 855
 856 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockivUnlinkedProgram) {
 857   GetActiveUniformBlockiv cmd;
 858   typedef GetActiveUniformBlockiv::Result Result;
 859   Result* result = static_cast<Result*>(shared_memory_address_);
 860   result->SetNumResults(0);
 861   cmd.Init(client_program_id_,
 862            0,
 863            GL_UNIFORM_BLOCK_BINDING,
 864            shared_memory_id_,
 865            shared_memory_offset_);
 866   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
 867       .WillOnce(SetArgPointee<2>(GL_FALSE))
 868       .RetiresOnSaturation();
 869   decoder_->set_unsafe_es3_apis_enabled(true);
 870   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 871   EXPECT_EQ(0, result->GetNumResults());
 872   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 873 }
 874
 875 TEST_P(GLES2DecoderWithShaderTest,
 876        GetActiveUniformBlockivResultNotInitFails) {
 877   GetActiveUniformBlockiv cmd;
 878   typedef GetActiveUniformBlockiv::Result Result;
 879   Result* result = static_cast<Result*>(shared_memory_address_);
 880   result->SetNumResults(1);  // Should be initialized to 0.
 881   cmd.Init(client_program_id_,
 882            0,
 883            GL_UNIFORM_BLOCK_BINDING,
 884            shared_memory_id_,
 885            shared_memory_offset_);
 886   decoder_->set_unsafe_es3_apis_enabled(true);
 887   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
 888       .WillOnce(SetArgPointee<2>(GL_TRUE))
 889       .RetiresOnSaturation();
 890   EXPECT_CALL(*gl_, GetError())
 891       .WillOnce(Return(GL_NO_ERROR))
 892       .RetiresOnSaturation();
 893   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 894 }
 895
 896 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBlockivBadProgramFails) {
 897   GetActiveUniformBlockiv cmd;
 898   typedef GetActiveUniformBlockiv::Result Result;
 899   Result* result = static_cast<Result*>(shared_memory_address_);
 900   result->SetNumResults(0);
 901   cmd.Init(kInvalidClientId,
 902            0,
 903            GL_UNIFORM_BLOCK_BINDING,
 904            shared_memory_id_,
 905            shared_memory_offset_);
 906   decoder_->set_unsafe_es3_apis_enabled(true);
 907   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 908   EXPECT_EQ(0, result->GetNumResults());
 909   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 910 }
 911
 912 TEST_P(GLES2DecoderWithShaderTest,
 913        GetActiveUniformBlockivBadSharedMemoryFails) {
 914   GetActiveUniformBlockiv cmd;
 915   decoder_->set_unsafe_es3_apis_enabled(true);
 916   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
 917       .WillOnce(SetArgPointee<2>(GL_TRUE))
 918       .WillOnce(SetArgPointee<2>(GL_TRUE))
 919       .RetiresOnSaturation();
 920   EXPECT_CALL(*gl_, GetError())
 921       .WillOnce(Return(GL_NO_ERROR))
 922       .WillOnce(Return(GL_NO_ERROR))
 923       .RetiresOnSaturation();
 924   cmd.Init(client_program_id_,
 925            0,
 926            GL_UNIFORM_BLOCK_BINDING,
 927            kInvalidSharedMemoryId,
 928            shared_memory_offset_);
 929   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 930   cmd.Init(client_program_id_,
 931            0,
 932            GL_UNIFORM_BLOCK_BINDING,
 933            shared_memory_id_,
 934            kInvalidSharedMemoryOffset);
 935   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 936 }
 937
 938 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) {
 939   const GLuint kAttribIndex = 1;
 940   const uint32 kBucketId = 123;
 941   GetActiveAttrib cmd;
 942   typedef GetActiveAttrib::Result Result;
 943   Result* result = static_cast<Result*>(shared_memory_address_);
 944   result->success = 0;
 945   cmd.Init(client_program_id_,
 946            kAttribIndex,
 947            kBucketId,
 948            shared_memory_id_,
 949            shared_memory_offset_);
 950   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 951   EXPECT_NE(0, result->success);
 952   EXPECT_EQ(kAttrib2Size, result->size);
 953   EXPECT_EQ(kAttrib2Type, result->type);
 954   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 955   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 956   ASSERT_TRUE(bucket != NULL);
 957   EXPECT_EQ(
 958       0,
 959       memcmp(bucket->GetData(0, bucket->size()), kAttrib2Name, bucket->size()));
 960 }
 961
 962 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) {
 963   const GLuint kAttribIndex = 1;
 964   const uint32 kBucketId = 123;
 965   GetActiveAttrib cmd;
 966   typedef GetActiveAttrib::Result Result;
 967   Result* result = static_cast<Result*>(shared_memory_address_);
 968   result->success = 1;
 969   cmd.Init(client_program_id_,
 970            kAttribIndex,
 971            kBucketId,
 972            shared_memory_id_,
 973            shared_memory_offset_);
 974   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 975 }
 976
 977 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) {
 978   const GLuint kAttribIndex = 1;
 979   const uint32 kBucketId = 123;
 980   GetActiveAttrib cmd;
 981   typedef GetActiveAttrib::Result Result;
 982   Result* result = static_cast<Result*>(shared_memory_address_);
 983   result->success = 0;
 984   cmd.Init(kInvalidClientId,
 985            kAttribIndex,
 986            kBucketId,
 987            shared_memory_id_,
 988            shared_memory_offset_);
 989   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 990   EXPECT_EQ(0, result->success);
 991   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 992 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 993   result->success = 0;
 994   cmd.Init(client_shader_id_,
 995            kAttribIndex,
 996            kBucketId,
 997            shared_memory_id_,
 998            shared_memory_offset_);
 999   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1000   EXPECT_EQ(0, result->success);
1001   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1002 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
1003 }
1004
1005 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadIndexFails) {
1006   const uint32 kBucketId = 123;
1007   GetActiveAttrib cmd;
1008   typedef GetActiveAttrib::Result Result;
1009   Result* result = static_cast<Result*>(shared_memory_address_);
1010   result->success = 0;
1011   cmd.Init(client_program_id_,
1012            kBadAttribIndex,
1013            kBucketId,
1014            shared_memory_id_,
1015            shared_memory_offset_);
1016   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1017   EXPECT_EQ(0, result->success);
1018   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1019 }
1020
1021 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
1022   const GLuint kAttribIndex = 1;
1023   const uint32 kBucketId = 123;
1024   GetActiveAttrib cmd;
1025   cmd.Init(client_program_id_,
1026            kAttribIndex,
1027            kBucketId,
1028            kInvalidSharedMemoryId,
1029            shared_memory_offset_);
1030   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1031   cmd.Init(client_program_id_,
1032            kAttribIndex,
1033            kBucketId,
1034            shared_memory_id_,
1035            kInvalidSharedMemoryOffset);
1036   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1037 }
1038
1039 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesSucceeds) {
1040   const uint32 kBucketId = 123;
1041   const char kName0[] = "Cow";
1042   const char kName1[] = "Chicken";
1043   const char* kNames[] = { kName0, kName1 };
1044   const size_t kCount = arraysize(kNames);
1045   const char kValidStrEnd = 0;
1046   const GLuint kIndices[] = { 1, 2 };
1047   SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd);
1048   GetUniformIndices::Result* result =
1049       static_cast<GetUniformIndices::Result*>(shared_memory_address_);
1050   GetUniformIndices cmd;
1051   cmd.Init(client_program_id_,
1052            kBucketId,
1053            kSharedMemoryId,
1054            kSharedMemoryOffset);
1055   EXPECT_CALL(*gl_, GetUniformIndices(kServiceProgramId, kCount, _, _))
1056       .WillOnce(SetArrayArgument<3>(kIndices, kIndices + kCount))
1057       .RetiresOnSaturation();
1058   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
1059       .WillOnce(SetArgPointee<2>(GL_TRUE))
1060       .RetiresOnSaturation();
1061   EXPECT_CALL(*gl_, GetError())
1062       .WillOnce(Return(GL_NO_ERROR))
1063       .WillOnce(Return(GL_NO_ERROR))
1064       .RetiresOnSaturation();
1065   decoder_->set_unsafe_es3_apis_enabled(true);
1066   result->size = 0;
1067   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1068   EXPECT_EQ(kCount, static_cast<size_t>(result->GetNumResults()));
1069   for (size_t ii = 0; ii < kCount; ++ii) {
1070     EXPECT_EQ(kIndices[ii], result->GetData()[ii]);
1071   }
1072   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1073   decoder_->set_unsafe_es3_apis_enabled(false);
1074   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
1075 }
1076
1077 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadProgramFails) {
1078   const uint32 kBucketId = 123;
1079   const char kName0[] = "Cow";
1080   const char kName1[] = "Chicken";
1081   const char* kNames[] = { kName0, kName1 };
1082   const size_t kCount = arraysize(kNames);
1083   const char kValidStrEnd = 0;
1084   SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd);
1085   GetUniformIndices::Result* result =
1086       static_cast<GetUniformIndices::Result*>(shared_memory_address_);
1087   decoder_->set_unsafe_es3_apis_enabled(true);
1088   GetUniformIndices cmd;
1089   // None-existant program
1090   cmd.Init(kInvalidClientId,
1091            kBucketId,
1092            kSharedMemoryId,
1093            kSharedMemoryOffset);
1094   result->size = 0;
1095   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1096   EXPECT_EQ(0, result->GetNumResults());
1097   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1098   // Unlinked program.
1099   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
1100       .WillOnce(SetArgPointee<2>(GL_FALSE))
1101       .RetiresOnSaturation();
1102   cmd.Init(client_program_id_,
1103            kBucketId,
1104            kSharedMemoryId,
1105            kSharedMemoryOffset);
1106   result->size = 0;
1107   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1108   EXPECT_EQ(0, result->GetNumResults());
1109   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1110 }
1111
1112 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadParamsFails) {
1113   const uint32 kBucketId = 123;
1114   const char kName0[] = "Cow";
1115   const char kName1[] = "Chicken";
1116   const char* kNames[] = { kName0, kName1 };
1117   const size_t kCount = arraysize(kNames);
1118   const char kValidStrEnd = 0;
1119   const GLuint kIndices[] = { 1, 2 };
1120   SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd);
1121   GetUniformIndices::Result* result =
1122       static_cast<GetUniformIndices::Result*>(shared_memory_address_);
1123   GetUniformIndices cmd;
1124   cmd.Init(client_program_id_,
1125            kBucketId,
1126            kSharedMemoryId,
1127            kSharedMemoryOffset);
1128   EXPECT_CALL(*gl_, GetUniformIndices(kServiceProgramId, kCount, _, _))
1129       .WillOnce(SetArrayArgument<3>(kIndices, kIndices + kCount))
1130       .RetiresOnSaturation();
1131   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
1132       .WillOnce(SetArgPointee<2>(GL_TRUE))
1133       .RetiresOnSaturation();
1134   EXPECT_CALL(*gl_, GetError())
1135       .WillOnce(Return(GL_NO_ERROR))
1136       .WillOnce(Return(GL_INVALID_VALUE))
1137       .RetiresOnSaturation();
1138   decoder_->set_unsafe_es3_apis_enabled(true);
1139   result->size = 0;
1140   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1141   EXPECT_EQ(0, result->GetNumResults());
1142   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1143 }
1144
1145 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesResultNotInitFails) {
1146   const uint32 kBucketId = 123;
1147   const char kName0[] = "Cow";
1148   const char kName1[] = "Chicken";
1149   const char* kNames[] = { kName0, kName1 };
1150   const size_t kCount = arraysize(kNames);
1151   const char kValidStrEnd = 0;
1152   SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd);
1153   GetUniformIndices::Result* result =
1154       static_cast<GetUniformIndices::Result*>(shared_memory_address_);
1155   decoder_->set_unsafe_es3_apis_enabled(true);
1156   GetUniformIndices cmd;
1157   result->size = 1976;  // Any value other than 0.
1158   cmd.Init(kInvalidClientId,
1159            kBucketId,
1160            kSharedMemoryId,
1161            kSharedMemoryOffset);
1162   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1163 }
1164
1165 TEST_P(GLES2DecoderWithShaderTest, GetUniformIndicesBadSharedMemoryFails) {
1166   const uint32 kBucketId = 123;
1167   const char kName0[] = "Cow";
1168   const char kName1[] = "Chicken";
1169   const char* kNames[] = { kName0, kName1 };
1170   const size_t kCount = arraysize(kNames);
1171   const char kValidStrEnd = 0;
1172   SetBucketAsCStrings(kBucketId, kCount, kNames, kCount, kValidStrEnd);
1173   GetUniformIndices::Result* result =
1174       static_cast<GetUniformIndices::Result*>(shared_memory_address_);
1175   decoder_->set_unsafe_es3_apis_enabled(true);
1176   GetUniformIndices cmd;
1177   cmd.Init(client_program_id_,
1178            kBucketId,
1179            kInvalidSharedMemoryId,
1180            kSharedMemoryOffset);
1181   result->size = 0;
1182   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1183   cmd.Init(client_program_id_,
1184            kBucketId,
1185            kSharedMemoryId,
1186            kInvalidSharedMemoryOffset);
1187   result->size = 0;
1188   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1189 }
1190
1191 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivSucceeds) {
1192   const uint32 kBucketId = 123;
1193   const GLuint kIndices[] = { 1, 2 };
1194   const GLint kResults[] = { 1976, 321 };
1195   const size_t kCount = arraysize(kIndices);
1196   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
1197   GetActiveUniformsiv::Result* result =
1198       static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_);
1199   GetActiveUniformsiv cmd;
1200   cmd.Init(client_program_id_,
1201            kBucketId,
1202            GL_UNIFORM_TYPE,
1203            kSharedMemoryId,
1204            kSharedMemoryOffset);
1205   EXPECT_CALL(*gl_,
1206               GetActiveUniformsiv(
1207                   kServiceProgramId, kCount, _, GL_UNIFORM_TYPE, _))
1208       .WillOnce(SetArrayArgument<4>(kResults, kResults + kCount))
1209       .RetiresOnSaturation();
1210   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
1211       .WillOnce(SetArgPointee<2>(GL_TRUE))
1212       .RetiresOnSaturation();
1213   EXPECT_CALL(*gl_, GetError())
1214       .WillOnce(Return(GL_NO_ERROR))
1215       .WillOnce(Return(GL_NO_ERROR))
1216       .RetiresOnSaturation();
1217   decoder_->set_unsafe_es3_apis_enabled(true);
1218   result->size = 0;
1219   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1220   EXPECT_EQ(kCount, static_cast<size_t>(result->GetNumResults()));
1221   for (size_t ii = 0; ii < kCount; ++ii) {
1222     EXPECT_EQ(kResults[ii], result->GetData()[ii]);
1223   }
1224   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1225   decoder_->set_unsafe_es3_apis_enabled(false);
1226   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
1227 }
1228
1229 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadProgramFails) {
1230   const uint32 kBucketId = 123;
1231   const GLuint kIndices[] = { 1, 2 };
1232   const size_t kCount = arraysize(kIndices);
1233   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
1234   GetActiveUniformsiv::Result* result =
1235       static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_);
1236   decoder_->set_unsafe_es3_apis_enabled(true);
1237   GetActiveUniformsiv cmd;
1238   // None-existant program
1239   cmd.Init(kInvalidClientId,
1240            kBucketId,
1241            GL_UNIFORM_TYPE,
1242            kSharedMemoryId,
1243            kSharedMemoryOffset);
1244   result->size = 0;
1245   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1246   EXPECT_EQ(0, result->GetNumResults());
1247   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1248   // Unlinked program.
1249   cmd.Init(client_program_id_,
1250            kBucketId,
1251            GL_UNIFORM_TYPE,
1252            kSharedMemoryId,
1253            kSharedMemoryOffset);
1254   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
1255       .WillOnce(SetArgPointee<2>(GL_FALSE))
1256       .RetiresOnSaturation();
1257   result->size = 0;
1258   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1259   EXPECT_EQ(0, result->GetNumResults());
1260   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1261 }
1262
1263 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadParamsFails) {
1264   const uint32 kBucketId = 123;
1265   const GLuint kIndices[] = { 1, 2 };
1266   const GLint kResults[] = { 1976, 321 };
1267   const size_t kCount = arraysize(kIndices);
1268   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
1269   GetActiveUniformsiv::Result* result =
1270       static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_);
1271   GetActiveUniformsiv cmd;
1272   cmd.Init(client_program_id_,
1273            kBucketId,
1274            GL_UNIFORM_TYPE,
1275            kSharedMemoryId,
1276            kSharedMemoryOffset);
1277   EXPECT_CALL(*gl_,
1278               GetActiveUniformsiv(
1279                   kServiceProgramId, kCount, _, GL_UNIFORM_TYPE, _))
1280       .WillOnce(SetArrayArgument<4>(kResults, kResults + kCount))
1281       .RetiresOnSaturation();
1282   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
1283       .WillOnce(SetArgPointee<2>(GL_TRUE))
1284       .RetiresOnSaturation();
1285   EXPECT_CALL(*gl_, GetError())
1286       .WillOnce(Return(GL_NO_ERROR))
1287       .WillOnce(Return(GL_INVALID_VALUE))
1288       .RetiresOnSaturation();
1289   decoder_->set_unsafe_es3_apis_enabled(true);
1290   result->size = 0;
1291   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1292   EXPECT_EQ(0, result->GetNumResults());
1293   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1294 }
1295
1296 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivResultNotInitFails) {
1297   const uint32 kBucketId = 123;
1298   const GLuint kIndices[] = { 1, 2 };
1299   const size_t kCount = arraysize(kIndices);
1300   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
1301   GetActiveUniformsiv::Result* result =
1302       static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_);
1303   GetActiveUniformsiv cmd;
1304   cmd.Init(client_program_id_,
1305            kBucketId,
1306            GL_UNIFORM_TYPE,
1307            kSharedMemoryId,
1308            kSharedMemoryOffset);
1309   decoder_->set_unsafe_es3_apis_enabled(true);
1310   result->size = 1976;  // Any value other than 0.
1311   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1312 }
1313
1314 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformsivBadSharedMemoryFails) {
1315   const uint32 kBucketId = 123;
1316   const GLuint kIndices[] = { 1, 2 };
1317   const size_t kCount = arraysize(kIndices);
1318   SetBucketData(kBucketId, kIndices, sizeof(GLuint) * kCount);
1319   GetActiveUniformsiv::Result* result =
1320       static_cast<GetActiveUniformsiv::Result*>(shared_memory_address_);
1321   GetActiveUniformsiv cmd;
1322   decoder_->set_unsafe_es3_apis_enabled(true);
1323   result->size = 0;
1324   cmd.Init(client_program_id_,
1325            kBucketId,
1326            GL_UNIFORM_TYPE,
1327            kInvalidSharedMemoryId,
1328            kSharedMemoryOffset);
1329   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1330   result->size = 0;
1331   cmd.Init(client_program_id_,
1332            kBucketId,
1333            GL_UNIFORM_TYPE,
1334            kSharedMemoryId,
1335            kInvalidSharedMemoryOffset);
1336   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1337 }
1338
1339 TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) {
1340   const char* kInfo = "hello";
1341   const uint32 kBucketId = 123;
1342   CompileShader compile_cmd;
1343   GetShaderInfoLog cmd;
1344   EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _));
1345   EXPECT_CALL(*gl_, CompileShader(kServiceShaderId));
1346   EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _))
1347       .WillOnce(SetArgPointee<2>(GL_FALSE))
1348       .RetiresOnSaturation();
1349   EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_INFO_LOG_LENGTH, _))
1350       .WillOnce(SetArgPointee<2>(strlen(kInfo) + 1))
1351       .RetiresOnSaturation();
1352   EXPECT_CALL(*gl_, GetShaderInfoLog(kServiceShaderId, strlen(kInfo) + 1, _, _))
1353       .WillOnce(DoAll(SetArgPointee<2>(strlen(kInfo)),
1354                       SetArrayArgument<3>(kInfo, kInfo + strlen(kInfo) + 1)));
1355   compile_cmd.Init(client_shader_id_);
1356   cmd.Init(client_shader_id_, kBucketId);
1357   EXPECT_EQ(error::kNoError, ExecuteCmd(compile_cmd));
1358   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1359   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
1360   ASSERT_TRUE(bucket != NULL);
1361   EXPECT_EQ(strlen(kInfo) + 1, bucket->size());
1362   EXPECT_EQ(0,
1363             memcmp(bucket->GetData(0, bucket->size()), kInfo, bucket->size()));
1364   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1365 }
1366
1367 TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
1368   const uint32 kBucketId = 123;
1369   GetShaderInfoLog cmd;
1370   cmd.Init(kInvalidClientId, kBucketId);
1371   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1372   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1373 }
1374
1375 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingSucceeds) {
1376   const GLuint kIndex = 1;
1377   const uint32 kBucketId = 123;
1378   const char kName[] = "HolyCow";
1379   const GLsizei kBufferSize = static_cast<GLsizei>(strlen(kName) + 1);
1380   const GLsizei kSize = 2;
1381   const GLenum kType = GL_FLOAT_VEC2;
1382   GetTransformFeedbackVarying cmd;
1383   typedef GetTransformFeedbackVarying::Result Result;
1384   Result* result = static_cast<Result*>(shared_memory_address_);
1385   result->success = 0;
1386   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
1387       .WillOnce(SetArgPointee<2>(GL_TRUE))
1388       .RetiresOnSaturation();
1389   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId,
1390                                  GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, _))
1391       .WillOnce(SetArgPointee<2>(kBufferSize))
1392       .RetiresOnSaturation();
1393   EXPECT_CALL(*gl_, GetError())
1394       .WillOnce(Return(GL_NO_ERROR))
1395       .WillOnce(Return(GL_NO_ERROR))
1396       .RetiresOnSaturation();
1397   EXPECT_CALL(*gl_,
1398               GetTransformFeedbackVarying(
1399                   kServiceProgramId, kIndex, _, _, _, _, _))
1400       .WillOnce(DoAll(SetArgPointee<3>(kBufferSize - 1),
1401                       SetArgPointee<4>(kSize),
1402                       SetArgPointee<5>(kType),
1403                       SetArrayArgument<6>(kName, kName + kBufferSize)))
1404       .RetiresOnSaturation();
1405   cmd.Init(client_program_id_,
1406            kIndex,
1407            kBucketId,
1408            shared_memory_id_,
1409            shared_memory_offset_);
1410   decoder_->set_unsafe_es3_apis_enabled(true);
1411   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1412   EXPECT_NE(0, result->success);
1413   EXPECT_EQ(kSize, static_cast<GLsizei>(result->size));
1414   EXPECT_EQ(kType, static_cast<GLenum>(result->type));
1415   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1416   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
1417   ASSERT_TRUE(bucket != NULL);
1418   EXPECT_EQ(
1419       0, memcmp(bucket->GetData(0, bucket->size()), kName, bucket->size()));
1420   decoder_->set_unsafe_es3_apis_enabled(false);
1421   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
1422 }
1423
1424 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingNotInitFails) {
1425   const GLuint kIndex = 1;
1426   const uint32 kBucketId = 123;
1427   GetTransformFeedbackVarying cmd;
1428   typedef GetTransformFeedbackVarying::Result Result;
1429   Result* result = static_cast<Result*>(shared_memory_address_);
1430   result->success = 1;
1431   cmd.Init(client_program_id_,
1432            kIndex,
1433            kBucketId,
1434            shared_memory_id_,
1435            shared_memory_offset_);
1436   decoder_->set_unsafe_es3_apis_enabled(true);
1437   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1438 }
1439
1440 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingBadProgramFails) {
1441   const GLuint kIndex = 1;
1442   const uint32 kBucketId = 123;
1443   GetTransformFeedbackVarying cmd;
1444   typedef GetTransformFeedbackVarying::Result Result;
1445   Result* result = static_cast<Result*>(shared_memory_address_);
1446   result->success = 0;
1447   cmd.Init(kInvalidClientId,
1448            kIndex,
1449            kBucketId,
1450            shared_memory_id_,
1451            shared_memory_offset_);
1452   decoder_->set_unsafe_es3_apis_enabled(true);
1453   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1454   EXPECT_EQ(0, result->success);
1455   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1456 }
1457
1458 TEST_P(GLES2DecoderWithShaderTest, GetTransformFeedbackVaryingBadParamsFails) {
1459   const GLuint kIndex = 1;
1460   const uint32 kBucketId = 123;
1461   const GLsizei kBufferSize = 10;
1462   GetTransformFeedbackVarying cmd;
1463   typedef GetTransformFeedbackVarying::Result Result;
1464   Result* result = static_cast<Result*>(shared_memory_address_);
1465   result->success = 0;
1466   cmd.Init(client_program_id_,
1467            kIndex,
1468            kBucketId,
1469            shared_memory_id_,
1470            shared_memory_offset_);
1471   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_LINK_STATUS, _))
1472       .WillOnce(SetArgPointee<2>(GL_TRUE))
1473       .RetiresOnSaturation();
1474   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId,
1475                                  GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH, _))
1476       .WillOnce(SetArgPointee<2>(kBufferSize))
1477       .RetiresOnSaturation();
1478   EXPECT_CALL(*gl_, GetError())
1479       .WillOnce(Return(GL_NO_ERROR))
1480       .WillOnce(Return(GL_INVALID_VALUE))
1481       .RetiresOnSaturation();
1482   EXPECT_CALL(*gl_,
1483               GetTransformFeedbackVarying(
1484                   kServiceProgramId, kIndex, _, _, _, _, _))
1485       .Times(1)
1486       .RetiresOnSaturation();
1487   decoder_->set_unsafe_es3_apis_enabled(true);
1488   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1489   EXPECT_EQ(0, result->success);
1490   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1491 }
1492
1493 TEST_P(GLES2DecoderWithShaderTest,
1494        GetTransformFeedbackVaryingBadSharedMemoryFails) {
1495   const GLuint kIndex = 1;
1496   const uint32 kBucketId = 123;
1497   GetTransformFeedbackVarying cmd;
1498   typedef GetTransformFeedbackVarying::Result Result;
1499   Result* result = static_cast<Result*>(shared_memory_address_);
1500   result->success = 0;
1501   decoder_->set_unsafe_es3_apis_enabled(true);
1502   cmd.Init(client_program_id_,
1503            kIndex,
1504            kBucketId,
1505            kInvalidSharedMemoryId,
1506            shared_memory_offset_);
1507   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1508   cmd.Init(client_program_id_,
1509            kIndex,
1510            kBucketId,
1511            shared_memory_id_,
1512            kInvalidSharedMemoryOffset);
1513   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1514 }
1515
1516 TEST_P(GLES2DecoderTest, CompileShaderValidArgs) {
1517   // Compile shader should not actually call any GL calls yet.
1518   CompileShader cmd;
1519   cmd.Init(client_shader_id_);
1520   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1521
1522   // Getting the shader compilation state should trigger the actual GL calls.
1523   EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _));
1524   EXPECT_CALL(*gl_, CompileShader(kServiceShaderId));
1525   EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _))
1526       .WillOnce(SetArgPointee<2>(GL_TRUE))
1527       .RetiresOnSaturation();
1528   EXPECT_CALL(*gl_, GetError())
1529         .WillOnce(Return(GL_NO_ERROR))
1530         .WillOnce(Return(GL_NO_ERROR))
1531         .RetiresOnSaturation();
1532
1533   GetShaderiv status_cmd;
1534   status_cmd.Init(client_shader_id_, GL_COMPILE_STATUS,
1535                   kSharedMemoryId, kSharedMemoryOffset);
1536   EXPECT_EQ(error::kNoError, ExecuteCmd(status_cmd));
1537 }
1538
1539 TEST_P(GLES2DecoderTest, CompileShaderInvalidArgs) {
1540   CompileShader cmd;
1541   cmd.Init(kInvalidClientId);
1542   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1543   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1544 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
1545   cmd.Init(client_program_id_);
1546   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1547   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1548 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
1549 }
1550
1551 TEST_P(GLES2DecoderTest, ShaderSourceBucketAndGetShaderSourceValidArgs) {
1552   const uint32 kInBucketId = 123;
1553   const uint32 kOutBucketId = 125;
1554   const char kSource0[] = "hello";
1555   const char* kSource[] = { kSource0 };
1556   const char kValidStrEnd = 0;
1557   SetBucketAsCStrings(kInBucketId, 1, kSource, 1, kValidStrEnd);
1558   ShaderSourceBucket cmd;
1559   cmd.Init(client_shader_id_, kInBucketId);
1560   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1561   ClearSharedMemory();
1562   GetShaderSource get_cmd;
1563   get_cmd.Init(client_shader_id_, kOutBucketId);
1564   EXPECT_EQ(error::kNoError, ExecuteCmd(get_cmd));
1565   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kOutBucketId);
1566   ASSERT_TRUE(bucket != NULL);
1567   EXPECT_EQ(sizeof(kSource0), bucket->size());
1568   EXPECT_EQ(0, memcmp(bucket->GetData(0, bucket->size()),
1569                       kSource0, bucket->size()));
1570 }
1571
1572 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
1573 TEST_P(GLES2DecoderTest, ShaderSourceBucketWithProgramId) {
1574   const uint32 kBucketId = 123;
1575   const char kSource0[] = "hello";
1576   const char* kSource[] = { kSource0 };
1577   const char kValidStrEnd = 0;
1578   SetBucketAsCStrings(kBucketId, 1, kSource, 1, kValidStrEnd);
1579   ShaderSourceBucket cmd;
1580   cmd.Init(client_program_id_, kBucketId);
1581   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1582   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1583 }
1584 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
1585
1586 TEST_P(GLES2DecoderTest, ShaderSourceStripComments) {
1587   const uint32 kInBucketId = 123;
1588   const char kSource0[] = "hello/*te\ast*/world//a\ab";
1589   const char* kSource[] = { kSource0 };
1590   const char kValidStrEnd = 0;
1591   SetBucketAsCStrings(kInBucketId, 1, kSource, 1, kValidStrEnd);
1592   ShaderSourceBucket cmd;
1593   cmd.Init(client_shader_id_, kInBucketId);
1594   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1595   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1596 }
1597
1598 TEST_P(GLES2DecoderWithShaderTest, Uniform1iValidArgs) {
1599   EXPECT_CALL(*gl_, Uniform1i(kUniform1RealLocation, 2));
1600   Uniform1i cmd;
1601   cmd.Init(kUniform1FakeLocation, 2);
1602   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1603 }
1604
1605 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
1606   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
1607   EXPECT_CALL(*gl_,
1608               Uniform1iv(kUniform1RealLocation,
1609                          1,
1610                          reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
1611   GLint temp[1 * 2] = {
1612       0,
1613   };
1614   cmd.Init(kUniform1FakeLocation, 1, &temp[0]);
1615   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1616 }
1617
1618 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateInvalidValidArgs) {
1619   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
1620   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
1621   GLint temp[1 * 2] = {
1622       0,
1623   };
1624   cmd.Init(kUniform1FakeLocation, 2, &temp[0]);
1625   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1626   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1627 }
1628
1629 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivZeroCount) {
1630   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
1631   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
1632   GLint temp = 0;
1633   cmd.Init(kUniform1FakeLocation, 0, &temp);
1634   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1635   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1636 }
1637
1638 TEST_P(GLES2DecoderWithShaderTest, Uniform1iSamplerIsLmited) {
1639   EXPECT_CALL(*gl_, Uniform1i(_, _)).Times(0);
1640   Uniform1i cmd;
1641   cmd.Init(kUniform1FakeLocation, kNumTextureUnits);
1642   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1643   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1644 }
1645
1646 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivSamplerIsLimited) {
1647   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
1648   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
1649   GLint temp[] = {kNumTextureUnits};
1650   cmd.Init(kUniform1FakeLocation, 1, &temp[0]);
1651   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
1652   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1653 }
1654
1655 TEST_P(GLES2DecoderTest, BindAttribLocationBucket) {
1656   const uint32 kBucketId = 123;
1657   const GLint kLocation = 2;
1658   const char* kName = "testing";
1659   EXPECT_CALL(*gl_,
1660               BindAttribLocation(kServiceProgramId, kLocation, StrEq(kName)))
1661       .Times(1);
1662   SetBucketAsCString(kBucketId, kName);
1663   BindAttribLocationBucket cmd;
1664   cmd.Init(client_program_id_, kLocation, kBucketId);
1665   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1666 }
1667
1668 TEST_P(GLES2DecoderTest, BindAttribLocationBucketInvalidArgs) {
1669   const uint32 kBucketId = 123;
1670   const GLint kLocation = 2;
1671   const char* kName = "testing";
1672   EXPECT_CALL(*gl_, BindAttribLocation(_, _, _)).Times(0);
1673   BindAttribLocationBucket cmd;
1674   // check bucket does not exist.
1675   cmd.Init(client_program_id_, kLocation, kBucketId);
1676   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1677   // check bucket is empty.
1678   SetBucketAsCString(kBucketId, NULL);
1679   cmd.Init(client_program_id_, kLocation, kBucketId);
1680   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1681   // Check bad program id
1682   SetBucketAsCString(kBucketId, kName);
1683   cmd.Init(kInvalidClientId, kLocation, kBucketId);
1684   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1685   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1686 }
1687
1688 TEST_P(GLES2DecoderWithShaderTest, GetAttribLocation) {
1689   const uint32 kBucketId = 123;
1690   const char* kNonExistentName = "foobar";
1691   typedef GetAttribLocation::Result Result;
1692   Result* result = GetSharedMemoryAs<Result*>();
1693   SetBucketAsCString(kBucketId, kAttrib2Name);
1694   *result = -1;
1695   GetAttribLocation cmd;
1696   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1697   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1698   EXPECT_EQ(kAttrib2Location, *result);
1699   SetBucketAsCString(kBucketId, kNonExistentName);
1700   *result = -1;
1701   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1702   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1703   EXPECT_EQ(-1, *result);
1704 }
1705
1706 TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) {
1707   const uint32 kBucketId = 123;
1708   typedef GetAttribLocation::Result Result;
1709   Result* result = GetSharedMemoryAs<Result*>();
1710   *result = -1;
1711   GetAttribLocation cmd;
1712   // Check no bucket
1713   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1714   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1715   EXPECT_EQ(-1, *result);
1716   // Check bad program id.
1717   SetBucketAsCString(kBucketId, kAttrib2Name);
1718   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1719   *result = -1;
1720   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1721   EXPECT_EQ(-1, *result);
1722   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1723   // Check bad memory
1724   cmd.Init(client_program_id_,
1725            kBucketId,
1726            kInvalidSharedMemoryId,
1727            kSharedMemoryOffset);
1728   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1729   cmd.Init(client_program_id_,
1730            kBucketId,
1731            kSharedMemoryId,
1732            kInvalidSharedMemoryOffset);
1733   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1734 }
1735
1736 TEST_P(GLES2DecoderWithShaderTest, GetFragDataLocation) {
1737   const uint32 kBucketId = 123;
1738   const GLint kLocation = 10;
1739   const char* kName = "color";
1740   typedef GetFragDataLocation::Result Result;
1741   Result* result = GetSharedMemoryAs<Result*>();
1742   SetBucketAsCString(kBucketId, kName);
1743   *result = -1;
1744   GetFragDataLocation cmd;
1745   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1746   EXPECT_CALL(*gl_, GetFragDataLocation(kServiceProgramId, StrEq(kName)))
1747       .WillOnce(Return(kLocation))
1748       .RetiresOnSaturation();
1749   decoder_->set_unsafe_es3_apis_enabled(true);
1750   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1751   EXPECT_EQ(kLocation, *result);
1752   decoder_->set_unsafe_es3_apis_enabled(false);
1753   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
1754 }
1755
1756 TEST_P(GLES2DecoderWithShaderTest, GetFragDataLocationInvalidArgs) {
1757   const uint32 kBucketId = 123;
1758   typedef GetFragDataLocation::Result Result;
1759   Result* result = GetSharedMemoryAs<Result*>();
1760   *result = -1;
1761   GetFragDataLocation cmd;
1762   decoder_->set_unsafe_es3_apis_enabled(true);
1763   // Check no bucket
1764   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1765   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1766   EXPECT_EQ(-1, *result);
1767   // Check bad program id.
1768   const char* kName = "color";
1769   SetBucketAsCString(kBucketId, kName);
1770   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1771   *result = -1;
1772   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1773   EXPECT_EQ(-1, *result);
1774   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1775   // Check bad memory
1776   cmd.Init(client_program_id_,
1777            kBucketId,
1778            kInvalidSharedMemoryId,
1779            kSharedMemoryOffset);
1780   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1781   cmd.Init(client_program_id_,
1782            kBucketId,
1783            kSharedMemoryId,
1784            kInvalidSharedMemoryOffset);
1785   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1786 }
1787
1788 TEST_P(GLES2DecoderWithShaderTest, GetUniformBlockIndex) {
1789   const uint32 kBucketId = 123;
1790   const GLuint kIndex = 10;
1791   const char* kName = "color";
1792   typedef GetUniformBlockIndex::Result Result;
1793   Result* result = GetSharedMemoryAs<Result*>();
1794   SetBucketAsCString(kBucketId, kName);
1795   *result = GL_INVALID_INDEX;
1796   GetUniformBlockIndex cmd;
1797   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1798   EXPECT_CALL(*gl_, GetUniformBlockIndex(kServiceProgramId, StrEq(kName)))
1799       .WillOnce(Return(kIndex))
1800       .RetiresOnSaturation();
1801   decoder_->set_unsafe_es3_apis_enabled(true);
1802   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1803   EXPECT_EQ(kIndex, *result);
1804   decoder_->set_unsafe_es3_apis_enabled(false);
1805   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
1806 }
1807
1808 TEST_P(GLES2DecoderWithShaderTest, GetUniformBlockIndexInvalidArgs) {
1809   const uint32 kBucketId = 123;
1810   typedef GetUniformBlockIndex::Result Result;
1811   Result* result = GetSharedMemoryAs<Result*>();
1812   *result = GL_INVALID_INDEX;
1813   GetUniformBlockIndex cmd;
1814   decoder_->set_unsafe_es3_apis_enabled(true);
1815   // Check no bucket
1816   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1817   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1818   EXPECT_EQ(GL_INVALID_INDEX, *result);
1819   // Check bad program id.
1820   const char* kName = "color";
1821   SetBucketAsCString(kBucketId, kName);
1822   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1823   *result = GL_INVALID_INDEX;
1824   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1825   EXPECT_EQ(GL_INVALID_INDEX, *result);
1826   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1827   // Check bad memory
1828   cmd.Init(client_program_id_,
1829            kBucketId,
1830            kInvalidSharedMemoryId,
1831            kSharedMemoryOffset);
1832   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1833   cmd.Init(client_program_id_,
1834            kBucketId,
1835            kSharedMemoryId,
1836            kInvalidSharedMemoryOffset);
1837   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1838 }
1839
1840 TEST_P(GLES2DecoderWithShaderTest, GetUniformLocation) {
1841   const uint32 kBucketId = 123;
1842   const char* kNonExistentName = "foobar";
1843   typedef GetUniformLocation::Result Result;
1844   Result* result = GetSharedMemoryAs<Result*>();
1845   SetBucketAsCString(kBucketId, kUniform2Name);
1846   *result = -1;
1847   GetUniformLocation cmd;
1848   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1849   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1850   EXPECT_EQ(kUniform2FakeLocation, *result);
1851   SetBucketAsCString(kBucketId, kNonExistentName);
1852   *result = -1;
1853   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1854   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1855   EXPECT_EQ(-1, *result);
1856 }
1857
1858 TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationInvalidArgs) {
1859   const uint32 kBucketId = 123;
1860   typedef GetUniformLocation::Result Result;
1861   Result* result = GetSharedMemoryAs<Result*>();
1862   *result = -1;
1863   GetUniformLocation cmd;
1864   // Check no bucket
1865   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1866   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1867   EXPECT_EQ(-1, *result);
1868   // Check bad program id.
1869   SetBucketAsCString(kBucketId, kUniform2Name);
1870   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1871   *result = -1;
1872   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1873   EXPECT_EQ(-1, *result);
1874   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1875   // Check bad memory
1876   cmd.Init(client_program_id_,
1877            kBucketId,
1878            kInvalidSharedMemoryId,
1879            kSharedMemoryOffset);
1880   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1881   cmd.Init(client_program_id_,
1882            kBucketId,
1883            kSharedMemoryId,
1884            kInvalidSharedMemoryOffset);
1885   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1886 }
1887
1888 TEST_P(GLES2DecoderWithShaderTest, UniformBlockBindingValidArgs) {
1889   EXPECT_CALL(*gl_, UniformBlockBinding(kServiceProgramId, 2, 3));
1890   SpecializedSetup<cmds::UniformBlockBinding, 0>(true);
1891   cmds::UniformBlockBinding cmd;
1892   cmd.Init(client_program_id_, 2, 3);
1893   decoder_->set_unsafe_es3_apis_enabled(true);
1894   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1895   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1896   decoder_->set_unsafe_es3_apis_enabled(false);
1897   EXPECT_EQ(error::kUnknownCommand, ExecuteCmd(cmd));
1898 }
1899
1900 TEST_P(GLES2DecoderWithShaderTest, BindUniformLocationCHROMIUMBucket) {
1901   const uint32 kBucketId = 123;
1902   const GLint kLocation = 2;
1903   const char* kName = "testing";
1904   const char* kBadName1 = "gl_testing";
1905   const char* kBadName2 = "testing[1]";
1906
1907   SetBucketAsCString(kBucketId, kName);
1908   BindUniformLocationCHROMIUMBucket cmd;
1909   cmd.Init(client_program_id_,
1910            kLocation,
1911            kBucketId);
1912   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1913   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1914   // check negative location
1915   SetBucketAsCString(kBucketId, kName);
1916   cmd.Init(client_program_id_, -1, kBucketId);
1917   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1918   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1919   // check highest location
1920   SetBucketAsCString(kBucketId, kName);
1921   GLint kMaxLocation =
1922       (kMaxFragmentUniformVectors + kMaxVertexUniformVectors) * 4 - 1;
1923   cmd.Init(client_program_id_,
1924            kMaxLocation,
1925            kBucketId);
1926   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1927   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1928   // check too high location
1929   SetBucketAsCString(kBucketId, kName);
1930   cmd.Init(client_program_id_,
1931            kMaxLocation + 1,
1932            kBucketId);
1933   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1934   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1935   // check bad name "gl_..."
1936   SetBucketAsCString(kBucketId, kBadName1);
1937   cmd.Init(client_program_id_,
1938            kLocation,
1939            kBucketId);
1940   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1941   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1942   // check bad name "name[1]" non zero
1943   SetBucketAsCString(kBucketId, kBadName2);
1944   cmd.Init(client_program_id_,
1945            kLocation,
1946            kBucketId);
1947   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1948   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1949 }
1950
1951 TEST_P(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) {
1952   base::CommandLine command_line(0, NULL);
1953   command_line.AppendSwitchASCII(
1954       switches::kGpuDriverBugWorkarounds,
1955       base::IntToString(gpu::CLEAR_UNIFORMS_BEFORE_FIRST_PROGRAM_USE));
1956   InitState init;
1957   init.has_alpha = true;
1958   init.request_alpha = true;
1959   init.bind_generates_resource = true;
1960   InitDecoderWithCommandLine(init, &command_line);
1961   {
1962     static AttribInfo attribs[] = {
1963         {
1964          kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location,
1965         },
1966         {
1967          kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location,
1968         },
1969         {
1970          kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location,
1971         },
1972     };
1973     static UniformInfo uniforms[] = {
1974         {kUniform1Name, kUniform1Size, kUniform1Type, kUniform1FakeLocation,
1975          kUniform1RealLocation, kUniform1DesiredLocation},
1976         {kUniform2Name, kUniform2Size, kUniform2Type, kUniform2FakeLocation,
1977          kUniform2RealLocation, kUniform2DesiredLocation},
1978         {kUniform3Name, kUniform3Size, kUniform3Type, kUniform3FakeLocation,
1979          kUniform3RealLocation, kUniform3DesiredLocation},
1980     };
1981     SetupShader(attribs,
1982                 arraysize(attribs),
1983                 uniforms,
1984                 arraysize(uniforms),
1985                 client_program_id_,
1986                 kServiceProgramId,
1987                 client_vertex_shader_id_,
1988                 kServiceVertexShaderId,
1989                 client_fragment_shader_id_,
1990                 kServiceFragmentShaderId);
1991     TestHelper::SetupExpectationsForClearingUniforms(
1992         gl_.get(), uniforms, arraysize(uniforms));
1993   }
1994
1995   {
1996     EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
1997         .Times(1)
1998         .RetiresOnSaturation();
1999     cmds::UseProgram cmd;
2000     cmd.Init(client_program_id_);
2001     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
2002   }
2003 }
2004
2005 // TODO(gman): DeleteProgram
2006
2007 // TODO(gman): UseProgram
2008
2009 // TODO(gman): DeleteShader
2010
2011 }  // namespace gles2
2012 }  // namespace gpu