src/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, ShaderSourceAndGetShaderSourceValidArgs) {
 695   const uint32 kBucketId = 123;
 696   const char kSource[] = "hello";
 697   const uint32 kSourceSize = sizeof(kSource) - 1;
 698   memcpy(shared_memory_address_, kSource, kSourceSize);
 699   ShaderSource cmd;
 700   cmd.Init(
 701       client_shader_id_, kSharedMemoryId, kSharedMemoryOffset, kSourceSize);
 702   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 703   memset(shared_memory_address_, 0, kSourceSize);
 704   GetShaderSource get_cmd;
 705   get_cmd.Init(client_shader_id_, kBucketId);
 706   EXPECT_EQ(error::kNoError, ExecuteCmd(get_cmd));
 707   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
 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, ShaderSourceInvalidArgs) {
 715   const char kSource[] = "hello";
 716   const uint32 kSourceSize = sizeof(kSource) - 1;
 717   memcpy(shared_memory_address_, kSource, kSourceSize);
 718   ShaderSource cmd;
 719   cmd.Init(kInvalidClientId, kSharedMemoryId, kSharedMemoryOffset, kSourceSize);
 720   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 721   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 722 #if GLES2_TEST_SHADER_VS_PROGRAM_IDS
 723   cmd.Init(
 724       client_program_id_, kSharedMemoryId, kSharedMemoryOffset, kSourceSize);
 725   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 726   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 727 #endif  // GLES2_TEST_SHADER_VS_PROGRAM_IDS
 728   cmd.Init(client_shader_id_,
 729            kInvalidSharedMemoryId,
 730            kSharedMemoryOffset,
 731            kSourceSize);
 732   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 733   cmd.Init(client_shader_id_,
 734            kSharedMemoryId,
 735            kInvalidSharedMemoryOffset,
 736            kSourceSize);
 737   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 738   cmd.Init(client_shader_id_,
 739            kSharedMemoryId,
 740            kSharedMemoryOffset,
 741            kSharedBufferSize);
 742   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 743 }
 744
 745 TEST_P(GLES2DecoderTest, ShaderSourceBucketAndGetShaderSourceValidArgs) {
 746   const uint32 kInBucketId = 123;
 747   const uint32 kOutBucketId = 125;
 748   const char kSource[] = "hello";
 749   const uint32 kSourceSize = sizeof(kSource) - 1;
 750   SetBucketAsCString(kInBucketId, kSource);
 751   ShaderSourceBucket cmd;
 752   cmd.Init(client_shader_id_, kInBucketId);
 753   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 754   ClearSharedMemory();
 755   GetShaderSource get_cmd;
 756   get_cmd.Init(client_shader_id_, kOutBucketId);
 757   EXPECT_EQ(error::kNoError, ExecuteCmd(get_cmd));
 758   CommonDecoder::Bucket* bucket = decoder_->GetBucket(kOutBucketId);
 759   ASSERT_TRUE(bucket != NULL);
 760   EXPECT_EQ(kSourceSize + 1, bucket->size());
 761   EXPECT_EQ(
 762       0, memcmp(bucket->GetData(0, bucket->size()), kSource, bucket->size()));
 763 }
 764
 765 TEST_P(GLES2DecoderTest, ShaderSourceBucketInvalidArgs) {
 766   const uint32 kBucketId = 123;
 767   const char kSource[] = "hello";
 768   const uint32 kSourceSize = sizeof(kSource) - 1;
 769   memcpy(shared_memory_address_, kSource, kSourceSize);
 770   ShaderSourceBucket cmd;
 771   // Test no bucket.
 772   cmd.Init(client_texture_id_, kBucketId);
 773   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 774   // Test invalid client.
 775   SetBucketAsCString(kBucketId, kSource);
 776   cmd.Init(kInvalidClientId, kBucketId);
 777   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 778   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 779 }
 780
 781 TEST_P(GLES2DecoderTest, ShaderSourceStripComments) {
 782   const uint32 kInBucketId = 123;
 783   const char kSource[] = "hello/*te\ast*/world//a\ab";
 784   SetBucketAsCString(kInBucketId, kSource);
 785   ShaderSourceBucket cmd;
 786   cmd.Init(client_shader_id_, kInBucketId);
 787   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 788   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 789 }
 790
 791 TEST_P(GLES2DecoderWithShaderTest, Uniform1iValidArgs) {
 792   EXPECT_CALL(*gl_, Uniform1i(kUniform1RealLocation, 2));
 793   Uniform1i cmd;
 794   cmd.Init(kUniform1FakeLocation, 2);
 795   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 796 }
 797
 798 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivValidArgs) {
 799   EXPECT_CALL(
 800       *gl_,
 801       Uniform1iv(kUniform1RealLocation,
 802                  1,
 803                  reinterpret_cast<const GLint*>(shared_memory_address_)));
 804   Uniform1iv cmd;
 805   cmd.Init(kUniform1FakeLocation, 1, shared_memory_id_, shared_memory_offset_);
 806   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 807 }
 808
 809 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_0) {
 810   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
 811   Uniform1iv cmd;
 812   cmd.Init(kUniform1FakeLocation, 1, kInvalidSharedMemoryId, 0);
 813   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 814 }
 815
 816 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidArgs2_1) {
 817   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
 818   Uniform1iv cmd;
 819   cmd.Init(
 820       kUniform1FakeLocation, 1, shared_memory_id_, kInvalidSharedMemoryOffset);
 821   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 822 }
 823
 824 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivImmediateValidArgs) {
 825   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
 826   EXPECT_CALL(*gl_,
 827               Uniform1iv(kUniform1RealLocation,
 828                          1,
 829                          reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
 830   GLint temp[1 * 2] = {
 831       0,
 832   };
 833   cmd.Init(kUniform1FakeLocation, 1, &temp[0]);
 834   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 835 }
 836
 837 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivInvalidValidArgs) {
 838   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
 839   Uniform1iv cmd;
 840   cmd.Init(kUniform1FakeLocation, 2, shared_memory_id_, shared_memory_offset_);
 841   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 842   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 843 }
 844
 845 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivZeroCount) {
 846   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
 847   Uniform1iv cmd;
 848   cmd.Init(kUniform1FakeLocation, 0, shared_memory_id_, shared_memory_offset_);
 849   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 850   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 851 }
 852
 853 TEST_P(GLES2DecoderWithShaderTest, Uniform1iSamplerIsLmited) {
 854   EXPECT_CALL(*gl_, Uniform1i(_, _)).Times(0);
 855   Uniform1i cmd;
 856   cmd.Init(kUniform1FakeLocation, kNumTextureUnits);
 857   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 858   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 859 }
 860
 861 TEST_P(GLES2DecoderWithShaderTest, Uniform1ivSamplerIsLimited) {
 862   EXPECT_CALL(*gl_, Uniform1iv(_, _, _)).Times(0);
 863   Uniform1ivImmediate& cmd = *GetImmediateAs<Uniform1ivImmediate>();
 864   GLint temp[] = {kNumTextureUnits};
 865   cmd.Init(kUniform1FakeLocation, 1, &temp[0]);
 866   EXPECT_EQ(error::kNoError, ExecuteImmediateCmd(cmd, sizeof(temp)));
 867   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 868 }
 869
 870 TEST_P(GLES2DecoderTest, BindAttribLocation) {
 871   const GLint kLocation = 2;
 872   const char* kName = "testing";
 873   const uint32 kNameSize = strlen(kName);
 874   EXPECT_CALL(*gl_,
 875               BindAttribLocation(kServiceProgramId, kLocation, StrEq(kName)))
 876       .Times(1);
 877   memcpy(shared_memory_address_, kName, kNameSize);
 878   BindAttribLocation cmd;
 879   cmd.Init(client_program_id_,
 880            kLocation,
 881            kSharedMemoryId,
 882            kSharedMemoryOffset,
 883            kNameSize);
 884   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 885 }
 886
 887 TEST_P(GLES2DecoderTest, BindAttribLocationInvalidArgs) {
 888   const GLint kLocation = 2;
 889   const char* kName = "testing";
 890   const char* kBadName = "test\aing";
 891   const uint32 kNameSize = strlen(kName);
 892   const uint32 kBadNameSize = strlen(kBadName);
 893   EXPECT_CALL(*gl_, BindAttribLocation(_, _, _)).Times(0);
 894   memcpy(shared_memory_address_, kName, kNameSize);
 895   BindAttribLocation cmd;
 896   cmd.Init(kInvalidClientId,
 897            kLocation,
 898            kSharedMemoryId,
 899            kSharedMemoryOffset,
 900            kNameSize);
 901   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 902   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 903   cmd.Init(client_program_id_,
 904            kLocation,
 905            kInvalidSharedMemoryId,
 906            kSharedMemoryOffset,
 907            kNameSize);
 908   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 909   cmd.Init(client_program_id_,
 910            kLocation,
 911            kSharedMemoryId,
 912            kInvalidSharedMemoryOffset,
 913            kNameSize);
 914   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 915   cmd.Init(client_program_id_,
 916            kLocation,
 917            kSharedMemoryId,
 918            kSharedMemoryOffset,
 919            kSharedBufferSize);
 920   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 921   memcpy(shared_memory_address_, kBadName, kBadNameSize);
 922   cmd.Init(client_program_id_,
 923            kLocation,
 924            kSharedMemoryId,
 925            kSharedMemoryOffset,
 926            kBadNameSize);
 927   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 928   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 929 }
 930
 931 TEST_P(GLES2DecoderTest, BindAttribLocationBucket) {
 932   const uint32 kBucketId = 123;
 933   const GLint kLocation = 2;
 934   const char* kName = "testing";
 935   EXPECT_CALL(*gl_,
 936               BindAttribLocation(kServiceProgramId, kLocation, StrEq(kName)))
 937       .Times(1);
 938   SetBucketAsCString(kBucketId, kName);
 939   BindAttribLocationBucket cmd;
 940   cmd.Init(client_program_id_, kLocation, kBucketId);
 941   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 942 }
 943
 944 TEST_P(GLES2DecoderTest, BindAttribLocationBucketInvalidArgs) {
 945   const uint32 kBucketId = 123;
 946   const GLint kLocation = 2;
 947   const char* kName = "testing";
 948   EXPECT_CALL(*gl_, BindAttribLocation(_, _, _)).Times(0);
 949   BindAttribLocationBucket cmd;
 950   // check bucket does not exist.
 951   cmd.Init(client_program_id_, kLocation, kBucketId);
 952   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 953   // check bucket is empty.
 954   SetBucketAsCString(kBucketId, NULL);
 955   cmd.Init(client_program_id_, kLocation, kBucketId);
 956   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 957   // Check bad program id
 958   SetBucketAsCString(kBucketId, kName);
 959   cmd.Init(kInvalidClientId, kLocation, kBucketId);
 960   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 961   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 962 }
 963
 964 TEST_P(GLES2DecoderWithShaderTest, GetAttribLocation) {
 965   const uint32 kNameSize = strlen(kAttrib2Name);
 966   const char* kNonExistentName = "foobar";
 967   const uint32 kNonExistentNameSize = strlen(kNonExistentName);
 968   typedef GetAttribLocation::Result Result;
 969   Result* result = GetSharedMemoryAs<Result*>();
 970   *result = -1;
 971   char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result));
 972   const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result);
 973   memcpy(name, kAttrib2Name, kNameSize);
 974   GetAttribLocation cmd;
 975   cmd.Init(client_program_id_,
 976            kSharedMemoryId,
 977            kNameOffset,
 978            kSharedMemoryId,
 979            kSharedMemoryOffset,
 980            kNameSize);
 981   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 982   EXPECT_EQ(kAttrib2Location, *result);
 983   *result = -1;
 984   memcpy(name, kNonExistentName, kNonExistentNameSize);
 985   cmd.Init(client_program_id_,
 986            kSharedMemoryId,
 987            kNameOffset,
 988            kSharedMemoryId,
 989            kSharedMemoryOffset,
 990            kNonExistentNameSize);
 991   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 992   EXPECT_EQ(-1, *result);
 993 }
 994
 995 TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationInvalidArgs) {
 996   const uint32 kNameSize = strlen(kAttrib2Name);
 997   const char* kBadName = "foo\abar";
 998   const uint32 kBadNameSize = strlen(kBadName);
 999   typedef GetAttribLocation::Result Result;
1000   Result* result = GetSharedMemoryAs<Result*>();
1001   *result = -1;
1002   char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result));
1003   const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result);
1004   memcpy(name, kAttrib2Name, kNameSize);
1005   GetAttribLocation cmd;
1006   cmd.Init(kInvalidClientId,
1007            kSharedMemoryId,
1008            kNameOffset,
1009            kSharedMemoryId,
1010            kSharedMemoryOffset,
1011            kNameSize);
1012   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1013   EXPECT_EQ(-1, *result);
1014   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1015   *result = -1;
1016   cmd.Init(client_program_id_,
1017            kInvalidSharedMemoryId,
1018            kNameOffset,
1019            kSharedMemoryId,
1020            kSharedMemoryOffset,
1021            kNameSize);
1022   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1023   EXPECT_EQ(-1, *result);
1024   cmd.Init(client_program_id_,
1025            kSharedMemoryId,
1026            kInvalidSharedMemoryOffset,
1027            kSharedMemoryId,
1028            kSharedMemoryOffset,
1029            kNameSize);
1030   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1031   EXPECT_EQ(-1, *result);
1032   cmd.Init(client_program_id_,
1033            kSharedMemoryId,
1034            kNameOffset,
1035            kInvalidSharedMemoryId,
1036            kSharedMemoryOffset,
1037            kNameSize);
1038   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1039   EXPECT_EQ(-1, *result);
1040   cmd.Init(client_program_id_,
1041            kSharedMemoryId,
1042            kNameOffset,
1043            kSharedMemoryId,
1044            kInvalidSharedMemoryOffset,
1045            kNameSize);
1046   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1047   EXPECT_EQ(-1, *result);
1048   cmd.Init(client_program_id_,
1049            kSharedMemoryId,
1050            kNameOffset,
1051            kSharedMemoryId,
1052            kSharedMemoryOffset,
1053            kSharedBufferSize);
1054   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1055   EXPECT_EQ(-1, *result);
1056   memcpy(name, kBadName, kBadNameSize);
1057   cmd.Init(client_program_id_,
1058            kSharedMemoryId,
1059            kNameOffset,
1060            kSharedMemoryId,
1061            kSharedMemoryOffset,
1062            kBadNameSize);
1063   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1064   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1065 }
1066
1067 TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationBucket) {
1068   const uint32 kBucketId = 123;
1069   const char* kNonExistentName = "foobar";
1070   typedef GetAttribLocationBucket::Result Result;
1071   Result* result = GetSharedMemoryAs<Result*>();
1072   SetBucketAsCString(kBucketId, kAttrib2Name);
1073   *result = -1;
1074   GetAttribLocationBucket cmd;
1075   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1076   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1077   EXPECT_EQ(kAttrib2Location, *result);
1078   SetBucketAsCString(kBucketId, kNonExistentName);
1079   *result = -1;
1080   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1081   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1082   EXPECT_EQ(-1, *result);
1083 }
1084
1085 TEST_P(GLES2DecoderWithShaderTest, GetAttribLocationBucketInvalidArgs) {
1086   const uint32 kBucketId = 123;
1087   typedef GetAttribLocationBucket::Result Result;
1088   Result* result = GetSharedMemoryAs<Result*>();
1089   *result = -1;
1090   GetAttribLocationBucket cmd;
1091   // Check no bucket
1092   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1093   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1094   EXPECT_EQ(-1, *result);
1095   // Check bad program id.
1096   SetBucketAsCString(kBucketId, kAttrib2Name);
1097   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1098   *result = -1;
1099   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1100   EXPECT_EQ(-1, *result);
1101   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1102   // Check bad memory
1103   cmd.Init(client_program_id_,
1104            kBucketId,
1105            kInvalidSharedMemoryId,
1106            kSharedMemoryOffset);
1107   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1108   cmd.Init(client_program_id_,
1109            kBucketId,
1110            kSharedMemoryId,
1111            kInvalidSharedMemoryOffset);
1112   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1113 }
1114
1115 TEST_P(GLES2DecoderWithShaderTest, GetUniformLocation) {
1116   const uint32 kNameSize = strlen(kUniform2Name);
1117   const char* kNonExistentName = "foobar";
1118   const uint32 kNonExistentNameSize = strlen(kNonExistentName);
1119   typedef GetUniformLocation::Result Result;
1120   Result* result = GetSharedMemoryAs<Result*>();
1121   *result = -1;
1122   char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result));
1123   const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result);
1124   memcpy(name, kUniform2Name, kNameSize);
1125   GetUniformLocation cmd;
1126   cmd.Init(client_program_id_,
1127            kSharedMemoryId,
1128            kNameOffset,
1129            kSharedMemoryId,
1130            kSharedMemoryOffset,
1131            kNameSize);
1132   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1133   EXPECT_EQ(kUniform2FakeLocation, *result);
1134   memcpy(name, kNonExistentName, kNonExistentNameSize);
1135   *result = -1;
1136   cmd.Init(client_program_id_,
1137            kSharedMemoryId,
1138            kNameOffset,
1139            kSharedMemoryId,
1140            kSharedMemoryOffset,
1141            kNonExistentNameSize);
1142   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1143   EXPECT_EQ(-1, *result);
1144 }
1145
1146 TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationInvalidArgs) {
1147   const uint32 kNameSize = strlen(kUniform2Name);
1148   const char* kBadName = "foo\abar";
1149   const uint32 kBadNameSize = strlen(kBadName);
1150   typedef GetUniformLocation::Result Result;
1151   Result* result = GetSharedMemoryAs<Result*>();
1152   *result = -1;
1153   char* name = GetSharedMemoryAsWithOffset<char*>(sizeof(*result));
1154   const uint32 kNameOffset = kSharedMemoryOffset + sizeof(*result);
1155   memcpy(name, kUniform2Name, kNameSize);
1156   GetUniformLocation cmd;
1157   cmd.Init(kInvalidClientId,
1158            kSharedMemoryId,
1159            kNameOffset,
1160            kSharedMemoryId,
1161            kSharedMemoryOffset,
1162            kNameSize);
1163   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1164   EXPECT_EQ(-1, *result);
1165   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1166   *result = -1;
1167   cmd.Init(client_program_id_,
1168            kInvalidSharedMemoryId,
1169            kNameOffset,
1170            kSharedMemoryId,
1171            kSharedMemoryOffset,
1172            kNameSize);
1173   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1174   EXPECT_EQ(-1, *result);
1175   cmd.Init(client_program_id_,
1176            kSharedMemoryId,
1177            kInvalidSharedMemoryOffset,
1178            kSharedMemoryId,
1179            kSharedMemoryOffset,
1180            kNameSize);
1181   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1182   EXPECT_EQ(-1, *result);
1183   cmd.Init(client_program_id_,
1184            kSharedMemoryId,
1185            kNameOffset,
1186            kInvalidSharedMemoryId,
1187            kSharedMemoryOffset,
1188            kNameSize);
1189   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1190   EXPECT_EQ(-1, *result);
1191   cmd.Init(client_program_id_,
1192            kSharedMemoryId,
1193            kNameOffset,
1194            kSharedMemoryId,
1195            kInvalidSharedMemoryOffset,
1196            kNameSize);
1197   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1198   EXPECT_EQ(-1, *result);
1199   cmd.Init(client_program_id_,
1200            kSharedMemoryId,
1201            kNameOffset,
1202            kSharedMemoryId,
1203            kSharedMemoryOffset,
1204            kSharedBufferSize);
1205   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1206   EXPECT_EQ(-1, *result);
1207   memcpy(name, kBadName, kBadNameSize);
1208   cmd.Init(client_program_id_,
1209            kSharedMemoryId,
1210            kNameOffset,
1211            kSharedMemoryId,
1212            kSharedMemoryOffset,
1213            kBadNameSize);
1214   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1215   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1216 }
1217
1218 TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationBucket) {
1219   const uint32 kBucketId = 123;
1220   const char* kNonExistentName = "foobar";
1221   typedef GetUniformLocationBucket::Result Result;
1222   Result* result = GetSharedMemoryAs<Result*>();
1223   SetBucketAsCString(kBucketId, kUniform2Name);
1224   *result = -1;
1225   GetUniformLocationBucket cmd;
1226   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1227   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1228   EXPECT_EQ(kUniform2FakeLocation, *result);
1229   SetBucketAsCString(kBucketId, kNonExistentName);
1230   *result = -1;
1231   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1232   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1233   EXPECT_EQ(-1, *result);
1234 }
1235
1236 TEST_P(GLES2DecoderWithShaderTest, GetUniformLocationBucketInvalidArgs) {
1237   const uint32 kBucketId = 123;
1238   typedef GetUniformLocationBucket::Result Result;
1239   Result* result = GetSharedMemoryAs<Result*>();
1240   *result = -1;
1241   GetUniformLocationBucket cmd;
1242   // Check no bucket
1243   cmd.Init(client_program_id_, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1244   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1245   EXPECT_EQ(-1, *result);
1246   // Check bad program id.
1247   SetBucketAsCString(kBucketId, kUniform2Name);
1248   cmd.Init(kInvalidClientId, kBucketId, kSharedMemoryId, kSharedMemoryOffset);
1249   *result = -1;
1250   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1251   EXPECT_EQ(-1, *result);
1252   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1253   // Check bad memory
1254   cmd.Init(client_program_id_,
1255            kBucketId,
1256            kInvalidSharedMemoryId,
1257            kSharedMemoryOffset);
1258   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1259   cmd.Init(client_program_id_,
1260            kBucketId,
1261            kSharedMemoryId,
1262            kInvalidSharedMemoryOffset);
1263   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
1264 }
1265
1266 TEST_P(GLES2DecoderWithShaderTest, BindUniformLocationCHROMIUM) {
1267   const GLint kLocation = 2;
1268   const char* kName = "testing";
1269   const uint32 kNameSize = strlen(kName);
1270   const char* kBadName1 = "gl_testing";
1271   const uint32 kBadName1Size = strlen(kBadName1);
1272   const char* kBadName2 = "testing[1]";
1273   const uint32 kBadName2Size = strlen(kBadName2);
1274   memcpy(shared_memory_address_, kName, kNameSize);
1275   BindUniformLocationCHROMIUM cmd;
1276   cmd.Init(client_program_id_,
1277            kLocation,
1278            kSharedMemoryId,
1279            kSharedMemoryOffset,
1280            kNameSize);
1281   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1282   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1283   // check negative location
1284   memcpy(shared_memory_address_, kName, kNameSize);
1285   cmd.Init(
1286       client_program_id_, -1, kSharedMemoryId, kSharedMemoryOffset, kNameSize);
1287   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1288   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1289   // check highest location
1290   memcpy(shared_memory_address_, kName, kNameSize);
1291   GLint kMaxLocation =
1292       (kMaxFragmentUniformVectors + kMaxVertexUniformVectors) * 4 - 1;
1293   cmd.Init(client_program_id_,
1294            kMaxLocation,
1295            kSharedMemoryId,
1296            kSharedMemoryOffset,
1297            kNameSize);
1298   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1299   EXPECT_EQ(GL_NO_ERROR, GetGLError());
1300   // check too high location
1301   memcpy(shared_memory_address_, kName, kNameSize);
1302   cmd.Init(client_program_id_,
1303            kMaxLocation + 1,
1304            kSharedMemoryId,
1305            kSharedMemoryOffset,
1306            kNameSize);
1307   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1308   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1309   // check bad name "gl_..."
1310   memcpy(shared_memory_address_, kBadName1, kBadName1Size);
1311   cmd.Init(client_program_id_,
1312            kLocation,
1313            kSharedMemoryId,
1314            kSharedMemoryOffset,
1315            kBadName1Size);
1316   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1317   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
1318   // check bad name "name[1]" non zero
1319   memcpy(shared_memory_address_, kBadName2, kBadName2Size);
1320   cmd.Init(client_program_id_,
1321            kLocation,
1322            kSharedMemoryId,
1323            kSharedMemoryOffset,
1324            kBadName2Size);
1325   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1326   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
1327 }
1328
1329 TEST_P(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) {
1330   CommandLine command_line(0, NULL);
1331   command_line.AppendSwitchASCII(
1332       switches::kGpuDriverBugWorkarounds,
1333       base::IntToString(gpu::CLEAR_UNIFORMS_BEFORE_FIRST_PROGRAM_USE));
1334   InitState init;
1335   init.gl_version = "3.0";
1336   init.has_alpha = true;
1337   init.request_alpha = true;
1338   init.bind_generates_resource = true;
1339   InitDecoderWithCommandLine(init, &command_line);
1340   {
1341     static AttribInfo attribs[] = {
1342         {
1343          kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location,
1344         },
1345         {
1346          kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location,
1347         },
1348         {
1349          kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location,
1350         },
1351     };
1352     static UniformInfo uniforms[] = {
1353         {kUniform1Name, kUniform1Size, kUniform1Type, kUniform1FakeLocation,
1354          kUniform1RealLocation, kUniform1DesiredLocation},
1355         {kUniform2Name, kUniform2Size, kUniform2Type, kUniform2FakeLocation,
1356          kUniform2RealLocation, kUniform2DesiredLocation},
1357         {kUniform3Name, kUniform3Size, kUniform3Type, kUniform3FakeLocation,
1358          kUniform3RealLocation, kUniform3DesiredLocation},
1359     };
1360     SetupShader(attribs,
1361                 arraysize(attribs),
1362                 uniforms,
1363                 arraysize(uniforms),
1364                 client_program_id_,
1365                 kServiceProgramId,
1366                 client_vertex_shader_id_,
1367                 kServiceVertexShaderId,
1368                 client_fragment_shader_id_,
1369                 kServiceFragmentShaderId);
1370     TestHelper::SetupExpectationsForClearingUniforms(
1371         gl_.get(), uniforms, arraysize(uniforms));
1372   }
1373
1374   {
1375     EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
1376         .Times(1)
1377         .RetiresOnSaturation();
1378     cmds::UseProgram cmd;
1379     cmd.Init(client_program_id_);
1380     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
1381   }
1382 }
1383
1384 // TODO(gman): DeleteProgram
1385
1386 // TODO(gman): UseProgram
1387
1388 // TODO(gman): DeleteShader
1389
1390 }  // namespace gles2
1391 }  // namespace gpu