gpu/command_buffer/service/program_manager_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/program_manager.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/strings/string_util.h"
  12 #include "gpu/command_buffer/common/gles2_cmd_format.h"
  13 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  14 #include "gpu/command_buffer/service/common_decoder.h"
  15 #include "gpu/command_buffer/service/feature_info.h"
  16 #include "gpu/command_buffer/service/gpu_service_test.h"
  17 #include "gpu/command_buffer/service/mocks.h"
  18 #include "gpu/command_buffer/service/shader_manager.h"
  19 #include "gpu/command_buffer/service/test_helper.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21 #include "ui/gl/gl_mock.h"
  22
  23 using ::testing::_;
  24 using ::testing::DoAll;
  25 using ::testing::InSequence;
  26 using ::testing::MatcherCast;
  27 using ::testing::Pointee;
  28 using ::testing::Return;
  29 using ::testing::ReturnRef;
  30 using ::testing::SetArrayArgument;
  31 using ::testing::SetArgumentPointee;
  32 using ::testing::StrEq;
  33
  34 namespace gpu {
  35 namespace gles2 {
  36
  37 namespace {
  38 const uint32 kMaxVaryingVectors = 8;
  39
  40 void ShaderCacheCb(const std::string& key, const std::string& shader) {}
  41 }  // namespace anonymous
  42
  43 class ProgramManagerTest : public GpuServiceTest {
  44  public:
  45   ProgramManagerTest() : manager_(NULL, kMaxVaryingVectors) { }
  46   virtual ~ProgramManagerTest() {
  47     manager_.Destroy(false);
  48   }
  49
  50  protected:
  51   ProgramManager manager_;
  52 };
  53
  54 TEST_F(ProgramManagerTest, Basic) {
  55   const GLuint kClient1Id = 1;
  56   const GLuint kService1Id = 11;
  57   const GLuint kClient2Id = 2;
  58   // Check we can create program.
  59   manager_.CreateProgram(kClient1Id, kService1Id);
  60   // Check program got created.
  61   Program* program1 = manager_.GetProgram(kClient1Id);
  62   ASSERT_TRUE(program1 != NULL);
  63   GLuint client_id = 0;
  64   EXPECT_TRUE(manager_.GetClientId(program1->service_id(), &client_id));
  65   EXPECT_EQ(kClient1Id, client_id);
  66   // Check we get nothing for a non-existent program.
  67   EXPECT_TRUE(manager_.GetProgram(kClient2Id) == NULL);
  68 }
  69
  70 TEST_F(ProgramManagerTest, Destroy) {
  71   const GLuint kClient1Id = 1;
  72   const GLuint kService1Id = 11;
  73   // Check we can create program.
  74   Program* program0 = manager_.CreateProgram(kClient1Id, kService1Id);
  75   ASSERT_TRUE(program0 != NULL);
  76   // Check program got created.
  77   Program* program1 = manager_.GetProgram(kClient1Id);
  78   ASSERT_EQ(program0, program1);
  79   EXPECT_CALL(*gl_, DeleteProgram(kService1Id))
  80       .Times(1)
  81       .RetiresOnSaturation();
  82   manager_.Destroy(true);
  83   // Check the resources were released.
  84   program1 = manager_.GetProgram(kClient1Id);
  85   ASSERT_TRUE(program1 == NULL);
  86 }
  87
  88 TEST_F(ProgramManagerTest, DeleteBug) {
  89   ShaderManager shader_manager;
  90   const GLuint kClient1Id = 1;
  91   const GLuint kClient2Id = 2;
  92   const GLuint kService1Id = 11;
  93   const GLuint kService2Id = 12;
  94   // Check we can create program.
  95   scoped_refptr<Program> program1(
  96       manager_.CreateProgram(kClient1Id, kService1Id));
  97   scoped_refptr<Program> program2(
  98       manager_.CreateProgram(kClient2Id, kService2Id));
  99   // Check program got created.
 100   ASSERT_TRUE(program1.get());
 101   ASSERT_TRUE(program2.get());
 102   manager_.UseProgram(program1.get());
 103   manager_.MarkAsDeleted(&shader_manager, program1.get());
 104   //  Program will be deleted when last ref is released.
 105   EXPECT_CALL(*gl_, DeleteProgram(kService2Id))
 106       .Times(1)
 107       .RetiresOnSaturation();
 108   manager_.MarkAsDeleted(&shader_manager, program2.get());
 109   EXPECT_TRUE(manager_.IsOwned(program1.get()));
 110   EXPECT_FALSE(manager_.IsOwned(program2.get()));
 111 }
 112
 113 TEST_F(ProgramManagerTest, Program) {
 114   const GLuint kClient1Id = 1;
 115   const GLuint kService1Id = 11;
 116   // Check we can create program.
 117   Program* program1 = manager_.CreateProgram(
 118       kClient1Id, kService1Id);
 119   ASSERT_TRUE(program1);
 120   EXPECT_EQ(kService1Id, program1->service_id());
 121   EXPECT_FALSE(program1->InUse());
 122   EXPECT_FALSE(program1->IsValid());
 123   EXPECT_FALSE(program1->IsDeleted());
 124   EXPECT_FALSE(program1->CanLink());
 125   EXPECT_TRUE(program1->log_info() == NULL);
 126 }
 127
 128 class ProgramManagerWithShaderTest : public GpuServiceTest {
 129  public:
 130   ProgramManagerWithShaderTest()
 131       :  manager_(NULL, kMaxVaryingVectors), program_(NULL) {
 132   }
 133
 134   virtual ~ProgramManagerWithShaderTest() {
 135     manager_.Destroy(false);
 136     shader_manager_.Destroy(false);
 137   }
 138
 139   static const GLint kNumVertexAttribs = 16;
 140
 141   static const GLuint kClientProgramId = 123;
 142   static const GLuint kServiceProgramId = 456;
 143   static const GLuint kVertexShaderClientId = 201;
 144   static const GLuint kFragmentShaderClientId = 202;
 145   static const GLuint kVertexShaderServiceId = 301;
 146   static const GLuint kFragmentShaderServiceId = 302;
 147
 148   static const char* kAttrib1Name;
 149   static const char* kAttrib2Name;
 150   static const char* kAttrib3Name;
 151   static const GLint kAttrib1Size = 1;
 152   static const GLint kAttrib2Size = 1;
 153   static const GLint kAttrib3Size = 1;
 154   static const int kAttrib1Precision = SH_PRECISION_MEDIUMP;
 155   static const int kAttrib2Precision = SH_PRECISION_HIGHP;
 156   static const int kAttrib3Precision = SH_PRECISION_LOWP;
 157   static const int kAttribStaticUse = 0;
 158   static const GLint kAttrib1Location = 0;
 159   static const GLint kAttrib2Location = 1;
 160   static const GLint kAttrib3Location = 2;
 161   static const GLenum kAttrib1Type = GL_FLOAT_VEC4;
 162   static const GLenum kAttrib2Type = GL_FLOAT_VEC2;
 163   static const GLenum kAttrib3Type = GL_FLOAT_VEC3;
 164   static const GLint kInvalidAttribLocation = 30;
 165   static const GLint kBadAttribIndex = kNumVertexAttribs;
 166
 167   static const char* kUniform1Name;
 168   static const char* kUniform2Name;
 169   static const char* kUniform3BadName;
 170   static const char* kUniform3GoodName;
 171   static const GLint kUniform1Size = 1;
 172   static const GLint kUniform2Size = 3;
 173   static const GLint kUniform3Size = 2;
 174   static const int kUniform1Precision = SH_PRECISION_LOWP;
 175   static const int kUniform2Precision = SH_PRECISION_MEDIUMP;
 176   static const int kUniform3Precision = SH_PRECISION_HIGHP;
 177   static const int kUniform1StaticUse = 1;
 178   static const int kUniform2StaticUse = 1;
 179   static const int kUniform3StaticUse = 1;
 180   static const GLint kUniform1FakeLocation = 0;  // These are hard coded
 181   static const GLint kUniform2FakeLocation = 1;  // to match
 182   static const GLint kUniform3FakeLocation = 2;  // ProgramManager.
 183   static const GLint kUniform1RealLocation = 11;
 184   static const GLint kUniform2RealLocation = 22;
 185   static const GLint kUniform3RealLocation = 33;
 186   static const GLint kUniform1DesiredLocation = -1;
 187   static const GLint kUniform2DesiredLocation = -1;
 188   static const GLint kUniform3DesiredLocation = -1;
 189   static const GLenum kUniform1Type = GL_FLOAT_VEC4;
 190   static const GLenum kUniform2Type = GL_INT_VEC2;
 191   static const GLenum kUniform3Type = GL_FLOAT_VEC3;
 192   static const GLint kInvalidUniformLocation = 30;
 193   static const GLint kBadUniformIndex = 1000;
 194
 195   static const size_t kNumAttribs;
 196   static const size_t kNumUniforms;
 197
 198  protected:
 199   typedef TestHelper::AttribInfo AttribInfo;
 200   typedef TestHelper::UniformInfo UniformInfo;
 201
 202   typedef enum {
 203     kVarUniform,
 204     kVarVarying,
 205     kVarAttribute
 206   } VarCategory;
 207
 208   typedef struct {
 209     int type;
 210     int size;
 211     int precision;
 212     int static_use;
 213     std::string name;
 214     VarCategory category;
 215   } VarInfo;
 216
 217   virtual void SetUp() {
 218     GpuServiceTest::SetUp();
 219
 220     SetupDefaultShaderExpectations();
 221
 222     Shader* vertex_shader = shader_manager_.CreateShader(
 223         kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
 224     Shader* fragment_shader =
 225         shader_manager_.CreateShader(
 226             kFragmentShaderClientId, kFragmentShaderServiceId,
 227             GL_FRAGMENT_SHADER);
 228     ASSERT_TRUE(vertex_shader != NULL);
 229     ASSERT_TRUE(fragment_shader != NULL);
 230     TestHelper::SetShaderStates(gl_.get(), vertex_shader, true);
 231     TestHelper::SetShaderStates(gl_.get(), fragment_shader, true);
 232
 233     program_ = manager_.CreateProgram(
 234         kClientProgramId, kServiceProgramId);
 235     ASSERT_TRUE(program_ != NULL);
 236
 237     program_->AttachShader(&shader_manager_, vertex_shader);
 238     program_->AttachShader(&shader_manager_, fragment_shader);
 239     program_->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
 240                    base::Bind(&ShaderCacheCb));
 241   }
 242
 243   void SetupShader(AttribInfo* attribs, size_t num_attribs,
 244                    UniformInfo* uniforms, size_t num_uniforms,
 245                    GLuint service_id) {
 246     TestHelper::SetupShader(
 247         gl_.get(), attribs, num_attribs, uniforms, num_uniforms, service_id);
 248   }
 249
 250   void SetupDefaultShaderExpectations() {
 251     SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
 252                 kServiceProgramId);
 253   }
 254
 255   void SetupExpectationsForClearingUniforms(
 256       UniformInfo* uniforms, size_t num_uniforms) {
 257     TestHelper::SetupExpectationsForClearingUniforms(
 258         gl_.get(), uniforms, num_uniforms);
 259   }
 260
 261   // Return true if link status matches expected_link_status
 262   bool LinkAsExpected(Program* program,
 263                       bool expected_link_status) {
 264     GLuint service_id = program->service_id();
 265     if (expected_link_status) {
 266       SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
 267                   service_id);
 268     }
 269     program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
 270                   base::Bind(&ShaderCacheCb));
 271     GLint link_status;
 272     program->GetProgramiv(GL_LINK_STATUS, &link_status);
 273     return (static_cast<bool>(link_status) == expected_link_status);
 274   }
 275
 276   Program* SetupShaderVariableTest(const VarInfo* vertex_variables,
 277                                    size_t vertex_variable_size,
 278                                    const VarInfo* fragment_variables,
 279                                    size_t fragment_variable_size) {
 280     // Set up shader
 281     const GLuint kVShaderClientId = 1;
 282     const GLuint kVShaderServiceId = 11;
 283     const GLuint kFShaderClientId = 2;
 284     const GLuint kFShaderServiceId = 12;
 285
 286     ShaderTranslator::VariableMap vertex_attrib_map;
 287     ShaderTranslator::VariableMap vertex_uniform_map;
 288     ShaderTranslator::VariableMap vertex_varying_map;
 289     for (size_t ii = 0; ii < vertex_variable_size; ++ii) {
 290       ShaderTranslator::VariableMap* map = NULL;
 291       switch (vertex_variables[ii].category) {
 292         case kVarAttribute:
 293           map = &vertex_attrib_map;
 294           break;
 295         case kVarUniform:
 296           map = &vertex_uniform_map;
 297           break;
 298         case kVarVarying:
 299           map = &vertex_varying_map;
 300           break;
 301         default:
 302           NOTREACHED();
 303       }
 304       (*map)[vertex_variables[ii].name] =
 305           ShaderTranslator::VariableInfo(vertex_variables[ii].type,
 306                                          vertex_variables[ii].size,
 307                                          vertex_variables[ii].precision,
 308                                          vertex_variables[ii].static_use,
 309                                          vertex_variables[ii].name);
 310     }
 311
 312     ShaderTranslator::VariableMap frag_attrib_map;
 313     ShaderTranslator::VariableMap frag_uniform_map;
 314     ShaderTranslator::VariableMap frag_varying_map;
 315     for (size_t ii = 0; ii < fragment_variable_size; ++ii) {
 316       ShaderTranslator::VariableMap* map = NULL;
 317       switch (fragment_variables[ii].category) {
 318         case kVarAttribute:
 319           map = &frag_attrib_map;
 320           break;
 321         case kVarUniform:
 322           map = &frag_uniform_map;
 323           break;
 324         case kVarVarying:
 325           map = &frag_varying_map;
 326           break;
 327         default:
 328           NOTREACHED();
 329       }
 330       (*map)[fragment_variables[ii].name] =
 331           ShaderTranslator::VariableInfo(fragment_variables[ii].type,
 332                                          fragment_variables[ii].size,
 333                                          fragment_variables[ii].precision,
 334                                          fragment_variables[ii].static_use,
 335                                          fragment_variables[ii].name);
 336     }
 337
 338     // Check we can create shader.
 339     Shader* vshader = shader_manager_.CreateShader(
 340         kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
 341     Shader* fshader = shader_manager_.CreateShader(
 342         kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
 343     // Check shader got created.
 344     EXPECT_TRUE(vshader != NULL && fshader != NULL);
 345     // Set Status
 346     TestHelper::SetShaderStates(
 347         gl_.get(), vshader, true, NULL, NULL,
 348         &vertex_attrib_map, &vertex_uniform_map, &vertex_varying_map, NULL);
 349     TestHelper::SetShaderStates(
 350         gl_.get(), fshader, true, NULL, NULL,
 351         &frag_attrib_map, &frag_uniform_map, &frag_varying_map, NULL);
 352
 353     // Set up program
 354     const GLuint kClientProgramId = 6666;
 355     const GLuint kServiceProgramId = 8888;
 356     Program* program =
 357         manager_.CreateProgram(kClientProgramId, kServiceProgramId);
 358     EXPECT_TRUE(program != NULL);
 359     EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
 360     EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 361     return program;
 362   }
 363
 364   static AttribInfo kAttribs[];
 365   static UniformInfo kUniforms[];
 366
 367   ProgramManager manager_;
 368   Program* program_;
 369   ShaderManager shader_manager_;
 370 };
 371
 372 ProgramManagerWithShaderTest::AttribInfo
 373     ProgramManagerWithShaderTest::kAttribs[] = {
 374   { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
 375   { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
 376   { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
 377 };
 378
 379 // GCC requires these declarations, but MSVC requires they not be present
 380 #ifndef COMPILER_MSVC
 381 const GLint ProgramManagerWithShaderTest::kNumVertexAttribs;
 382 const GLuint ProgramManagerWithShaderTest::kClientProgramId;
 383 const GLuint ProgramManagerWithShaderTest::kServiceProgramId;
 384 const GLuint ProgramManagerWithShaderTest::kVertexShaderClientId;
 385 const GLuint ProgramManagerWithShaderTest::kFragmentShaderClientId;
 386 const GLuint ProgramManagerWithShaderTest::kVertexShaderServiceId;
 387 const GLuint ProgramManagerWithShaderTest::kFragmentShaderServiceId;
 388 const GLint ProgramManagerWithShaderTest::kAttrib1Size;
 389 const GLint ProgramManagerWithShaderTest::kAttrib2Size;
 390 const GLint ProgramManagerWithShaderTest::kAttrib3Size;
 391 const GLint ProgramManagerWithShaderTest::kAttrib1Location;
 392 const GLint ProgramManagerWithShaderTest::kAttrib2Location;
 393 const GLint ProgramManagerWithShaderTest::kAttrib3Location;
 394 const GLenum ProgramManagerWithShaderTest::kAttrib1Type;
 395 const GLenum ProgramManagerWithShaderTest::kAttrib2Type;
 396 const GLenum ProgramManagerWithShaderTest::kAttrib3Type;
 397 const GLint ProgramManagerWithShaderTest::kInvalidAttribLocation;
 398 const GLint ProgramManagerWithShaderTest::kBadAttribIndex;
 399 const GLint ProgramManagerWithShaderTest::kUniform1Size;
 400 const GLint ProgramManagerWithShaderTest::kUniform2Size;
 401 const GLint ProgramManagerWithShaderTest::kUniform3Size;
 402 const GLint ProgramManagerWithShaderTest::kUniform1FakeLocation;
 403 const GLint ProgramManagerWithShaderTest::kUniform2FakeLocation;
 404 const GLint ProgramManagerWithShaderTest::kUniform3FakeLocation;
 405 const GLint ProgramManagerWithShaderTest::kUniform1RealLocation;
 406 const GLint ProgramManagerWithShaderTest::kUniform2RealLocation;
 407 const GLint ProgramManagerWithShaderTest::kUniform3RealLocation;
 408 const GLint ProgramManagerWithShaderTest::kUniform1DesiredLocation;
 409 const GLint ProgramManagerWithShaderTest::kUniform2DesiredLocation;
 410 const GLint ProgramManagerWithShaderTest::kUniform3DesiredLocation;
 411 const GLenum ProgramManagerWithShaderTest::kUniform1Type;
 412 const GLenum ProgramManagerWithShaderTest::kUniform2Type;
 413 const GLenum ProgramManagerWithShaderTest::kUniform3Type;
 414 const GLint ProgramManagerWithShaderTest::kInvalidUniformLocation;
 415 const GLint ProgramManagerWithShaderTest::kBadUniformIndex;
 416 #endif
 417
 418 const size_t ProgramManagerWithShaderTest::kNumAttribs =
 419     arraysize(ProgramManagerWithShaderTest::kAttribs);
 420
 421 ProgramManagerWithShaderTest::UniformInfo
 422     ProgramManagerWithShaderTest::kUniforms[] = {
 423   { kUniform1Name,
 424     kUniform1Size,
 425     kUniform1Type,
 426     kUniform1FakeLocation,
 427     kUniform1RealLocation,
 428     kUniform1DesiredLocation,
 429     kUniform1Name,
 430   },
 431   { kUniform2Name,
 432     kUniform2Size,
 433     kUniform2Type,
 434     kUniform2FakeLocation,
 435     kUniform2RealLocation,
 436     kUniform2DesiredLocation,
 437     kUniform2Name,
 438   },
 439   { kUniform3BadName,
 440     kUniform3Size,
 441     kUniform3Type,
 442     kUniform3FakeLocation,
 443     kUniform3RealLocation,
 444     kUniform3DesiredLocation,
 445     kUniform3GoodName,
 446   },
 447 };
 448
 449 const size_t ProgramManagerWithShaderTest::kNumUniforms =
 450     arraysize(ProgramManagerWithShaderTest::kUniforms);
 451
 452 const char* ProgramManagerWithShaderTest::kAttrib1Name = "attrib1";
 453 const char* ProgramManagerWithShaderTest::kAttrib2Name = "attrib2";
 454 const char* ProgramManagerWithShaderTest::kAttrib3Name = "attrib3";
 455 const char* ProgramManagerWithShaderTest::kUniform1Name = "uniform1";
 456 // Correctly has array spec.
 457 const char* ProgramManagerWithShaderTest::kUniform2Name = "uniform2[0]";
 458 // Incorrectly missing array spec.
 459 const char* ProgramManagerWithShaderTest::kUniform3BadName = "uniform3";
 460 const char* ProgramManagerWithShaderTest::kUniform3GoodName = "uniform3[0]";
 461
 462 TEST_F(ProgramManagerWithShaderTest, GetAttribInfos) {
 463   const Program* program = manager_.GetProgram(kClientProgramId);
 464   ASSERT_TRUE(program != NULL);
 465   const Program::AttribInfoVector& infos =
 466       program->GetAttribInfos();
 467   ASSERT_EQ(kNumAttribs, infos.size());
 468   for (size_t ii = 0; ii < kNumAttribs; ++ii) {
 469     const Program::VertexAttrib& info = infos[ii];
 470     const AttribInfo& expected = kAttribs[ii];
 471     EXPECT_EQ(expected.size, info.size);
 472     EXPECT_EQ(expected.type, info.type);
 473     EXPECT_EQ(expected.location, info.location);
 474     EXPECT_STREQ(expected.name, info.name.c_str());
 475   }
 476 }
 477
 478 TEST_F(ProgramManagerWithShaderTest, GetAttribInfo) {
 479   const GLint kValidIndex = 1;
 480   const GLint kInvalidIndex = 1000;
 481   const Program* program = manager_.GetProgram(kClientProgramId);
 482   ASSERT_TRUE(program != NULL);
 483   const Program::VertexAttrib* info =
 484       program->GetAttribInfo(kValidIndex);
 485   ASSERT_TRUE(info != NULL);
 486   EXPECT_EQ(kAttrib2Size, info->size);
 487   EXPECT_EQ(kAttrib2Type, info->type);
 488   EXPECT_EQ(kAttrib2Location, info->location);
 489   EXPECT_STREQ(kAttrib2Name, info->name.c_str());
 490   EXPECT_TRUE(program->GetAttribInfo(kInvalidIndex) == NULL);
 491 }
 492
 493 TEST_F(ProgramManagerWithShaderTest, GetAttribLocation) {
 494   const char* kInvalidName = "foo";
 495   const Program* program = manager_.GetProgram(kClientProgramId);
 496   ASSERT_TRUE(program != NULL);
 497   EXPECT_EQ(kAttrib2Location, program->GetAttribLocation(kAttrib2Name));
 498   EXPECT_EQ(-1, program->GetAttribLocation(kInvalidName));
 499 }
 500
 501 TEST_F(ProgramManagerWithShaderTest, GetUniformInfo) {
 502   const GLint kInvalidIndex = 1000;
 503   const Program* program = manager_.GetProgram(kClientProgramId);
 504   ASSERT_TRUE(program != NULL);
 505   const Program::UniformInfo* info =
 506       program->GetUniformInfo(0);
 507   ASSERT_TRUE(info != NULL);
 508   EXPECT_EQ(kUniform1Size, info->size);
 509   EXPECT_EQ(kUniform1Type, info->type);
 510   EXPECT_EQ(kUniform1RealLocation, info->element_locations[0]);
 511   EXPECT_STREQ(kUniform1Name, info->name.c_str());
 512   info = program->GetUniformInfo(1);
 513   ASSERT_TRUE(info != NULL);
 514   EXPECT_EQ(kUniform2Size, info->size);
 515   EXPECT_EQ(kUniform2Type, info->type);
 516   EXPECT_EQ(kUniform2RealLocation, info->element_locations[0]);
 517   EXPECT_STREQ(kUniform2Name, info->name.c_str());
 518   info = program->GetUniformInfo(2);
 519   // We emulate certain OpenGL drivers by supplying the name without
 520   // the array spec. Our implementation should correctly add the required spec.
 521   ASSERT_TRUE(info != NULL);
 522   EXPECT_EQ(kUniform3Size, info->size);
 523   EXPECT_EQ(kUniform3Type, info->type);
 524   EXPECT_EQ(kUniform3RealLocation, info->element_locations[0]);
 525   EXPECT_STREQ(kUniform3GoodName, info->name.c_str());
 526   EXPECT_TRUE(program->GetUniformInfo(kInvalidIndex) == NULL);
 527 }
 528
 529 TEST_F(ProgramManagerWithShaderTest, AttachDetachShader) {
 530   static const GLuint kClientProgramId = 124;
 531   static const GLuint kServiceProgramId = 457;
 532   Program* program = manager_.CreateProgram(
 533       kClientProgramId, kServiceProgramId);
 534   ASSERT_TRUE(program != NULL);
 535   EXPECT_FALSE(program->CanLink());
 536   const GLuint kVShaderClientId = 2001;
 537   const GLuint kFShaderClientId = 2002;
 538   const GLuint kVShaderServiceId = 3001;
 539   const GLuint kFShaderServiceId = 3002;
 540   Shader* vshader = shader_manager_.CreateShader(
 541       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
 542   ASSERT_TRUE(vshader != NULL);
 543   TestHelper::SetShaderStates(gl_.get(), vshader, true);
 544   Shader* fshader = shader_manager_.CreateShader(
 545       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
 546   ASSERT_TRUE(fshader != NULL);
 547   TestHelper::SetShaderStates(gl_.get(), fshader, true);
 548   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
 549   EXPECT_FALSE(program->CanLink());
 550   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 551   EXPECT_TRUE(program->CanLink());
 552   program->DetachShader(&shader_manager_, vshader);
 553   EXPECT_FALSE(program->CanLink());
 554   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
 555   EXPECT_TRUE(program->CanLink());
 556   program->DetachShader(&shader_manager_, fshader);
 557   EXPECT_FALSE(program->CanLink());
 558   EXPECT_FALSE(program->AttachShader(&shader_manager_, vshader));
 559   EXPECT_FALSE(program->CanLink());
 560   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 561   EXPECT_TRUE(program->CanLink());
 562   TestHelper::SetShaderStates(gl_.get(), vshader, false);
 563   EXPECT_FALSE(program->CanLink());
 564   TestHelper::SetShaderStates(gl_.get(), vshader, true);
 565   EXPECT_TRUE(program->CanLink());
 566   TestHelper::SetShaderStates(gl_.get(), fshader, false);
 567   EXPECT_FALSE(program->CanLink());
 568   TestHelper::SetShaderStates(gl_.get(), fshader, true);
 569   EXPECT_TRUE(program->CanLink());
 570   EXPECT_TRUE(program->DetachShader(&shader_manager_, fshader));
 571   EXPECT_FALSE(program->DetachShader(&shader_manager_, fshader));
 572 }
 573
 574 TEST_F(ProgramManagerWithShaderTest, GetUniformFakeLocation) {
 575   const Program* program = manager_.GetProgram(kClientProgramId);
 576   ASSERT_TRUE(program != NULL);
 577   // Emulate the situation that uniform3[1] isn't used and optimized out by
 578   // a driver, so it's location is -1.
 579   Program::UniformInfo* uniform = const_cast<Program::UniformInfo*>(
 580       program->GetUniformInfo(2));
 581   ASSERT_TRUE(uniform != NULL && kUniform3Size == 2);
 582   EXPECT_EQ(kUniform3Size, uniform->size);
 583   uniform->element_locations[1] = -1;
 584   EXPECT_EQ(kUniform1FakeLocation,
 585             program->GetUniformFakeLocation(kUniform1Name));
 586   EXPECT_EQ(kUniform2FakeLocation,
 587             program->GetUniformFakeLocation(kUniform2Name));
 588   EXPECT_EQ(kUniform3FakeLocation,
 589             program->GetUniformFakeLocation(kUniform3BadName));
 590   // Check we can get uniform2 as "uniform2" even though the name is
 591   // "uniform2[0]"
 592   EXPECT_EQ(kUniform2FakeLocation,
 593             program->GetUniformFakeLocation("uniform2"));
 594   // Check we can get uniform3 as "uniform3[0]" even though we simulated GL
 595   // returning "uniform3"
 596   EXPECT_EQ(kUniform3FakeLocation,
 597             program->GetUniformFakeLocation(kUniform3GoodName));
 598   // Check that we can get the locations of the array elements > 1
 599   EXPECT_EQ(ProgramManager::MakeFakeLocation(kUniform2FakeLocation, 1),
 600             program->GetUniformFakeLocation("uniform2[1]"));
 601   EXPECT_EQ(ProgramManager::MakeFakeLocation(kUniform2FakeLocation, 2),
 602             program->GetUniformFakeLocation("uniform2[2]"));
 603   EXPECT_EQ(-1, program->GetUniformFakeLocation("uniform2[3]"));
 604   EXPECT_EQ(-1, program->GetUniformFakeLocation("uniform3[1]"));
 605   EXPECT_EQ(-1, program->GetUniformFakeLocation("uniform3[2]"));
 606 }
 607
 608 TEST_F(ProgramManagerWithShaderTest, GetUniformInfoByFakeLocation) {
 609   const GLint kInvalidLocation = 1234;
 610   const Program::UniformInfo* info;
 611   const Program* program = manager_.GetProgram(kClientProgramId);
 612   GLint real_location = -1;
 613   GLint array_index = -1;
 614   ASSERT_TRUE(program != NULL);
 615   info = program->GetUniformInfoByFakeLocation(
 616       kUniform2FakeLocation, &real_location, &array_index);
 617   EXPECT_EQ(kUniform2RealLocation, real_location);
 618   EXPECT_EQ(0, array_index);
 619   ASSERT_TRUE(info != NULL);
 620   EXPECT_EQ(kUniform2Type, info->type);
 621   real_location = -1;
 622   array_index = -1;
 623   info = program->GetUniformInfoByFakeLocation(
 624       kInvalidLocation, &real_location, &array_index);
 625   EXPECT_TRUE(info == NULL);
 626   EXPECT_EQ(-1, real_location);
 627   EXPECT_EQ(-1, array_index);
 628   GLint loc = program->GetUniformFakeLocation("uniform2[2]");
 629   info = program->GetUniformInfoByFakeLocation(
 630       loc, &real_location, &array_index);
 631   ASSERT_TRUE(info != NULL);
 632   EXPECT_EQ(kUniform2RealLocation + 2 * 2, real_location);
 633   EXPECT_EQ(2, array_index);
 634 }
 635
 636 // Some GL drivers incorrectly return gl_DepthRange and possibly other uniforms
 637 // that start with "gl_". Our implementation catches these and does not allow
 638 // them back to client.
 639 TEST_F(ProgramManagerWithShaderTest, GLDriverReturnsGLUnderscoreUniform) {
 640   static const char* kUniform2Name = "gl_longNameWeCanCheckFor";
 641   static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
 642     { kUniform1Name,
 643       kUniform1Size,
 644       kUniform1Type,
 645       kUniform1FakeLocation,
 646       kUniform1RealLocation,
 647       kUniform1DesiredLocation,
 648       kUniform1Name,
 649     },
 650     { kUniform2Name,
 651       kUniform2Size,
 652       kUniform2Type,
 653       kUniform2FakeLocation,
 654       kUniform2RealLocation,
 655       kUniform2DesiredLocation,
 656       kUniform2Name,
 657     },
 658     { kUniform3BadName,
 659       kUniform3Size,
 660       kUniform3Type,
 661       kUniform3FakeLocation,
 662       kUniform3RealLocation,
 663       kUniform3DesiredLocation,
 664       kUniform3GoodName,
 665     },
 666   };
 667   const size_t kNumUniforms = arraysize(kUniforms);
 668   static const GLuint kClientProgramId = 1234;
 669   static const GLuint kServiceProgramId = 5679;
 670   const GLuint kVShaderClientId = 2001;
 671   const GLuint kFShaderClientId = 2002;
 672   const GLuint kVShaderServiceId = 3001;
 673   const GLuint kFShaderServiceId = 3002;
 674   SetupShader(
 675       kAttribs, kNumAttribs, kUniforms, kNumUniforms, kServiceProgramId);
 676   Shader* vshader = shader_manager_.CreateShader(
 677       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
 678   ASSERT_TRUE(vshader != NULL);
 679   TestHelper::SetShaderStates(gl_.get(), vshader, true);
 680   Shader* fshader = shader_manager_.CreateShader(
 681       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
 682   ASSERT_TRUE(fshader != NULL);
 683   TestHelper::SetShaderStates(gl_.get(), fshader, true);
 684   Program* program =
 685       manager_.CreateProgram(kClientProgramId, kServiceProgramId);
 686   ASSERT_TRUE(program != NULL);
 687   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
 688   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 689   program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
 690                 base::Bind(&ShaderCacheCb));
 691   GLint value = 0;
 692   program->GetProgramiv(GL_ACTIVE_ATTRIBUTES, &value);
 693   EXPECT_EQ(3, value);
 694   // Check that we skipped the "gl_" uniform.
 695   program->GetProgramiv(GL_ACTIVE_UNIFORMS, &value);
 696   EXPECT_EQ(2, value);
 697   // Check that our max length adds room for the array spec and is not as long
 698   // as the "gl_" uniform we skipped.
 699   // +4u is to account for "gl_" and NULL terminator.
 700   program->GetProgramiv(GL_ACTIVE_UNIFORM_MAX_LENGTH, &value);
 701   EXPECT_EQ(strlen(kUniform3BadName) + 4u, static_cast<size_t>(value));
 702 }
 703
 704 // Test the bug comparing similar array names is fixed.
 705 TEST_F(ProgramManagerWithShaderTest, SimilarArrayNames) {
 706   static const char* kUniform2Name = "u_nameLong[0]";
 707   static const char* kUniform3Name = "u_name[0]";
 708   static const GLint kUniform2Size = 2;
 709   static const GLint kUniform3Size = 2;
 710   static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
 711     { kUniform1Name,
 712       kUniform1Size,
 713       kUniform1Type,
 714       kUniform1FakeLocation,
 715       kUniform1RealLocation,
 716       kUniform1DesiredLocation,
 717       kUniform1Name,
 718     },
 719     { kUniform2Name,
 720       kUniform2Size,
 721       kUniform2Type,
 722       kUniform2FakeLocation,
 723       kUniform2RealLocation,
 724       kUniform2DesiredLocation,
 725       kUniform2Name,
 726     },
 727     { kUniform3Name,
 728       kUniform3Size,
 729       kUniform3Type,
 730       kUniform3FakeLocation,
 731       kUniform3RealLocation,
 732       kUniform3DesiredLocation,
 733       kUniform3Name,
 734     },
 735   };
 736   const size_t kNumUniforms = arraysize(kUniforms);
 737   static const GLuint kClientProgramId = 1234;
 738   static const GLuint kServiceProgramId = 5679;
 739   const GLuint kVShaderClientId = 2001;
 740   const GLuint kFShaderClientId = 2002;
 741   const GLuint kVShaderServiceId = 3001;
 742   const GLuint kFShaderServiceId = 3002;
 743   SetupShader(
 744       kAttribs, kNumAttribs, kUniforms, kNumUniforms, kServiceProgramId);
 745   Shader* vshader = shader_manager_.CreateShader(
 746       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
 747   ASSERT_TRUE(vshader != NULL);
 748   TestHelper::SetShaderStates(gl_.get(), vshader, true);
 749   Shader* fshader = shader_manager_.CreateShader(
 750       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
 751   ASSERT_TRUE(fshader != NULL);
 752   TestHelper::SetShaderStates(gl_.get(), fshader, true);
 753   Program* program =
 754       manager_.CreateProgram(kClientProgramId, kServiceProgramId);
 755   ASSERT_TRUE(program != NULL);
 756   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
 757   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 758   program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
 759                 base::Bind(&ShaderCacheCb));
 760
 761   // Check that we get the correct locations.
 762   EXPECT_EQ(kUniform2FakeLocation,
 763             program->GetUniformFakeLocation(kUniform2Name));
 764   EXPECT_EQ(kUniform3FakeLocation,
 765             program->GetUniformFakeLocation(kUniform3Name));
 766 }
 767
 768 // Some GL drivers incorrectly return the wrong type. For example they return
 769 // GL_FLOAT_VEC2 when they should return GL_FLOAT_MAT2. Check we handle this.
 770 TEST_F(ProgramManagerWithShaderTest, GLDriverReturnsWrongTypeInfo) {
 771   static GLenum kAttrib2BadType = GL_FLOAT_VEC2;
 772   static GLenum kAttrib2GoodType = GL_FLOAT_MAT2;
 773   static GLenum kUniform2BadType = GL_FLOAT_VEC3;
 774   static GLenum kUniform2GoodType = GL_FLOAT_MAT3;
 775   ShaderTranslator::VariableMap attrib_map;
 776   ShaderTranslator::VariableMap uniform_map;
 777   ShaderTranslator::VariableMap varying_map;
 778   attrib_map[kAttrib1Name] = ShaderTranslatorInterface::VariableInfo(
 779       kAttrib1Type, kAttrib1Size, kAttrib1Precision,
 780       kAttribStaticUse, kAttrib1Name);
 781   attrib_map[kAttrib2Name] = ShaderTranslatorInterface::VariableInfo(
 782       kAttrib2GoodType, kAttrib2Size, kAttrib2Precision,
 783       kAttribStaticUse, kAttrib2Name);
 784   attrib_map[kAttrib3Name] = ShaderTranslatorInterface::VariableInfo(
 785       kAttrib3Type, kAttrib3Size, kAttrib3Precision,
 786       kAttribStaticUse, kAttrib3Name);
 787   uniform_map[kUniform1Name] = ShaderTranslatorInterface::VariableInfo(
 788       kUniform1Type, kUniform1Size, kUniform1Precision,
 789       kUniform1StaticUse, kUniform1Name);
 790   uniform_map[kUniform2Name] = ShaderTranslatorInterface::VariableInfo(
 791       kUniform2GoodType, kUniform2Size, kUniform2Precision,
 792       kUniform2StaticUse, kUniform2Name);
 793   uniform_map[kUniform3GoodName] = ShaderTranslatorInterface::VariableInfo(
 794       kUniform3Type, kUniform3Size, kUniform3Precision,
 795       kUniform3StaticUse, kUniform3GoodName);
 796   const GLuint kVShaderClientId = 2001;
 797   const GLuint kFShaderClientId = 2002;
 798   const GLuint kVShaderServiceId = 3001;
 799   const GLuint kFShaderServiceId = 3002;
 800   Shader* vshader = shader_manager_.CreateShader(
 801       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
 802   ASSERT_TRUE(vshader != NULL);
 803   TestHelper::SetShaderStates(
 804       gl_.get(), vshader, true, NULL, NULL,
 805       &attrib_map, &uniform_map, &varying_map, NULL);
 806   Shader* fshader = shader_manager_.CreateShader(
 807       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
 808   ASSERT_TRUE(fshader != NULL);
 809   TestHelper::SetShaderStates(
 810       gl_.get(), fshader, true, NULL, NULL,
 811       &attrib_map, &uniform_map, &varying_map, NULL);
 812   static ProgramManagerWithShaderTest::AttribInfo kAttribs[] = {
 813     { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
 814     { kAttrib2Name, kAttrib2Size, kAttrib2BadType, kAttrib2Location, },
 815     { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
 816   };
 817   static ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
 818     { kUniform1Name,
 819       kUniform1Size,
 820       kUniform1Type,
 821       kUniform1FakeLocation,
 822       kUniform1RealLocation,
 823       kUniform1DesiredLocation,
 824       kUniform1Name,
 825     },
 826     { kUniform2Name,
 827       kUniform2Size,
 828       kUniform2BadType,
 829       kUniform2FakeLocation,
 830       kUniform2RealLocation,
 831       kUniform2DesiredLocation,
 832       kUniform2Name,
 833     },
 834     { kUniform3BadName,
 835       kUniform3Size,
 836       kUniform3Type,
 837       kUniform3FakeLocation,
 838       kUniform3RealLocation,
 839       kUniform3DesiredLocation,
 840       kUniform3GoodName,
 841     },
 842   };
 843   const size_t kNumAttribs= arraysize(kAttribs);
 844   const size_t kNumUniforms = arraysize(kUniforms);
 845   static const GLuint kClientProgramId = 1234;
 846   static const GLuint kServiceProgramId = 5679;
 847   SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
 848               kServiceProgramId);
 849   Program* program = manager_.CreateProgram(
 850       kClientProgramId, kServiceProgramId);
 851   ASSERT_TRUE(program!= NULL);
 852   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
 853   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 854   program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
 855                 base::Bind(&ShaderCacheCb));
 856   // Check that we got the good type, not the bad.
 857   // Check Attribs
 858   for (unsigned index = 0; index < kNumAttribs; ++index) {
 859     const Program::VertexAttrib* attrib_info =
 860         program->GetAttribInfo(index);
 861     ASSERT_TRUE(attrib_info != NULL);
 862     ShaderTranslator::VariableMap::const_iterator it = attrib_map.find(
 863         attrib_info->name);
 864     ASSERT_TRUE(it != attrib_map.end());
 865     EXPECT_EQ(it->first, attrib_info->name);
 866     EXPECT_EQ(static_cast<GLenum>(it->second.type), attrib_info->type);
 867     EXPECT_EQ(it->second.size, attrib_info->size);
 868     EXPECT_EQ(it->second.name, attrib_info->name);
 869   }
 870   // Check Uniforms
 871   for (unsigned index = 0; index < kNumUniforms; ++index) {
 872     const Program::UniformInfo* uniform_info =
 873         program->GetUniformInfo(index);
 874     ASSERT_TRUE(uniform_info != NULL);
 875     ShaderTranslator::VariableMap::const_iterator it = uniform_map.find(
 876         uniform_info->name);
 877     ASSERT_TRUE(it != uniform_map.end());
 878     EXPECT_EQ(it->first, uniform_info->name);
 879     EXPECT_EQ(static_cast<GLenum>(it->second.type), uniform_info->type);
 880     EXPECT_EQ(it->second.size, uniform_info->size);
 881     EXPECT_EQ(it->second.name, uniform_info->name);
 882   }
 883 }
 884
 885 TEST_F(ProgramManagerWithShaderTest, ProgramInfoUseCount) {
 886   static const GLuint kClientProgramId = 124;
 887   static const GLuint kServiceProgramId = 457;
 888   Program* program = manager_.CreateProgram(
 889       kClientProgramId, kServiceProgramId);
 890   ASSERT_TRUE(program != NULL);
 891   EXPECT_FALSE(program->CanLink());
 892   const GLuint kVShaderClientId = 2001;
 893   const GLuint kFShaderClientId = 2002;
 894   const GLuint kVShaderServiceId = 3001;
 895   const GLuint kFShaderServiceId = 3002;
 896   Shader* vshader = shader_manager_.CreateShader(
 897       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
 898   ASSERT_TRUE(vshader != NULL);
 899   TestHelper::SetShaderStates(gl_.get(), vshader, true);
 900   Shader* fshader = shader_manager_.CreateShader(
 901       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
 902   ASSERT_TRUE(fshader != NULL);
 903   TestHelper::SetShaderStates(gl_.get(), fshader, true);
 904   EXPECT_FALSE(vshader->InUse());
 905   EXPECT_FALSE(fshader->InUse());
 906   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
 907   EXPECT_TRUE(vshader->InUse());
 908   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 909   EXPECT_TRUE(fshader->InUse());
 910   EXPECT_TRUE(program->CanLink());
 911   EXPECT_FALSE(program->InUse());
 912   EXPECT_FALSE(program->IsDeleted());
 913   manager_.UseProgram(program);
 914   EXPECT_TRUE(program->InUse());
 915   manager_.UseProgram(program);
 916   EXPECT_TRUE(program->InUse());
 917   manager_.MarkAsDeleted(&shader_manager_, program);
 918   EXPECT_TRUE(program->IsDeleted());
 919   Program* info2 = manager_.GetProgram(kClientProgramId);
 920   EXPECT_EQ(program, info2);
 921   manager_.UnuseProgram(&shader_manager_, program);
 922   EXPECT_TRUE(program->InUse());
 923   // this should delete the info.
 924   EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId))
 925       .Times(1)
 926       .RetiresOnSaturation();
 927   manager_.UnuseProgram(&shader_manager_, program);
 928   info2 = manager_.GetProgram(kClientProgramId);
 929   EXPECT_TRUE(info2 == NULL);
 930   EXPECT_FALSE(vshader->InUse());
 931   EXPECT_FALSE(fshader->InUse());
 932 }
 933
 934 TEST_F(ProgramManagerWithShaderTest, ProgramInfoUseCount2) {
 935   static const GLuint kClientProgramId = 124;
 936   static const GLuint kServiceProgramId = 457;
 937   Program* program = manager_.CreateProgram(
 938       kClientProgramId, kServiceProgramId);
 939   ASSERT_TRUE(program != NULL);
 940   EXPECT_FALSE(program->CanLink());
 941   const GLuint kVShaderClientId = 2001;
 942   const GLuint kFShaderClientId = 2002;
 943   const GLuint kVShaderServiceId = 3001;
 944   const GLuint kFShaderServiceId = 3002;
 945   Shader* vshader = shader_manager_.CreateShader(
 946       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
 947   ASSERT_TRUE(vshader != NULL);
 948   TestHelper::SetShaderStates(gl_.get(), vshader, true);
 949   Shader* fshader = shader_manager_.CreateShader(
 950       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
 951   ASSERT_TRUE(fshader != NULL);
 952   TestHelper::SetShaderStates(gl_.get(), fshader, true);
 953   EXPECT_FALSE(vshader->InUse());
 954   EXPECT_FALSE(fshader->InUse());
 955   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
 956   EXPECT_TRUE(vshader->InUse());
 957   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
 958   EXPECT_TRUE(fshader->InUse());
 959   EXPECT_TRUE(program->CanLink());
 960   EXPECT_FALSE(program->InUse());
 961   EXPECT_FALSE(program->IsDeleted());
 962   manager_.UseProgram(program);
 963   EXPECT_TRUE(program->InUse());
 964   manager_.UseProgram(program);
 965   EXPECT_TRUE(program->InUse());
 966   manager_.UnuseProgram(&shader_manager_, program);
 967   EXPECT_TRUE(program->InUse());
 968   manager_.UnuseProgram(&shader_manager_, program);
 969   EXPECT_FALSE(program->InUse());
 970   Program* info2 = manager_.GetProgram(kClientProgramId);
 971   EXPECT_EQ(program, info2);
 972   // this should delete the program.
 973   EXPECT_CALL(*gl_, DeleteProgram(kServiceProgramId))
 974       .Times(1)
 975       .RetiresOnSaturation();
 976   manager_.MarkAsDeleted(&shader_manager_, program);
 977   info2 = manager_.GetProgram(kClientProgramId);
 978   EXPECT_TRUE(info2 == NULL);
 979   EXPECT_FALSE(vshader->InUse());
 980   EXPECT_FALSE(fshader->InUse());
 981 }
 982
 983 TEST_F(ProgramManagerWithShaderTest, ProgramInfoGetProgramInfo) {
 984   CommonDecoder::Bucket bucket;
 985   const Program* program = manager_.GetProgram(kClientProgramId);
 986   ASSERT_TRUE(program != NULL);
 987   program->GetProgramInfo(&manager_, &bucket);
 988   ProgramInfoHeader* header =
 989       bucket.GetDataAs<ProgramInfoHeader*>(0, sizeof(ProgramInfoHeader));
 990   ASSERT_TRUE(header != NULL);
 991   EXPECT_EQ(1u, header->link_status);
 992   EXPECT_EQ(arraysize(kAttribs), header->num_attribs);
 993   EXPECT_EQ(arraysize(kUniforms), header->num_uniforms);
 994   const ProgramInput* inputs = bucket.GetDataAs<const ProgramInput*>(
 995       sizeof(*header),
 996       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
 997   ASSERT_TRUE(inputs != NULL);
 998   const ProgramInput* input = inputs;
 999   // TODO(gman): Don't assume these are in order.
1000   for (uint32 ii = 0; ii < header->num_attribs; ++ii) {
1001     const AttribInfo& expected = kAttribs[ii];
1002     EXPECT_EQ(expected.size, input->size);
1003     EXPECT_EQ(expected.type, input->type);
1004     const int32* location = bucket.GetDataAs<const int32*>(
1005         input->location_offset, sizeof(int32));
1006     ASSERT_TRUE(location != NULL);
1007     EXPECT_EQ(expected.location, *location);
1008     const char* name_buf = bucket.GetDataAs<const char*>(
1009         input->name_offset, input->name_length);
1010     ASSERT_TRUE(name_buf != NULL);
1011     std::string name(name_buf, input->name_length);
1012     EXPECT_STREQ(expected.name, name.c_str());
1013     ++input;
1014   }
1015   // TODO(gman): Don't assume these are in order.
1016   for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
1017     const UniformInfo& expected = kUniforms[ii];
1018     EXPECT_EQ(expected.size, input->size);
1019     EXPECT_EQ(expected.type, input->type);
1020     const int32* locations = bucket.GetDataAs<const int32*>(
1021         input->location_offset, sizeof(int32) * input->size);
1022     ASSERT_TRUE(locations != NULL);
1023     for (int32 jj = 0; jj < input->size; ++jj) {
1024       EXPECT_EQ(
1025           ProgramManager::MakeFakeLocation(expected.fake_location, jj),
1026           locations[jj]);
1027     }
1028     const char* name_buf = bucket.GetDataAs<const char*>(
1029         input->name_offset, input->name_length);
1030     ASSERT_TRUE(name_buf != NULL);
1031     std::string name(name_buf, input->name_length);
1032     EXPECT_STREQ(expected.good_name, name.c_str());
1033     ++input;
1034   }
1035   EXPECT_EQ(header->num_attribs + header->num_uniforms,
1036             static_cast<uint32>(input - inputs));
1037 }
1038
1039 // Some drivers optimize out unused uniform array elements, so their
1040 // location would be -1.
1041 TEST_F(ProgramManagerWithShaderTest, UnusedUniformArrayElements) {
1042   CommonDecoder::Bucket bucket;
1043   const Program* program = manager_.GetProgram(kClientProgramId);
1044   ASSERT_TRUE(program != NULL);
1045   // Emulate the situation that only the first element has a valid location.
1046   // TODO(zmo): Don't assume these are in order.
1047   for (size_t ii = 0; ii < arraysize(kUniforms); ++ii) {
1048     Program::UniformInfo* uniform = const_cast<Program::UniformInfo*>(
1049         program->GetUniformInfo(ii));
1050     ASSERT_TRUE(uniform != NULL);
1051     EXPECT_EQ(static_cast<size_t>(kUniforms[ii].size),
1052               uniform->element_locations.size());
1053     for (GLsizei jj = 1; jj < uniform->size; ++jj)
1054       uniform->element_locations[jj] = -1;
1055   }
1056   program->GetProgramInfo(&manager_, &bucket);
1057   ProgramInfoHeader* header =
1058       bucket.GetDataAs<ProgramInfoHeader*>(0, sizeof(ProgramInfoHeader));
1059   ASSERT_TRUE(header != NULL);
1060   EXPECT_EQ(1u, header->link_status);
1061   EXPECT_EQ(arraysize(kAttribs), header->num_attribs);
1062   EXPECT_EQ(arraysize(kUniforms), header->num_uniforms);
1063   const ProgramInput* inputs = bucket.GetDataAs<const ProgramInput*>(
1064       sizeof(*header),
1065       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
1066   ASSERT_TRUE(inputs != NULL);
1067   const ProgramInput* input = inputs + header->num_attribs;
1068   for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
1069     const UniformInfo& expected = kUniforms[ii];
1070     EXPECT_EQ(expected.size, input->size);
1071     const int32* locations = bucket.GetDataAs<const int32*>(
1072         input->location_offset, sizeof(int32) * input->size);
1073     ASSERT_TRUE(locations != NULL);
1074     EXPECT_EQ(
1075         ProgramManager::MakeFakeLocation(expected.fake_location, 0),
1076         locations[0]);
1077     for (int32 jj = 1; jj < input->size; ++jj)
1078       EXPECT_EQ(-1, locations[jj]);
1079     ++input;
1080   }
1081 }
1082
1083 TEST_F(ProgramManagerWithShaderTest, BindAttribLocationConflicts) {
1084   // Set up shader
1085   const GLuint kVShaderClientId = 1;
1086   const GLuint kVShaderServiceId = 11;
1087   const GLuint kFShaderClientId = 2;
1088   const GLuint kFShaderServiceId = 12;
1089   ShaderTranslator::VariableMap attrib_map;
1090   for (uint32 ii = 0; ii < kNumAttribs; ++ii) {
1091     attrib_map[kAttribs[ii].name] = ShaderTranslatorInterface::VariableInfo(
1092         kAttribs[ii].type,
1093         kAttribs[ii].size,
1094         SH_PRECISION_MEDIUMP,
1095         kAttribStaticUse,
1096         kAttribs[ii].name);
1097   }
1098   // Check we can create shader.
1099   Shader* vshader = shader_manager_.CreateShader(
1100       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
1101   Shader* fshader = shader_manager_.CreateShader(
1102       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
1103   // Check shader got created.
1104   ASSERT_TRUE(vshader != NULL && fshader != NULL);
1105   // Set Status
1106   TestHelper::SetShaderStates(
1107       gl_.get(), vshader, true, NULL, NULL, &attrib_map, NULL, NULL, NULL);
1108   // Check attrib infos got copied.
1109   for (ShaderTranslator::VariableMap::const_iterator it = attrib_map.begin();
1110        it != attrib_map.end(); ++it) {
1111     const Shader::VariableInfo* variable_info =
1112         vshader->GetAttribInfo(it->first);
1113     ASSERT_TRUE(variable_info != NULL);
1114     EXPECT_EQ(it->second.type, variable_info->type);
1115     EXPECT_EQ(it->second.size, variable_info->size);
1116     EXPECT_EQ(it->second.precision, variable_info->precision);
1117     EXPECT_EQ(it->second.static_use, variable_info->static_use);
1118     EXPECT_EQ(it->second.name, variable_info->name);
1119   }
1120   TestHelper::SetShaderStates(
1121       gl_.get(), fshader, true, NULL, NULL, &attrib_map, NULL, NULL, NULL);
1122
1123   // Set up program
1124   const GLuint kClientProgramId = 6666;
1125   const GLuint kServiceProgramId = 8888;
1126   Program* program =
1127       manager_.CreateProgram(kClientProgramId, kServiceProgramId);
1128   ASSERT_TRUE(program != NULL);
1129   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
1130   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
1131
1132   EXPECT_FALSE(program->DetectAttribLocationBindingConflicts());
1133   EXPECT_TRUE(LinkAsExpected(program, true));
1134
1135   program->SetAttribLocationBinding(kAttrib1Name, 0);
1136   EXPECT_FALSE(program->DetectAttribLocationBindingConflicts());
1137   EXPECT_TRUE(LinkAsExpected(program, true));
1138
1139   program->SetAttribLocationBinding("xxx", 0);
1140   EXPECT_FALSE(program->DetectAttribLocationBindingConflicts());
1141   EXPECT_TRUE(LinkAsExpected(program, true));
1142
1143   program->SetAttribLocationBinding(kAttrib2Name, 1);
1144   EXPECT_FALSE(program->DetectAttribLocationBindingConflicts());
1145   EXPECT_TRUE(LinkAsExpected(program, true));
1146
1147   program->SetAttribLocationBinding(kAttrib2Name, 0);
1148   EXPECT_TRUE(program->DetectAttribLocationBindingConflicts());
1149   EXPECT_TRUE(LinkAsExpected(program, false));
1150 }
1151
1152 TEST_F(ProgramManagerWithShaderTest, UniformsPrecisionMismatch) {
1153   // Set up shader
1154   const GLuint kVShaderClientId = 1;
1155   const GLuint kVShaderServiceId = 11;
1156   const GLuint kFShaderClientId = 2;
1157   const GLuint kFShaderServiceId = 12;
1158
1159   ShaderTranslator::VariableMap vertex_uniform_map;
1160   vertex_uniform_map["a"] = ShaderTranslator::VariableInfo(
1161       1, 3, SH_PRECISION_MEDIUMP, 1, "a");
1162   ShaderTranslator::VariableMap frag_uniform_map;
1163   frag_uniform_map["a"] = ShaderTranslator::VariableInfo(
1164       1, 3, SH_PRECISION_LOWP, 1, "a");
1165
1166   // Check we can create shader.
1167   Shader* vshader = shader_manager_.CreateShader(
1168       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
1169   Shader* fshader = shader_manager_.CreateShader(
1170       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
1171   // Check shader got created.
1172   ASSERT_TRUE(vshader != NULL && fshader != NULL);
1173   // Set Status
1174   TestHelper::SetShaderStates(
1175       gl_.get(), vshader, true, NULL, NULL, NULL,
1176       &vertex_uniform_map, NULL, NULL);
1177   TestHelper::SetShaderStates(
1178       gl_.get(), fshader, true, NULL, NULL, NULL,
1179       &frag_uniform_map, NULL, NULL);
1180
1181   // Set up program
1182   const GLuint kClientProgramId = 6666;
1183   const GLuint kServiceProgramId = 8888;
1184   Program* program =
1185       manager_.CreateProgram(kClientProgramId, kServiceProgramId);
1186   ASSERT_TRUE(program != NULL);
1187   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
1188   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
1189
1190   std::string conflicting_name;
1191
1192   EXPECT_TRUE(program->DetectUniformsMismatch(&conflicting_name));
1193   EXPECT_EQ("a", conflicting_name);
1194   EXPECT_TRUE(LinkAsExpected(program, false));
1195 }
1196
1197 // If a varying has different type in the vertex and fragment
1198 // shader, linking should fail.
1199 TEST_F(ProgramManagerWithShaderTest, VaryingTypeMismatch) {
1200   const VarInfo kVertexVarying =
1201       { GL_FLOAT_VEC3, 1, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
1202   const VarInfo kFragmentVarying =
1203       { GL_FLOAT_VEC4, 1, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
1204   Program* program = SetupShaderVariableTest(
1205       &kVertexVarying, 1, &kFragmentVarying, 1);
1206
1207   std::string conflicting_name;
1208
1209   EXPECT_TRUE(program->DetectVaryingsMismatch(&conflicting_name));
1210   EXPECT_EQ("a", conflicting_name);
1211   EXPECT_TRUE(LinkAsExpected(program, false));
1212 }
1213
1214 // If a varying has different array size in the vertex and fragment
1215 // shader, linking should fail.
1216 TEST_F(ProgramManagerWithShaderTest, VaryingArraySizeMismatch) {
1217   const VarInfo kVertexVarying =
1218       { GL_FLOAT, 2, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
1219   const VarInfo kFragmentVarying =
1220       { GL_FLOAT, 3, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
1221   Program* program = SetupShaderVariableTest(
1222       &kVertexVarying, 1, &kFragmentVarying, 1);
1223
1224   std::string conflicting_name;
1225
1226   EXPECT_TRUE(program->DetectVaryingsMismatch(&conflicting_name));
1227   EXPECT_EQ("a", conflicting_name);
1228   EXPECT_TRUE(LinkAsExpected(program, false));
1229 }
1230
1231 // If a varying has different precision in the vertex and fragment
1232 // shader, linking should succeed.
1233 TEST_F(ProgramManagerWithShaderTest, VaryingPrecisionMismatch) {
1234   const VarInfo kVertexVarying =
1235       { GL_FLOAT, 2, SH_PRECISION_HIGHP, 1, "a", kVarVarying };
1236   const VarInfo kFragmentVarying =
1237       { GL_FLOAT, 2, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
1238   Program* program = SetupShaderVariableTest(
1239       &kVertexVarying, 1, &kFragmentVarying, 1);
1240
1241   std::string conflicting_name;
1242
1243   EXPECT_FALSE(program->DetectVaryingsMismatch(&conflicting_name));
1244   EXPECT_TRUE(conflicting_name.empty());
1245   EXPECT_TRUE(LinkAsExpected(program, true));
1246 }
1247
1248 // If a varying is statically used in fragment shader but not
1249 // declared in vertex shader, link should fail.
1250 TEST_F(ProgramManagerWithShaderTest, VaryingMissing) {
1251   const VarInfo kFragmentVarying =
1252       { GL_FLOAT, 3, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying };
1253   Program* program = SetupShaderVariableTest(
1254       NULL, 0, &kFragmentVarying, 1);
1255
1256   std::string conflicting_name;
1257
1258   EXPECT_TRUE(program->DetectVaryingsMismatch(&conflicting_name));
1259   EXPECT_EQ("a", conflicting_name);
1260   EXPECT_TRUE(LinkAsExpected(program, false));
1261 }
1262
1263 // If a varying is declared but not statically used in fragment
1264 // shader, even if it's not declared in vertex shader, link should
1265 // succeed.
1266 TEST_F(ProgramManagerWithShaderTest, InactiveVarying) {
1267   const VarInfo kFragmentVarying =
1268       { GL_FLOAT, 3, SH_PRECISION_MEDIUMP, 0, "a", kVarVarying };
1269   Program* program = SetupShaderVariableTest(
1270       NULL, 0, &kFragmentVarying, 1);
1271
1272   std::string conflicting_name;
1273
1274   EXPECT_FALSE(program->DetectVaryingsMismatch(&conflicting_name));
1275   EXPECT_TRUE(conflicting_name.empty());
1276   EXPECT_TRUE(LinkAsExpected(program, true));
1277 }
1278
1279 // Uniforms and attributes are both global variables, thus sharing
1280 // the same namespace. Any name conflicts should cause link
1281 // failure.
1282 TEST_F(ProgramManagerWithShaderTest, AttribUniformNameConflict) {
1283   const VarInfo kVertexAttribute =
1284       { GL_FLOAT_VEC4, 1, SH_PRECISION_MEDIUMP, 1, "a", kVarAttribute };
1285   const VarInfo kFragmentUniform =
1286       { GL_FLOAT_VEC4, 1, SH_PRECISION_MEDIUMP, 1, "a", kVarUniform };
1287   Program* program = SetupShaderVariableTest(
1288       &kVertexAttribute, 1, &kFragmentUniform, 1);
1289
1290   std::string conflicting_name;
1291
1292   EXPECT_TRUE(program->DetectGlobalNameConflicts(&conflicting_name));
1293   EXPECT_EQ("a", conflicting_name);
1294   EXPECT_TRUE(LinkAsExpected(program, false));
1295 }
1296
1297 // Varyings go over 8 rows.
1298 TEST_F(ProgramManagerWithShaderTest, TooManyVaryings) {
1299   const VarInfo kVertexVaryings[] = {
1300       { GL_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying },
1301       { GL_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b", kVarVarying }
1302   };
1303   const VarInfo kFragmentVaryings[] = {
1304       { GL_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying },
1305       { GL_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b", kVarVarying }
1306   };
1307   Program* program = SetupShaderVariableTest(
1308       kVertexVaryings, 2, kFragmentVaryings, 2);
1309
1310   EXPECT_FALSE(
1311       program->CheckVaryingsPacking(Program::kCountOnlyStaticallyUsed));
1312   EXPECT_TRUE(LinkAsExpected(program, false));
1313 }
1314
1315 // Varyings go over 8 rows but some are inactive
1316 TEST_F(ProgramManagerWithShaderTest, TooManyInactiveVaryings) {
1317   const VarInfo kVertexVaryings[] = {
1318       { GL_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying },
1319       { GL_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b", kVarVarying }
1320   };
1321   const VarInfo kFragmentVaryings[] = {
1322       { GL_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 0, "a", kVarVarying },
1323       { GL_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b", kVarVarying }
1324   };
1325   Program* program = SetupShaderVariableTest(
1326       kVertexVaryings, 2, kFragmentVaryings, 2);
1327
1328   EXPECT_TRUE(
1329       program->CheckVaryingsPacking(Program::kCountOnlyStaticallyUsed));
1330   EXPECT_TRUE(LinkAsExpected(program, true));
1331 }
1332
1333 // Varyings go over 8 rows but some are inactive.
1334 // However, we still fail the check if kCountAll option is used.
1335 TEST_F(ProgramManagerWithShaderTest, CountAllVaryingsInPacking) {
1336   const VarInfo kVertexVaryings[] = {
1337       { GL_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 1, "a", kVarVarying },
1338       { GL_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b", kVarVarying }
1339   };
1340   const VarInfo kFragmentVaryings[] = {
1341       { GL_FLOAT_VEC4, 4, SH_PRECISION_MEDIUMP, 0, "a", kVarVarying },
1342       { GL_FLOAT_VEC4, 5, SH_PRECISION_MEDIUMP, 1, "b", kVarVarying }
1343   };
1344   Program* program = SetupShaderVariableTest(
1345       kVertexVaryings, 2, kFragmentVaryings, 2);
1346
1347   EXPECT_FALSE(program->CheckVaryingsPacking(Program::kCountAll));
1348 }
1349
1350 TEST_F(ProgramManagerWithShaderTest, ClearWithSamplerTypes) {
1351   const GLuint kVShaderClientId = 2001;
1352   const GLuint kFShaderClientId = 2002;
1353   const GLuint kVShaderServiceId = 3001;
1354   const GLuint kFShaderServiceId = 3002;
1355   Shader* vshader = shader_manager_.CreateShader(
1356       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
1357   ASSERT_TRUE(vshader != NULL);
1358   TestHelper::SetShaderStates(gl_.get(), vshader, true);
1359   Shader* fshader = shader_manager_.CreateShader(
1360       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
1361   ASSERT_TRUE(fshader != NULL);
1362   TestHelper::SetShaderStates(gl_.get(), fshader, true);
1363   static const GLuint kClientProgramId = 1234;
1364   static const GLuint kServiceProgramId = 5679;
1365   Program* program = manager_.CreateProgram(
1366       kClientProgramId, kServiceProgramId);
1367   ASSERT_TRUE(program != NULL);
1368   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
1369   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
1370
1371   static const GLenum kSamplerTypes[] = {
1372     GL_SAMPLER_2D,
1373     GL_SAMPLER_CUBE,
1374     GL_SAMPLER_EXTERNAL_OES,
1375     GL_SAMPLER_3D_OES,
1376     GL_SAMPLER_2D_RECT_ARB,
1377   };
1378   const size_t kNumSamplerTypes = arraysize(kSamplerTypes);
1379   for (size_t ii = 0; ii < kNumSamplerTypes; ++ii) {
1380     static ProgramManagerWithShaderTest::AttribInfo kAttribs[] = {
1381       { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
1382       { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
1383       { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
1384     };
1385     ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
1386       { kUniform1Name,
1387         kUniform1Size,
1388         kUniform1Type,
1389         kUniform1FakeLocation,
1390         kUniform1RealLocation,
1391         kUniform1DesiredLocation,
1392         kUniform1Name,
1393       },
1394       { kUniform2Name,
1395         kUniform2Size,
1396         kSamplerTypes[ii],
1397         kUniform2FakeLocation,
1398         kUniform2RealLocation,
1399         kUniform2DesiredLocation,
1400         kUniform2Name,
1401       },
1402       { kUniform3BadName,
1403         kUniform3Size,
1404         kUniform3Type,
1405         kUniform3FakeLocation,
1406         kUniform3RealLocation,
1407         kUniform3DesiredLocation,
1408         kUniform3GoodName,
1409       },
1410     };
1411     const size_t kNumAttribs = arraysize(kAttribs);
1412     const size_t kNumUniforms = arraysize(kUniforms);
1413     SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
1414                 kServiceProgramId);
1415     program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
1416                   base::Bind(&ShaderCacheCb));
1417     SetupExpectationsForClearingUniforms(kUniforms, kNumUniforms);
1418     manager_.ClearUniforms(program);
1419   }
1420 }
1421
1422 TEST_F(ProgramManagerWithShaderTest, BindUniformLocation) {
1423   const GLuint kVShaderClientId = 2001;
1424   const GLuint kFShaderClientId = 2002;
1425   const GLuint kVShaderServiceId = 3001;
1426   const GLuint kFShaderServiceId = 3002;
1427
1428   const GLint kUniform1DesiredLocation = 10;
1429   const GLint kUniform2DesiredLocation = -1;
1430   const GLint kUniform3DesiredLocation = 5;
1431
1432   Shader* vshader = shader_manager_.CreateShader(
1433       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
1434   ASSERT_TRUE(vshader != NULL);
1435   TestHelper::SetShaderStates(gl_.get(), vshader, true);
1436   Shader* fshader = shader_manager_.CreateShader(
1437       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
1438   ASSERT_TRUE(fshader != NULL);
1439   TestHelper::SetShaderStates(gl_.get(), fshader, true);
1440   static const GLuint kClientProgramId = 1234;
1441   static const GLuint kServiceProgramId = 5679;
1442   Program* program = manager_.CreateProgram(
1443       kClientProgramId, kServiceProgramId);
1444   ASSERT_TRUE(program != NULL);
1445   EXPECT_TRUE(program->AttachShader(&shader_manager_, vshader));
1446   EXPECT_TRUE(program->AttachShader(&shader_manager_, fshader));
1447   EXPECT_TRUE(program->SetUniformLocationBinding(
1448       kUniform1Name, kUniform1DesiredLocation));
1449   EXPECT_TRUE(program->SetUniformLocationBinding(
1450       kUniform3BadName, kUniform3DesiredLocation));
1451
1452   static ProgramManagerWithShaderTest::AttribInfo kAttribs[] = {
1453     { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
1454     { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
1455     { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
1456   };
1457   ProgramManagerWithShaderTest::UniformInfo kUniforms[] = {
1458     { kUniform1Name,
1459       kUniform1Size,
1460       kUniform1Type,
1461       kUniform1FakeLocation,
1462       kUniform1RealLocation,
1463       kUniform1DesiredLocation,
1464       kUniform1Name,
1465     },
1466     { kUniform2Name,
1467       kUniform2Size,
1468       kUniform2Type,
1469       kUniform2FakeLocation,
1470       kUniform2RealLocation,
1471       kUniform2DesiredLocation,
1472       kUniform2Name,
1473     },
1474     { kUniform3BadName,
1475       kUniform3Size,
1476       kUniform3Type,
1477       kUniform3FakeLocation,
1478       kUniform3RealLocation,
1479       kUniform3DesiredLocation,
1480       kUniform3GoodName,
1481     },
1482   };
1483
1484   const size_t kNumAttribs = arraysize(kAttribs);
1485   const size_t kNumUniforms = arraysize(kUniforms);
1486   SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
1487               kServiceProgramId);
1488   program->Link(NULL, NULL, NULL, Program::kCountOnlyStaticallyUsed,
1489                 base::Bind(&ShaderCacheCb));
1490
1491   EXPECT_EQ(kUniform1DesiredLocation,
1492             program->GetUniformFakeLocation(kUniform1Name));
1493   EXPECT_EQ(kUniform3DesiredLocation,
1494             program->GetUniformFakeLocation(kUniform3BadName));
1495   EXPECT_EQ(kUniform3DesiredLocation,
1496             program->GetUniformFakeLocation(kUniform3GoodName));
1497 }
1498
1499 class ProgramManagerWithCacheTest : public GpuServiceTest {
1500  public:
1501   static const GLuint kClientProgramId = 1;
1502   static const GLuint kServiceProgramId = 10;
1503   static const GLuint kVertexShaderClientId = 2;
1504   static const GLuint kFragmentShaderClientId = 20;
1505   static const GLuint kVertexShaderServiceId = 3;
1506   static const GLuint kFragmentShaderServiceId = 30;
1507
1508   ProgramManagerWithCacheTest()
1509       : cache_(new MockProgramCache()),
1510         manager_(cache_.get(), kMaxVaryingVectors),
1511         vertex_shader_(NULL),
1512         fragment_shader_(NULL),
1513         program_(NULL) {
1514   }
1515   virtual ~ProgramManagerWithCacheTest() {
1516     manager_.Destroy(false);
1517     shader_manager_.Destroy(false);
1518   }
1519
1520  protected:
1521   virtual void SetUp() {
1522     GpuServiceTest::SetUp();
1523
1524     vertex_shader_ = shader_manager_.CreateShader(
1525        kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
1526     fragment_shader_ = shader_manager_.CreateShader(
1527        kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
1528     ASSERT_TRUE(vertex_shader_ != NULL);
1529     ASSERT_TRUE(fragment_shader_ != NULL);
1530     vertex_shader_->set_source("lka asjf bjajsdfj");
1531     fragment_shader_->set_source("lka asjf a   fasgag 3rdsf3 bjajsdfj");
1532
1533     program_ = manager_.CreateProgram(
1534         kClientProgramId, kServiceProgramId);
1535     ASSERT_TRUE(program_ != NULL);
1536
1537     program_->AttachShader(&shader_manager_, vertex_shader_);
1538     program_->AttachShader(&shader_manager_, fragment_shader_);
1539   }
1540
1541   void SetShadersCompiled() {
1542     TestHelper::SetShaderStates(gl_.get(), vertex_shader_, true);
1543     TestHelper::SetShaderStates(gl_.get(), fragment_shader_, true);
1544   }
1545
1546   void SetProgramCached() {
1547     cache_->LinkedProgramCacheSuccess(
1548         vertex_shader_->source(),
1549         NULL,
1550         fragment_shader_->source(),
1551         NULL,
1552         &program_->bind_attrib_location_map());
1553   }
1554
1555   void SetExpectationsForProgramCached() {
1556     SetExpectationsForProgramCached(program_,
1557                                     vertex_shader_,
1558                                     fragment_shader_);
1559   }
1560
1561   void SetExpectationsForProgramCached(
1562       Program* program,
1563       Shader* vertex_shader,
1564       Shader* fragment_shader) {
1565     EXPECT_CALL(*cache_.get(), SaveLinkedProgram(
1566         program->service_id(),
1567         vertex_shader,
1568         NULL,
1569         fragment_shader,
1570         NULL,
1571         &program->bind_attrib_location_map(),
1572         _)).Times(1);
1573   }
1574
1575   void SetExpectationsForNotCachingProgram() {
1576     SetExpectationsForNotCachingProgram(program_,
1577                                         vertex_shader_,
1578                                         fragment_shader_);
1579   }
1580
1581   void SetExpectationsForNotCachingProgram(
1582       Program* program,
1583       Shader* vertex_shader,
1584       Shader* fragment_shader) {
1585     EXPECT_CALL(*cache_.get(), SaveLinkedProgram(
1586         program->service_id(),
1587         vertex_shader,
1588         NULL,
1589         fragment_shader,
1590         NULL,
1591         &program->bind_attrib_location_map(),
1592         _)).Times(0);
1593   }
1594
1595   void SetExpectationsForProgramLoad(ProgramCache::ProgramLoadResult result) {
1596     SetExpectationsForProgramLoad(kServiceProgramId,
1597                                   program_,
1598                                   vertex_shader_,
1599                                   fragment_shader_,
1600                                   result);
1601   }
1602
1603   void SetExpectationsForProgramLoad(
1604       GLuint service_program_id,
1605       Program* program,
1606       Shader* vertex_shader,
1607       Shader* fragment_shader,
1608       ProgramCache::ProgramLoadResult result) {
1609     EXPECT_CALL(*cache_.get(),
1610                 LoadLinkedProgram(service_program_id,
1611                                   vertex_shader,
1612                                   NULL,
1613                                   fragment_shader,
1614                                   NULL,
1615                                   &program->bind_attrib_location_map(),
1616                                   _))
1617         .WillOnce(Return(result));
1618   }
1619
1620   void SetExpectationsForProgramLoadSuccess() {
1621     SetExpectationsForProgramLoadSuccess(kServiceProgramId);
1622   }
1623
1624   void SetExpectationsForProgramLoadSuccess(GLuint service_program_id) {
1625     TestHelper::SetupProgramSuccessExpectations(gl_.get(),
1626                                                 NULL,
1627                                                 0,
1628                                                 NULL,
1629                                                 0,
1630                                                 service_program_id);
1631   }
1632
1633   void SetExpectationsForProgramLink() {
1634     SetExpectationsForProgramLink(kServiceProgramId);
1635   }
1636
1637   void SetExpectationsForProgramLink(GLuint service_program_id) {
1638     TestHelper::SetupShader(gl_.get(), NULL, 0, NULL, 0, service_program_id);
1639     if (gfx::g_driver_gl.ext.b_GL_ARB_get_program_binary) {
1640       EXPECT_CALL(*gl_.get(),
1641                   ProgramParameteri(service_program_id,
1642                                     PROGRAM_BINARY_RETRIEVABLE_HINT,
1643                                     GL_TRUE)).Times(1);
1644     }
1645   }
1646
1647   void SetExpectationsForSuccessCompile(
1648       const Shader* shader) {
1649     const GLuint shader_id = shader->service_id();
1650     const char* src = shader->source().c_str();
1651     EXPECT_CALL(*gl_.get(),
1652                 ShaderSource(shader_id, 1, Pointee(src), NULL)).Times(1);
1653     EXPECT_CALL(*gl_.get(), CompileShader(shader_id)).Times(1);
1654     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_COMPILE_STATUS, _))
1655         .WillOnce(SetArgumentPointee<2>(GL_TRUE));
1656   }
1657
1658   void SetExpectationsForNoCompile(const Shader* shader) {
1659     const GLuint shader_id = shader->service_id();
1660     const char* src = shader->source().c_str();
1661     EXPECT_CALL(*gl_.get(),
1662                 ShaderSource(shader_id, 1, Pointee(src), NULL)).Times(0);
1663     EXPECT_CALL(*gl_.get(), CompileShader(shader_id)).Times(0);
1664     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_COMPILE_STATUS, _))
1665         .Times(0);
1666   }
1667
1668   void SetExpectationsForErrorCompile(const Shader* shader) {
1669     const GLuint shader_id = shader->service_id();
1670     const char* src = shader->source().c_str();
1671     EXPECT_CALL(*gl_.get(),
1672                 ShaderSource(shader_id, 1, Pointee(src), NULL)).Times(1);
1673     EXPECT_CALL(*gl_.get(), CompileShader(shader_id)).Times(1);
1674     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_COMPILE_STATUS, _))
1675         .WillOnce(SetArgumentPointee<2>(GL_FALSE));
1676     EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_INFO_LOG_LENGTH, _))
1677         .WillOnce(SetArgumentPointee<2>(0));
1678     EXPECT_CALL(*gl_.get(), GetShaderInfoLog(shader_id, 0, _, _))
1679         .Times(1);
1680   }
1681
1682   scoped_ptr<MockProgramCache> cache_;
1683   ProgramManager manager_;
1684
1685   Shader* vertex_shader_;
1686   Shader* fragment_shader_;
1687   Program* program_;
1688   ShaderManager shader_manager_;
1689 };
1690
1691 // GCC requires these declarations, but MSVC requires they not be present
1692 #ifndef COMPILER_MSVC
1693 const GLuint ProgramManagerWithCacheTest::kClientProgramId;
1694 const GLuint ProgramManagerWithCacheTest::kServiceProgramId;
1695 const GLuint ProgramManagerWithCacheTest::kVertexShaderClientId;
1696 const GLuint ProgramManagerWithCacheTest::kFragmentShaderClientId;
1697 const GLuint ProgramManagerWithCacheTest::kVertexShaderServiceId;
1698 const GLuint ProgramManagerWithCacheTest::kFragmentShaderServiceId;
1699 #endif
1700
1701 TEST_F(ProgramManagerWithCacheTest, CacheProgramOnSuccessfulLink) {
1702   SetShadersCompiled();
1703   SetExpectationsForProgramLink();
1704   SetExpectationsForProgramCached();
1705   EXPECT_TRUE(program_->Link(NULL, NULL, NULL,
1706       Program::kCountOnlyStaticallyUsed, base::Bind(&ShaderCacheCb)));
1707 }
1708
1709 TEST_F(ProgramManagerWithCacheTest, LoadProgramOnProgramCacheHit) {
1710   SetShadersCompiled();
1711   SetProgramCached();
1712
1713   SetExpectationsForNoCompile(vertex_shader_);
1714   SetExpectationsForNoCompile(fragment_shader_);
1715   SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS);
1716   SetExpectationsForNotCachingProgram();
1717   SetExpectationsForProgramLoadSuccess();
1718
1719   EXPECT_TRUE(program_->Link(NULL, NULL, NULL,
1720       Program::kCountOnlyStaticallyUsed, base::Bind(&ShaderCacheCb)));
1721 }
1722
1723 }  // namespace gles2
1724 }  // namespace gpu