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/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_unittest.h"
  20
  21 #include "gpu/command_buffer/service/gpu_switches.h"
  22 #include "gpu/command_buffer/service/image_manager.h"
  23 #include "gpu/command_buffer/service/mailbox_manager.h"
  24 #include "gpu/command_buffer/service/mocks.h"
  25 #include "gpu/command_buffer/service/program_manager.h"
  26 #include "gpu/command_buffer/service/test_helper.h"
  27 #include "testing/gtest/include/gtest/gtest.h"
  28 #include "ui/gl/gl_implementation.h"
  29 #include "ui/gl/gl_mock.h"
  30 #include "ui/gl/gl_surface_stub.h"
  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::DoAll;
  39 using ::testing::InSequence;
  40 using ::testing::Invoke;
  41 using ::testing::MatcherCast;
  42 using ::testing::Mock;
  43 using ::testing::Pointee;
  44 using ::testing::Return;
  45 using ::testing::SaveArg;
  46 using ::testing::SetArrayArgument;
  47 using ::testing::SetArgumentPointee;
  48 using ::testing::SetArgPointee;
  49 using ::testing::StrEq;
  50 using ::testing::StrictMock;
  51
  52 namespace gpu {
  53 namespace gles2 {
  54
  55 using namespace cmds;
  56
  57 TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMValidArgs) {
  58   const uint32 kBucketId = 123;
  59   GetProgramInfoCHROMIUM cmd;
  60   cmd.Init(client_program_id_, kBucketId);
  61   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  62   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
  63   EXPECT_GT(bucket->size(), 0u);
  64 }
  65
  66 TEST_P(GLES2DecoderWithShaderTest, GetProgramInfoCHROMIUMInvalidArgs) {
  67   const uint32 kBucketId = 123;
  68   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
  69   EXPECT_TRUE(bucket == NULL);
  70   GetProgramInfoCHROMIUM cmd;
  71   cmd.Init(kInvalidClientId, kBucketId);
  72   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  73   EXPECT_EQ(GL_NO_ERROR, GetGLError());
  74   bucket = decoder_->GetBucket(kBucketId);
  75   ASSERT_TRUE(bucket != NULL);
  76   EXPECT_EQ(sizeof(ProgramInfoHeader), bucket->size());
  77   ProgramInfoHeader* info =
  78       bucket->GetDataAs<ProgramInfoHeader*>(0, sizeof(ProgramInfoHeader));
  79   ASSERT_TRUE(info != 0);
  80   EXPECT_EQ(0u, info->link_status);
  81   EXPECT_EQ(0u, info->num_attribs);
  82   EXPECT_EQ(0u, info->num_uniforms);
  83 }
  84
  85 TEST_P(GLES2DecoderWithShaderTest, GetUniformivSucceeds) {
  86   GetUniformiv::Result* result =
  87       static_cast<GetUniformiv::Result*>(shared_memory_address_);
  88   result->size = 0;
  89   GetUniformiv cmd;
  90   cmd.Init(client_program_id_,
  91            kUniform2FakeLocation,
  92            kSharedMemoryId,
  93            kSharedMemoryOffset);
  94   EXPECT_CALL(*gl_, GetUniformiv(kServiceProgramId, kUniform2RealLocation, _))
  95       .Times(1);
  96   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
  97   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
  98             result->size);
  99 }
 100
 101 TEST_P(GLES2DecoderWithShaderTest, GetUniformivArrayElementSucceeds) {
 102   GetUniformiv::Result* result =
 103       static_cast<GetUniformiv::Result*>(shared_memory_address_);
 104   result->size = 0;
 105   GetUniformiv cmd;
 106   cmd.Init(client_program_id_,
 107            kUniform2ElementFakeLocation,
 108            kSharedMemoryId,
 109            kSharedMemoryOffset);
 110   EXPECT_CALL(*gl_,
 111               GetUniformiv(kServiceProgramId, kUniform2ElementRealLocation, _))
 112       .Times(1);
 113   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 114   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
 115             result->size);
 116 }
 117
 118 TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadProgramFails) {
 119   GetUniformiv::Result* result =
 120       static_cast<GetUniformiv::Result*>(shared_memory_address_);
 121   result->size = 0;
 122   GetUniformiv cmd;
 123   // non-existant program
 124   cmd.Init(kInvalidClientId,
 125            kUniform2FakeLocation,
 126            kSharedMemoryId,
 127            kSharedMemoryOffset);
 128   EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0);
 129   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 130   EXPECT_EQ(0U, result->size);
 131   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 132 // Valid id that is not a program. The GL spec requires a different error for
 133 // this case.
 134 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 135   result->size = kInitialResult;
 136   cmd.Init(client_shader_id_,
 137            kUniform2FakeLocation,
 138            kSharedMemoryId,
 139            kSharedMemoryOffset);
 140   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 141   EXPECT_EQ(0U, result->size);
 142   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 143 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 144   // Unlinked program
 145   EXPECT_CALL(*gl_, CreateProgram())
 146       .Times(1)
 147       .WillOnce(Return(kNewServiceId))
 148       .RetiresOnSaturation();
 149   CreateProgram cmd2;
 150   cmd2.Init(kNewClientId);
 151   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
 152   result->size = kInitialResult;
 153   cmd.Init(kNewClientId,
 154            kUniform2FakeLocation,
 155            kSharedMemoryId,
 156            kSharedMemoryOffset);
 157   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 158   EXPECT_EQ(0U, result->size);
 159   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 160 }
 161
 162 TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadLocationFails) {
 163   GetUniformiv::Result* result =
 164       static_cast<GetUniformiv::Result*>(shared_memory_address_);
 165   result->size = 0;
 166   GetUniformiv cmd;
 167   // invalid location
 168   cmd.Init(client_program_id_,
 169            kInvalidUniformLocation,
 170            kSharedMemoryId,
 171            kSharedMemoryOffset);
 172   EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0);
 173   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 174   EXPECT_EQ(0U, result->size);
 175   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 176 }
 177
 178 TEST_P(GLES2DecoderWithShaderTest, GetUniformivBadSharedMemoryFails) {
 179   GetUniformiv cmd;
 180   cmd.Init(client_program_id_,
 181            kUniform2FakeLocation,
 182            kInvalidSharedMemoryId,
 183            kSharedMemoryOffset);
 184   EXPECT_CALL(*gl_, GetUniformiv(_, _, _)).Times(0);
 185   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 186   cmd.Init(client_program_id_,
 187            kUniform2FakeLocation,
 188            kSharedMemoryId,
 189            kInvalidSharedMemoryOffset);
 190   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 191 };
 192
 193 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvSucceeds) {
 194   GetUniformfv::Result* result =
 195       static_cast<GetUniformfv::Result*>(shared_memory_address_);
 196   result->size = 0;
 197   GetUniformfv cmd;
 198   cmd.Init(client_program_id_,
 199            kUniform2FakeLocation,
 200            kSharedMemoryId,
 201            kSharedMemoryOffset);
 202   EXPECT_CALL(*gl_, GetUniformfv(kServiceProgramId, kUniform2RealLocation, _))
 203       .Times(1);
 204   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 205   EXPECT_EQ(GLES2Util::GetGLDataTypeSizeForUniforms(kUniform2Type),
 206             result->size);
 207 }
 208
 209 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvArrayElementSucceeds) {
 210   GetUniformfv::Result* result =
 211       static_cast<GetUniformfv::Result*>(shared_memory_address_);
 212   result->size = 0;
 213   GetUniformfv cmd;
 214   cmd.Init(client_program_id_,
 215            kUniform2ElementFakeLocation,
 216            kSharedMemoryId,
 217            kSharedMemoryOffset);
 218   EXPECT_CALL(*gl_,
 219               GetUniformfv(kServiceProgramId, kUniform2ElementRealLocation, _))
 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, GetUniformfvBadProgramFails) {
 227   GetUniformfv::Result* result =
 228       static_cast<GetUniformfv::Result*>(shared_memory_address_);
 229   result->size = 0;
 230   GetUniformfv cmd;
 231   // non-existant program
 232   cmd.Init(kInvalidClientId,
 233            kUniform2FakeLocation,
 234            kSharedMemoryId,
 235            kSharedMemoryOffset);
 236   EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0);
 237   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 238   EXPECT_EQ(0U, result->size);
 239   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 240 // Valid id that is not a program. The GL spec requires a different error for
 241 // this case.
 242 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 243   result->size = kInitialResult;
 244   cmd.Init(client_shader_id_,
 245            kUniform2FakeLocation,
 246            kSharedMemoryId,
 247            kSharedMemoryOffset);
 248   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 249   EXPECT_EQ(0U, result->size);
 250   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 251 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 252   // Unlinked program
 253   EXPECT_CALL(*gl_, CreateProgram())
 254       .Times(1)
 255       .WillOnce(Return(kNewServiceId))
 256       .RetiresOnSaturation();
 257   CreateProgram cmd2;
 258   cmd2.Init(kNewClientId);
 259   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
 260   result->size = kInitialResult;
 261   cmd.Init(kNewClientId,
 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 }
 269
 270 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadLocationFails) {
 271   GetUniformfv::Result* result =
 272       static_cast<GetUniformfv::Result*>(shared_memory_address_);
 273   result->size = 0;
 274   GetUniformfv cmd;
 275   // invalid location
 276   cmd.Init(client_program_id_,
 277            kInvalidUniformLocation,
 278            kSharedMemoryId,
 279            kSharedMemoryOffset);
 280   EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0);
 281   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 282   EXPECT_EQ(0U, result->size);
 283   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 284 }
 285
 286 TEST_P(GLES2DecoderWithShaderTest, GetUniformfvBadSharedMemoryFails) {
 287   GetUniformfv cmd;
 288   cmd.Init(client_program_id_,
 289            kUniform2FakeLocation,
 290            kInvalidSharedMemoryId,
 291            kSharedMemoryOffset);
 292   EXPECT_CALL(*gl_, GetUniformfv(_, _, _)).Times(0);
 293   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 294   cmd.Init(client_program_id_,
 295            kUniform2FakeLocation,
 296            kSharedMemoryId,
 297            kInvalidSharedMemoryOffset);
 298   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 299 };
 300
 301 TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersSucceeds) {
 302   GetAttachedShaders cmd;
 303   typedef GetAttachedShaders::Result Result;
 304   Result* result = static_cast<Result*>(shared_memory_address_);
 305   result->size = 0;
 306   EXPECT_CALL(*gl_, GetAttachedShaders(kServiceProgramId, 1, _, _)).WillOnce(
 307       DoAll(SetArgumentPointee<2>(1), SetArgumentPointee<3>(kServiceShaderId)));
 308   cmd.Init(client_program_id_,
 309            shared_memory_id_,
 310            shared_memory_offset_,
 311            Result::ComputeSize(1));
 312   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 313   EXPECT_EQ(1, result->GetNumResults());
 314   EXPECT_EQ(client_shader_id_, result->GetData()[0]);
 315   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 316 }
 317
 318 TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersResultNotInitFail) {
 319   GetAttachedShaders cmd;
 320   typedef GetAttachedShaders::Result Result;
 321   Result* result = static_cast<Result*>(shared_memory_address_);
 322   result->size = 1;
 323   EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0);
 324   cmd.Init(client_program_id_,
 325            shared_memory_id_,
 326            shared_memory_offset_,
 327            Result::ComputeSize(1));
 328   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 329 }
 330
 331 TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersBadProgramFails) {
 332   GetAttachedShaders cmd;
 333   typedef GetAttachedShaders::Result Result;
 334   Result* result = static_cast<Result*>(shared_memory_address_);
 335   result->size = 0;
 336   EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0);
 337   cmd.Init(kInvalidClientId,
 338            shared_memory_id_,
 339            shared_memory_offset_,
 340            Result::ComputeSize(1));
 341   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 342   EXPECT_EQ(0U, result->size);
 343   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 344 }
 345
 346 TEST_P(GLES2DecoderWithShaderTest, GetAttachedShadersBadSharedMemoryFails) {
 347   GetAttachedShaders cmd;
 348   typedef GetAttachedShaders::Result Result;
 349   cmd.Init(client_program_id_,
 350            kInvalidSharedMemoryId,
 351            shared_memory_offset_,
 352            Result::ComputeSize(1));
 353   EXPECT_CALL(*gl_, GetAttachedShaders(_, _, _, _)).Times(0);
 354   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 355   cmd.Init(client_program_id_,
 356            shared_memory_id_,
 357            kInvalidSharedMemoryOffset,
 358            Result::ComputeSize(1));
 359   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 360 }
 361
 362 TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatSucceeds) {
 363   ScopedGLImplementationSetter gl_impl(::gfx::kGLImplementationEGLGLES2);
 364   GetShaderPrecisionFormat cmd;
 365   typedef GetShaderPrecisionFormat::Result Result;
 366   Result* result = static_cast<Result*>(shared_memory_address_);
 367   result->success = 0;
 368   const GLint range[2] = {62, 62};
 369   const GLint precision = 16;
 370   EXPECT_CALL(*gl_, GetShaderPrecisionFormat(_, _, _, _))
 371       .WillOnce(DoAll(SetArrayArgument<2>(range, range + 2),
 372                       SetArgumentPointee<3>(precision)))
 373       .RetiresOnSaturation();
 374   cmd.Init(GL_VERTEX_SHADER,
 375            GL_HIGH_FLOAT,
 376            shared_memory_id_,
 377            shared_memory_offset_);
 378   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 379   EXPECT_NE(0, result->success);
 380   EXPECT_EQ(range[0], result->min_range);
 381   EXPECT_EQ(range[1], result->max_range);
 382   EXPECT_EQ(precision, result->precision);
 383   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 384 }
 385
 386 TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatResultNotInitFails) {
 387   GetShaderPrecisionFormat cmd;
 388   typedef GetShaderPrecisionFormat::Result Result;
 389   Result* result = static_cast<Result*>(shared_memory_address_);
 390   result->success = 1;
 391   // NOTE: GL might not be called. There is no Desktop OpenGL equivalent
 392   cmd.Init(GL_VERTEX_SHADER,
 393            GL_HIGH_FLOAT,
 394            shared_memory_id_,
 395            shared_memory_offset_);
 396   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 397 }
 398
 399 TEST_P(GLES2DecoderWithShaderTest, GetShaderPrecisionFormatBadArgsFails) {
 400   typedef GetShaderPrecisionFormat::Result Result;
 401   Result* result = static_cast<Result*>(shared_memory_address_);
 402   result->success = 0;
 403   GetShaderPrecisionFormat cmd;
 404   cmd.Init(
 405       GL_TEXTURE_2D, GL_HIGH_FLOAT, shared_memory_id_, shared_memory_offset_);
 406   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 407   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 408   result->success = 0;
 409   cmd.Init(GL_VERTEX_SHADER,
 410            GL_TEXTURE_2D,
 411            shared_memory_id_,
 412            shared_memory_offset_);
 413   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 414   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 415 }
 416
 417 TEST_P(GLES2DecoderWithShaderTest,
 418        GetShaderPrecisionFormatBadSharedMemoryFails) {
 419   GetShaderPrecisionFormat cmd;
 420   cmd.Init(GL_VERTEX_SHADER,
 421            GL_HIGH_FLOAT,
 422            kInvalidSharedMemoryId,
 423            shared_memory_offset_);
 424   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 425   cmd.Init(GL_VERTEX_SHADER,
 426            GL_TEXTURE_2D,
 427            shared_memory_id_,
 428            kInvalidSharedMemoryOffset);
 429   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 430 }
 431
 432 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformSucceeds) {
 433   const GLuint kUniformIndex = 1;
 434   const uint32 kBucketId = 123;
 435   GetActiveUniform cmd;
 436   typedef GetActiveUniform::Result Result;
 437   Result* result = static_cast<Result*>(shared_memory_address_);
 438   result->success = 0;
 439   cmd.Init(client_program_id_,
 440            kUniformIndex,
 441            kBucketId,
 442            shared_memory_id_,
 443            shared_memory_offset_);
 444   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 445   EXPECT_NE(0, result->success);
 446   EXPECT_EQ(kUniform2Size, result->size);
 447   EXPECT_EQ(kUniform2Type, result->type);
 448   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 449   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 450   ASSERT_TRUE(bucket != NULL);
 451   EXPECT_EQ(
 452       0,
 453       memcmp(
 454           bucket->GetData(0, bucket->size()), kUniform2Name, bucket->size()));
 455 }
 456
 457 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformResultNotInitFails) {
 458   const GLuint kUniformIndex = 1;
 459   const uint32 kBucketId = 123;
 460   GetActiveUniform cmd;
 461   typedef GetActiveUniform::Result Result;
 462   Result* result = static_cast<Result*>(shared_memory_address_);
 463   result->success = 1;
 464   cmd.Init(client_program_id_,
 465            kUniformIndex,
 466            kBucketId,
 467            shared_memory_id_,
 468            shared_memory_offset_);
 469   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 470 }
 471
 472 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadProgramFails) {
 473   const GLuint kUniformIndex = 1;
 474   const uint32 kBucketId = 123;
 475   GetActiveUniform cmd;
 476   typedef GetActiveUniform::Result Result;
 477   Result* result = static_cast<Result*>(shared_memory_address_);
 478   result->success = 0;
 479   cmd.Init(kInvalidClientId,
 480            kUniformIndex,
 481            kBucketId,
 482            shared_memory_id_,
 483            shared_memory_offset_);
 484   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 485   EXPECT_EQ(0, result->success);
 486   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 487 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 488   result->success = 0;
 489   cmd.Init(client_shader_id_,
 490            kUniformIndex,
 491            kBucketId,
 492            shared_memory_id_,
 493            shared_memory_offset_);
 494   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 495   EXPECT_EQ(0, result->success);
 496   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 497 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 498 }
 499
 500 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadIndexFails) {
 501   const uint32 kBucketId = 123;
 502   GetActiveUniform cmd;
 503   typedef GetActiveUniform::Result Result;
 504   Result* result = static_cast<Result*>(shared_memory_address_);
 505   result->success = 0;
 506   cmd.Init(client_program_id_,
 507            kBadUniformIndex,
 508            kBucketId,
 509            shared_memory_id_,
 510            shared_memory_offset_);
 511   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 512   EXPECT_EQ(0, result->success);
 513   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 514 }
 515
 516 TEST_P(GLES2DecoderWithShaderTest, GetActiveUniformBadSharedMemoryFails) {
 517   const GLuint kUniformIndex = 1;
 518   const uint32 kBucketId = 123;
 519   GetActiveUniform cmd;
 520   cmd.Init(client_program_id_,
 521            kUniformIndex,
 522            kBucketId,
 523            kInvalidSharedMemoryId,
 524            shared_memory_offset_);
 525   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 526   cmd.Init(client_program_id_,
 527            kUniformIndex,
 528            kBucketId,
 529            shared_memory_id_,
 530            kInvalidSharedMemoryOffset);
 531   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 532 }
 533
 534 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribSucceeds) {
 535   const GLuint kAttribIndex = 1;
 536   const uint32 kBucketId = 123;
 537   GetActiveAttrib cmd;
 538   typedef GetActiveAttrib::Result Result;
 539   Result* result = static_cast<Result*>(shared_memory_address_);
 540   result->success = 0;
 541   cmd.Init(client_program_id_,
 542            kAttribIndex,
 543            kBucketId,
 544            shared_memory_id_,
 545            shared_memory_offset_);
 546   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 547   EXPECT_NE(0, result->success);
 548   EXPECT_EQ(kAttrib2Size, result->size);
 549   EXPECT_EQ(kAttrib2Type, result->type);
 550   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 551   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 552   ASSERT_TRUE(bucket != NULL);
 553   EXPECT_EQ(
 554       0,
 555       memcmp(bucket->GetData(0, bucket->size()), kAttrib2Name, bucket->size()));
 556 }
 557
 558 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribResultNotInitFails) {
 559   const GLuint kAttribIndex = 1;
 560   const uint32 kBucketId = 123;
 561   GetActiveAttrib cmd;
 562   typedef GetActiveAttrib::Result Result;
 563   Result* result = static_cast<Result*>(shared_memory_address_);
 564   result->success = 1;
 565   cmd.Init(client_program_id_,
 566            kAttribIndex,
 567            kBucketId,
 568            shared_memory_id_,
 569            shared_memory_offset_);
 570   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 571 }
 572
 573 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadProgramFails) {
 574   const GLuint kAttribIndex = 1;
 575   const uint32 kBucketId = 123;
 576   GetActiveAttrib cmd;
 577   typedef GetActiveAttrib::Result Result;
 578   Result* result = static_cast<Result*>(shared_memory_address_);
 579   result->success = 0;
 580   cmd.Init(kInvalidClientId,
 581            kAttribIndex,
 582            kBucketId,
 583            shared_memory_id_,
 584            shared_memory_offset_);
 585   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 586   EXPECT_EQ(0, result->success);
 587   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 588 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 589   result->success = 0;
 590   cmd.Init(client_shader_id_,
 591            kAttribIndex,
 592            kBucketId,
 593            shared_memory_id_,
 594            shared_memory_offset_);
 595   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 596   EXPECT_EQ(0, result->success);
 597   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 598 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 599 }
 600
 601 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadIndexFails) {
 602   const uint32 kBucketId = 123;
 603   GetActiveAttrib cmd;
 604   typedef GetActiveAttrib::Result Result;
 605   Result* result = static_cast<Result*>(shared_memory_address_);
 606   result->success = 0;
 607   cmd.Init(client_program_id_,
 608            kBadAttribIndex,
 609            kBucketId,
 610            shared_memory_id_,
 611            shared_memory_offset_);
 612   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 613   EXPECT_EQ(0, result->success);
 614   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 615 }
 616
 617 TEST_P(GLES2DecoderWithShaderTest, GetActiveAttribBadSharedMemoryFails) {
 618   const GLuint kAttribIndex = 1;
 619   const uint32 kBucketId = 123;
 620   GetActiveAttrib cmd;
 621   cmd.Init(client_program_id_,
 622            kAttribIndex,
 623            kBucketId,
 624            kInvalidSharedMemoryId,
 625            shared_memory_offset_);
 626   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 627   cmd.Init(client_program_id_,
 628            kAttribIndex,
 629            kBucketId,
 630            shared_memory_id_,
 631            kInvalidSharedMemoryOffset);
 632   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 633 }
 634
 635 TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogValidArgs) {
 636   const char* kInfo = "hello";
 637   const uint32 kBucketId = 123;
 638   CompileShader compile_cmd;
 639   GetShaderInfoLog cmd;
 640   EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _));
 641   EXPECT_CALL(*gl_, CompileShader(kServiceShaderId));
 642   EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _))
 643       .WillOnce(SetArgumentPointee<2>(GL_FALSE))
 644       .RetiresOnSaturation();
 645   EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_INFO_LOG_LENGTH, _))
 646       .WillOnce(SetArgumentPointee<2>(strlen(kInfo) + 1))
 647       .RetiresOnSaturation();
 648   EXPECT_CALL(*gl_, GetShaderInfoLog(kServiceShaderId, strlen(kInfo) + 1, _, _))
 649       .WillOnce(DoAll(SetArgumentPointee<2>(strlen(kInfo)),
 650                       SetArrayArgument<3>(kInfo, kInfo + strlen(kInfo) + 1)));
 651   compile_cmd.Init(client_shader_id_);
 652   cmd.Init(client_shader_id_, kBucketId);
 653   EXPECT_EQ(error::kNoError, ExecuteCmd(compile_cmd));
 654   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 655   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 656   ASSERT_TRUE(bucket != NULL);
 657   EXPECT_EQ(strlen(kInfo) + 1, bucket->size());
 658   EXPECT_EQ(0,
 659             memcmp(bucket->GetData(0, bucket->size()), kInfo, bucket->size()));
 660   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 661 }
 662
 663 TEST_P(GLES2DecoderWithShaderTest, GetShaderInfoLogInvalidArgs) {
 664   const uint32 kBucketId = 123;
 665   GetShaderInfoLog cmd;
 666   cmd.Init(kInvalidClientId, kBucketId);
 667   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 668   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 669 }
 670
 671 TEST_P(GLES2DecoderTest, CompileShaderValidArgs) {
 672   EXPECT_CALL(*gl_, ShaderSource(kServiceShaderId, 1, _, _));
 673   EXPECT_CALL(*gl_, CompileShader(kServiceShaderId));
 674   EXPECT_CALL(*gl_, GetShaderiv(kServiceShaderId, GL_COMPILE_STATUS, _))
 675       .WillOnce(SetArgumentPointee<2>(GL_TRUE))
 676       .RetiresOnSaturation();
 677   CompileShader cmd;
 678   cmd.Init(client_shader_id_);
 679   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 680 }
 681
 682 TEST_P(GLES2DecoderTest, CompileShaderInvalidArgs) {
 683   CompileShader cmd;
 684   cmd.Init(kInvalidClientId);
 685   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 686   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 687 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 688   cmd.Init(client_program_id_);
 689   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 690   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 691 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 692 }
 693
 694 TEST_P(GLES2DecoderTest, ShaderSourceBucketAndGetShaderSourceValidArgs) {
 695   const uint32 kInBucketId = 123;
 696   const uint32 kOutBucketId = 125;
 697   const char kSource[] = "hello";
 698   const uint32 kSourceSize = sizeof(kSource) - 1;
 699   SetBucketAsCString(kInBucketId, kSource);
 700   ShaderSourceBucket cmd;
 701   cmd.Init(client_shader_id_, kInBucketId);
 702   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 703   ClearSharedMemory();
 704   GetShaderSource get_cmd;
 705   get_cmd.Init(client_shader_id_, kOutBucketId);
 706   EXPECT_EQ(error::kNoError, ExecuteCmd(get_cmd));
 707   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kOutBucketId);
 708   ASSERT_TRUE(bucket != NULL);
 709   EXPECT_EQ(kSourceSize + 1, bucket->size());
 710   EXPECT_EQ(
 711       0, memcmp(bucket->GetData(0, bucket->size()), kSource, bucket->size()));
 712 }
 713
 714 TEST_P(GLES2DecoderTest, ShaderSourceBucketInvalidArgs) {
 715   const uint32 kBucketId = 123;
 716   const char kSource[] = "hello";
 717   const uint32 kSourceSize = sizeof(kSource) - 1;
 718   memcpy(shared_memory_address_, kSource, kSourceSize);
 719   ShaderSourceBucket cmd;
 720   // Test no bucket.
 721   cmd.Init(client_texture_id_, kBucketId);
 722   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 723   // Test invalid client.
 724   SetBucketAsCString(kBucketId, kSource);
 725   cmd.Init(kInvalidClientId, kBucketId);
 726   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 727   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 728 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 729   SetBucketAsCString(kBucketId, kSource);
 730   cmd.Init(
 731       client_program_id_, kBucketId);
 732   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 733   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 734 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 735 }
 736
 737 TEST_P(GLES2DecoderTest, ShaderSourceStripComments) {
 738   const uint32 kInBucketId = 123;
 739   const char kSource[] = "hello/*te\ast*/world//a\ab";
 740   SetBucketAsCString(kInBucketId, kSource);
 741   ShaderSourceBucket cmd;
 742   cmd.Init(client_shader_id_, kInBucketId);
 743   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 744   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 745 }
 746
 747 TEST_P(GLES2DecoderWithShaderTest, Uniform1iValidArgs) {
 748   EXPECT_CALL(*gl_, Uniform1i(kUniform1RealLocation, 2));
 749   Uniform1i cmd;
 750   cmd.Init(kUniform1FakeLocation, 2);
 751   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 752 }
 753
 754 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
 755   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
 756   EXPECT_CALL(*gl_,
 757               Uniform1iv(kUniform1RealLocation,
 758                          1,
 759                          reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
 760   GLint temp[1 * 2] = {
 761       0,
 762   };
 763   cmd.Init(kUniform1FakeLocation, 1, &temp[0]);
 764   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 765 }
 766
 767 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateInvalidValidArgs) {
 768   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
 769   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
 770   GLint temp[1 * 2] = {
 771       0,
 772   };
 773   cmd.Init(kUniform1FakeLocation, 2, &temp[0]);
 774   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 775   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 776 }
 777
 778 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivZeroCount) {
 779   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
 780   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
 781   GLint temp = 0;
 782   cmd.Init(kUniform1FakeLocation, 0, &temp);
 783   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 784   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 785 }
 786
 787 TEST_P(GLES2DecoderWithShaderTest, Uniform1iSamplerIsLmited) {
 788   EXPECT_CALL(*gl_, Uniform1i(_, _)).Times(0);
 789   Uniform1i cmd;
 790   cmd.Init(kUniform1FakeLocation, kNumTextureUnits);
 791   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 792   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 793 }
 794
 795 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivSamplerIsLimited) {
 796   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
 797   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
 798   GLint temp[] = {kNumTextureUnits};
 799   cmd.Init(kUniform1FakeLocation, 1, &temp[0]);
 800   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 801   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 802 }
 803
 804 TEST_P(GLES2DecoderTest, BindAttribLocationBucket) {
 805   const uint32 kBucketId = 123;
 806   const GLint kLocation = 2;
 807   const char* kName = "testing";
 808   EXPECT_CALL(*gl_,
 809               BindAttribLocation(kServiceProgramId, kLocation, StrEq(kName)))
 810       .Times(1);
 811   SetBucketAsCString(kBucketId, kName);
 812   BindAttribLocationBucket cmd;
 813   cmd.Init(client_program_id_, kLocation, kBucketId);
 814   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 815 }
 816
 817 TEST_P(GLES2DecoderTest, BindAttribLocationBucketInvalidArgs) {
 818   const uint32 kBucketId = 123;
 819   const GLint kLocation = 2;
 820   const char* kName = "testing";
 821   EXPECT_CALL(*gl_, BindAttribLocation(_, _, _)).Times(0);
 822   BindAttribLocationBucket cmd;
 823   // check bucket does not exist.
 824   cmd.Init(client_program_id_, kLocation, kBucketId);
 825   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 826   // check bucket is empty.
 827   SetBucketAsCString(kBucketId, NULL);
 828   cmd.Init(client_program_id_, kLocation, kBucketId);
 829   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 830   // Check bad program id
 831   SetBucketAsCString(kBucketId, kName);
 832   cmd.Init(kInvalidClientId, kLocation, kBucketId);
 833   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 834   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 835 }
 836
 837 TEST_P(GLES2DecoderWithShaderTest, GetAttribLocation) {
 838   const uint32 kBucketId = 123;
 839   const char* kNonExistentName = "foobar";
 840   typedef GetAttribLocation::Result Result;
 841   Result* result = GetSharedMemoryAs<Result*>();
 842   SetBucketAsCString(kBucketId, kAttrib2Name);
 843   *result = -1;
 844   GetAttribLocation cmd;
 845   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
 846   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 847   EXPECT_EQ(kAttrib2Location, *result);
 848   SetBucketAsCString(kBucketId, kNonExistentName);
 849   *result = -1;
 850   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
 851   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 852   EXPECT_EQ(-1, *result);
 853 }
 854
 855 TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) {
 856   const uint32 kBucketId = 123;
 857   typedef GetAttribLocation::Result Result;
 858   Result* result = GetSharedMemoryAs<Result*>();
 859   *result = -1;
 860   GetAttribLocation cmd;
 861   // Check no bucket
 862   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
 863   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 864   EXPECT_EQ(-1, *result);
 865   // Check bad program id.
 866   SetBucketAsCString(kBucketId, kAttrib2Name);
 867   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
 868   *result = -1;
 869   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 870   EXPECT_EQ(-1, *result);
 871   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 872   // Check bad memory
 873   cmd.Init(client_program_id_,
 874            kBucketId,
 875            kInvalidSharedMemoryId,
 876            kSharedMemoryOffset);
 877   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 878   cmd.Init(client_program_id_,
 879            kBucketId,
 880            kSharedMemoryId,
 881            kInvalidSharedMemoryOffset);
 882   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 883 }
 884
 885 TEST_P(GLES2DecoderWithShaderTest, GetUniformLocation) {
 886   const uint32 kBucketId = 123;
 887   const char* kNonExistentName = "foobar";
 888   typedef GetUniformLocation::Result Result;
 889   Result* result = GetSharedMemoryAs<Result*>();
 890   SetBucketAsCString(kBucketId, kUniform2Name);
 891   *result = -1;
 892   GetUniformLocation cmd;
 893   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
 894   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 895   EXPECT_EQ(kUniform2FakeLocation, *result);
 896   SetBucketAsCString(kBucketId, kNonExistentName);
 897   *result = -1;
 898   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
 899   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 900   EXPECT_EQ(-1, *result);
 901 }
 902
 903 TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationInvalidArgs) {
 904   const uint32 kBucketId = 123;
 905   typedef GetUniformLocation::Result Result;
 906   Result* result = GetSharedMemoryAs<Result*>();
 907   *result = -1;
 908   GetUniformLocation cmd;
 909   // Check no bucket
 910   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
 911   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 912   EXPECT_EQ(-1, *result);
 913   // Check bad program id.
 914   SetBucketAsCString(kBucketId, kUniform2Name);
 915   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
 916   *result = -1;
 917   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 918   EXPECT_EQ(-1, *result);
 919   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 920   // Check bad memory
 921   cmd.Init(client_program_id_,
 922            kBucketId,
 923            kInvalidSharedMemoryId,
 924            kSharedMemoryOffset);
 925   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 926   cmd.Init(client_program_id_,
 927            kBucketId,
 928            kSharedMemoryId,
 929            kInvalidSharedMemoryOffset);
 930   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 931 }
 932
 933 TEST_P(GLES2DecoderWithShaderTest, BindUniformLocationCHROMIUMBucket) {
 934   const uint32 kBucketId = 123;
 935   const GLint kLocation = 2;
 936   const char* kName = "testing";
 937   const char* kBadName1 = "gl_testing";
 938   const char* kBadName2 = "testing[1]";
 939
 940   SetBucketAsCString(kBucketId, kName);
 941   BindUniformLocationCHROMIUMBucket cmd;
 942   cmd.Init(client_program_id_,
 943            kLocation,
 944            kBucketId);
 945   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 946   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 947   // check negative location
 948   SetBucketAsCString(kBucketId, kName);
 949   cmd.Init(client_program_id_, -1, kBucketId);
 950   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 951   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 952   // check highest location
 953   SetBucketAsCString(kBucketId, kName);
 954   GLint kMaxLocation =
 955       (kMaxFragmentUniformVectors + kMaxVertexUniformVectors) * 4 - 1;
 956   cmd.Init(client_program_id_,
 957            kMaxLocation,
 958            kBucketId);
 959   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 960   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 961   // check too high location
 962   SetBucketAsCString(kBucketId, kName);
 963   cmd.Init(client_program_id_,
 964            kMaxLocation + 1,
 965            kBucketId);
 966   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 967   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 968   // check bad name "gl_..."
 969   SetBucketAsCString(kBucketId, kBadName1);
 970   cmd.Init(client_program_id_,
 971            kLocation,
 972            kBucketId);
 973   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 974   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 975   // check bad name "name[1]" non zero
 976   SetBucketAsCString(kBucketId, kBadName2);
 977   cmd.Init(client_program_id_,
 978            kLocation,
 979            kBucketId);
 980   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 981   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 982 }
 983
 984 TEST_P(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) {
 985   CommandLine command_line(0, NULL);
 986   command_line.AppendSwitchASCII(
 987       switches::kGpuDriverBugWorkarounds,
 988       base::IntToString(gpu::CLEAR_UNIFORMS_BEFORE_FIRST_PROGRAM_USE));
 989   InitState init;
 990   init.gl_version = "3.0";
 991   init.has_alpha = true;
 992   init.request_alpha = true;
 993   init.bind_generates_resource = true;
 994   InitDecoderWithCommandLine(init, &command_line);
 995   {
 996     static AttribInfo attribs[] = {
 997         {
 998          kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location,
 999         },
1000         {
1001          kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location,
1002         },
1003         {
1004          kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location,
1005         },
1006     };
1007     static UniformInfo uniforms[] = {
1008         {kUniform1Name, kUniform1Size, kUniform1Type, kUniform1FakeLocation,
1009          kUniform1RealLocation, kUniform1DesiredLocation},
1010         {kUniform2Name, kUniform2Size, kUniform2Type, kUniform2FakeLocation,
1011          kUniform2RealLocation, kUniform2DesiredLocation},
1012         {kUniform3Name, kUniform3Size, kUniform3Type, kUniform3FakeLocation,
1013          kUniform3RealLocation, kUniform3DesiredLocation},
1014     };
1015     SetupShader(attribs,
1016                 arraysize(attribs),
1017                 uniforms,
1018                 arraysize(uniforms),
1019                 client_program_id_,
1020                 kServiceProgramId,
1021                 client_vertex_shader_id_,
1022                 kServiceVertexShaderId,
1023                 client_fragment_shader_id_,
1024                 kServiceFragmentShaderId);
1025     TestHelper::SetupExpectationsForClearingUniforms(
1026         gl_.get(), uniforms, arraysize(uniforms));
1027   }
1028
1029   {
1030     EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
1031         .Times(1)
1032         .RetiresOnSaturation();
1033     cmds::UseProgram cmd;
1034     cmd.Init(client_program_id_);
1035     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1036   }
1037 }
1038
1039 // TODO(gman): DeleteProgram
1040
1041 // TODO(gman): UseProgram
1042
1043 // TODO(gman): DeleteShader
1044
1045 }  // namespace gles2
1046 }  // namespace gpu