gpu/command_buffer/service/memory_program_cache_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/memory_program_cache.h"
   6
   7 #include "base/bind.h"
   8 #include "gpu/command_buffer/common/gles2_cmd_format.h"
   9 #include "gpu/command_buffer/service/gl_utils.h"
  10 #include "gpu/command_buffer/service/gpu_service_test.h"
  11 #include "gpu/command_buffer/service/shader_manager.h"
  12 #include "gpu/command_buffer/service/shader_translator.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14 #include "ui/gl/gl_bindings.h"
  15 #include "ui/gl/gl_mock.h"
  16
  17 using ::testing::_;
  18 using ::testing::ElementsAreArray;
  19 using ::testing::Invoke;
  20 using ::testing::SetArgPointee;
  21 using ::testing::SetArrayArgument;
  22
  23 namespace {
  24 typedef gpu::gles2::ShaderTranslator::VariableMap VariableMap;
  25 }  // anonymous namespace
  26
  27 namespace gpu {
  28 namespace gles2 {
  29
  30 class ProgramBinaryEmulator {
  31  public:
  32   ProgramBinaryEmulator(GLsizei length,
  33                         GLenum format,
  34                         const char* binary)
  35       : length_(length),
  36         format_(format),
  37         binary_(binary) { }
  38
  39   void GetProgramBinary(GLuint program,
  40                         GLsizei buffer_size,
  41                         GLsizei* length,
  42                         GLenum* format,
  43                         GLvoid* binary) {
  44     if (length) {
  45       *length = length_;
  46     }
  47     *format = format_;
  48     memcpy(binary, binary_, length_);
  49   }
  50
  51   void ProgramBinary(GLuint program,
  52                      GLenum format,
  53                      const GLvoid* binary,
  54                      GLsizei length) {
  55     // format and length are verified by matcher
  56     EXPECT_EQ(0, memcmp(binary_, binary, length));
  57   }
  58
  59   GLsizei length() const { return length_; }
  60   GLenum format() const { return format_; }
  61   const char* binary() const { return binary_; }
  62
  63  private:
  64   GLsizei length_;
  65   GLenum format_;
  66   const char* binary_;
  67 };
  68
  69 class MemoryProgramCacheTest : public GpuServiceTest {
  70  public:
  71   static const size_t kCacheSizeBytes = 1024;
  72   static const GLuint kVertexShaderClientId = 90;
  73   static const GLuint kVertexShaderServiceId = 100;
  74   static const GLuint kFragmentShaderClientId = 91;
  75   static const GLuint kFragmentShaderServiceId = 100;
  76
  77   MemoryProgramCacheTest()
  78       : cache_(new MemoryProgramCache(kCacheSizeBytes)),
  79         vertex_shader_(NULL),
  80         fragment_shader_(NULL),
  81         shader_cache_count_(0) { }
  82   virtual ~MemoryProgramCacheTest() {
  83     shader_manager_.Destroy(false);
  84   }
  85
  86   void ShaderCacheCb(const std::string& key, const std::string& shader) {
  87     shader_cache_count_++;
  88     shader_cache_shader_ = shader;
  89   }
  90
  91   int32 shader_cache_count() { return shader_cache_count_; }
  92   const std::string& shader_cache_shader() { return shader_cache_shader_; }
  93
  94  protected:
  95   virtual void SetUp() {
  96     GpuServiceTest::SetUp();
  97
  98     vertex_shader_ = shader_manager_.CreateShader(kVertexShaderClientId,
  99                                                   kVertexShaderServiceId,
 100                                                   GL_VERTEX_SHADER);
 101     fragment_shader_ = shader_manager_.CreateShader(
 102         kFragmentShaderClientId,
 103         kFragmentShaderServiceId,
 104         GL_FRAGMENT_SHADER);
 105     ASSERT_TRUE(vertex_shader_ != NULL);
 106     ASSERT_TRUE(fragment_shader_ != NULL);
 107     typedef ShaderTranslatorInterface::VariableInfo VariableInfo;
 108     typedef ShaderTranslator::VariableMap VariableMap;
 109     VariableMap vertex_attrib_map;
 110     VariableMap vertex_uniform_map;
 111     VariableMap vertex_varying_map;
 112     VariableMap fragment_attrib_map;
 113     VariableMap fragment_uniform_map;
 114     VariableMap fragment_varying_map;
 115
 116     vertex_attrib_map["a"] = VariableInfo(1, 34, SH_PRECISION_LOWP, 0, "a");
 117     vertex_uniform_map["a"] = VariableInfo(0, 10, SH_PRECISION_MEDIUMP, 1, "a");
 118     vertex_uniform_map["b"] = VariableInfo(2, 3114, SH_PRECISION_HIGHP, 1, "b");
 119     vertex_varying_map["c"] = VariableInfo(3, 2, SH_PRECISION_HIGHP, 1, "c");
 120     fragment_attrib_map["jjjbb"] =
 121         VariableInfo(463, 1114, SH_PRECISION_MEDIUMP, 0, "jjjbb");
 122     fragment_uniform_map["k"] =
 123         VariableInfo(10, 34413, SH_PRECISION_MEDIUMP, 1, "k");
 124     fragment_varying_map["c"] = VariableInfo(3, 2, SH_PRECISION_HIGHP, 1, "c");
 125
 126     vertex_shader_->set_attrib_map(vertex_attrib_map);
 127     vertex_shader_->set_uniform_map(vertex_uniform_map);
 128     vertex_shader_->set_varying_map(vertex_varying_map);
 129     fragment_shader_->set_attrib_map(vertex_attrib_map);
 130     fragment_shader_->set_uniform_map(vertex_uniform_map);
 131     fragment_shader_->set_varying_map(vertex_varying_map);
 132
 133     vertex_shader_->UpdateSource("bbbalsldkdkdkd");
 134     fragment_shader_->UpdateSource("bbbal   sldkdkdkas 134 ad");
 135
 136     vertex_shader_->SetStatus(true, NULL, NULL);
 137     fragment_shader_->SetStatus(true, NULL, NULL);
 138   }
 139
 140   void SetExpectationsForSaveLinkedProgram(
 141       const GLint program_id,
 142       ProgramBinaryEmulator* emulator) const {
 143     EXPECT_CALL(*gl_.get(),
 144                 GetProgramiv(program_id, GL_PROGRAM_BINARY_LENGTH_OES, _))
 145         .WillOnce(SetArgPointee<2>(emulator->length()));
 146     EXPECT_CALL(*gl_.get(),
 147                 GetProgramBinary(program_id, emulator->length(), _, _, _))
 148         .WillOnce(Invoke(emulator, &ProgramBinaryEmulator::GetProgramBinary));
 149   }
 150
 151   void SetExpectationsForLoadLinkedProgram(
 152       const GLint program_id,
 153       ProgramBinaryEmulator* emulator) const {
 154     EXPECT_CALL(*gl_.get(),
 155                 ProgramBinary(program_id,
 156                               emulator->format(),
 157                               _,
 158                               emulator->length()))
 159         .WillOnce(Invoke(emulator, &ProgramBinaryEmulator::ProgramBinary));
 160     EXPECT_CALL(*gl_.get(),
 161                 GetProgramiv(program_id, GL_LINK_STATUS, _))
 162                 .WillOnce(SetArgPointee<2>(GL_TRUE));
 163   }
 164
 165   void SetExpectationsForLoadLinkedProgramFailure(
 166       const GLint program_id,
 167       ProgramBinaryEmulator* emulator) const {
 168     EXPECT_CALL(*gl_.get(),
 169                 ProgramBinary(program_id,
 170                               emulator->format(),
 171                               _,
 172                               emulator->length()))
 173         .WillOnce(Invoke(emulator, &ProgramBinaryEmulator::ProgramBinary));
 174     EXPECT_CALL(*gl_.get(),
 175                 GetProgramiv(program_id, GL_LINK_STATUS, _))
 176                 .WillOnce(SetArgPointee<2>(GL_FALSE));
 177   }
 178
 179   scoped_ptr<MemoryProgramCache> cache_;
 180   ShaderManager shader_manager_;
 181   Shader* vertex_shader_;
 182   Shader* fragment_shader_;
 183   int32 shader_cache_count_;
 184   std::string shader_cache_shader_;
 185 };
 186
 187 TEST_F(MemoryProgramCacheTest, CacheSave) {
 188   const GLenum kFormat = 1;
 189   const int kProgramId = 10;
 190   const int kBinaryLength = 20;
 191   char test_binary[kBinaryLength];
 192   for (int i = 0; i < kBinaryLength; ++i) {
 193     test_binary[i] = i;
 194   }
 195   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 196
 197   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
 198   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 199                             fragment_shader_, NULL, NULL,
 200                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 201                                        base::Unretained(this)));
 202
 203   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
 204       *vertex_shader_->signature_source(),
 205       NULL,
 206       *fragment_shader_->signature_source(),
 207       NULL,
 208       NULL));
 209   EXPECT_EQ(1, shader_cache_count());
 210 }
 211
 212 TEST_F(MemoryProgramCacheTest, LoadProgram) {
 213   const GLenum kFormat = 1;
 214   const int kProgramId = 10;
 215   const int kBinaryLength = 20;
 216   char test_binary[kBinaryLength];
 217   for (int i = 0; i < kBinaryLength; ++i) {
 218     test_binary[i] = i;
 219   }
 220   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 221
 222   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
 223   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 224                             fragment_shader_, NULL, NULL,
 225                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 226                                        base::Unretained(this)));
 227
 228   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
 229       *vertex_shader_->signature_source(),
 230       NULL,
 231       *fragment_shader_->signature_source(),
 232       NULL,
 233       NULL));
 234   EXPECT_EQ(1, shader_cache_count());
 235
 236   cache_->Clear();
 237
 238   cache_->LoadProgram(shader_cache_shader());
 239   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
 240       *vertex_shader_->signature_source(),
 241       NULL,
 242       *fragment_shader_->signature_source(),
 243       NULL,
 244       NULL));
 245 }
 246
 247 TEST_F(MemoryProgramCacheTest, CacheLoadMatchesSave) {
 248   const GLenum kFormat = 1;
 249   const int kProgramId = 10;
 250   const int kBinaryLength = 20;
 251   char test_binary[kBinaryLength];
 252   for (int i = 0; i < kBinaryLength; ++i) {
 253     test_binary[i] = i;
 254   }
 255   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 256
 257   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
 258   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 259                             fragment_shader_, NULL, NULL,
 260                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 261                                        base::Unretained(this)));
 262   EXPECT_EQ(1, shader_cache_count());
 263
 264   VariableMap vertex_attrib_map = vertex_shader_->attrib_map();
 265   VariableMap vertex_uniform_map = vertex_shader_->uniform_map();
 266   VariableMap vertex_varying_map = vertex_shader_->varying_map();
 267   VariableMap fragment_attrib_map = fragment_shader_->attrib_map();
 268   VariableMap fragment_uniform_map = fragment_shader_->uniform_map();
 269   VariableMap fragment_varying_map = fragment_shader_->varying_map();
 270
 271   vertex_shader_->set_attrib_map(VariableMap());
 272   vertex_shader_->set_uniform_map(VariableMap());
 273   vertex_shader_->set_varying_map(VariableMap());
 274   fragment_shader_->set_attrib_map(VariableMap());
 275   fragment_shader_->set_uniform_map(VariableMap());
 276   fragment_shader_->set_varying_map(VariableMap());
 277
 278   SetExpectationsForLoadLinkedProgram(kProgramId, &emulator);
 279
 280   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram(
 281       kProgramId,
 282       vertex_shader_,
 283       NULL,
 284       fragment_shader_,
 285       NULL,
 286       NULL,
 287       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 288                  base::Unretained(this))));
 289
 290   // apparently the hash_map implementation on android doesn't have the
 291   // equality operator
 292 #if !defined(OS_ANDROID)
 293   EXPECT_EQ(vertex_attrib_map, vertex_shader_->attrib_map());
 294   EXPECT_EQ(vertex_uniform_map, vertex_shader_->uniform_map());
 295   EXPECT_EQ(vertex_varying_map, vertex_shader_->varying_map());
 296   EXPECT_EQ(fragment_attrib_map, fragment_shader_->attrib_map());
 297   EXPECT_EQ(fragment_uniform_map, fragment_shader_->uniform_map());
 298   EXPECT_EQ(fragment_varying_map, fragment_shader_->varying_map());
 299 #endif
 300 }
 301
 302 TEST_F(MemoryProgramCacheTest, LoadProgramMatchesSave) {
 303   const GLenum kFormat = 1;
 304   const int kProgramId = 10;
 305   const int kBinaryLength = 20;
 306   char test_binary[kBinaryLength];
 307   for (int i = 0; i < kBinaryLength; ++i) {
 308     test_binary[i] = i;
 309   }
 310   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 311
 312   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
 313   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 314                             fragment_shader_, NULL, NULL,
 315                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 316                                        base::Unretained(this)));
 317   EXPECT_EQ(1, shader_cache_count());
 318
 319   VariableMap vertex_attrib_map = vertex_shader_->attrib_map();
 320   VariableMap vertex_uniform_map = vertex_shader_->uniform_map();
 321   VariableMap vertex_varying_map = vertex_shader_->varying_map();
 322   VariableMap fragment_attrib_map = fragment_shader_->attrib_map();
 323   VariableMap fragment_uniform_map = fragment_shader_->uniform_map();
 324   VariableMap fragment_varying_map = fragment_shader_->varying_map();
 325
 326   vertex_shader_->set_attrib_map(VariableMap());
 327   vertex_shader_->set_uniform_map(VariableMap());
 328   vertex_shader_->set_varying_map(VariableMap());
 329   fragment_shader_->set_attrib_map(VariableMap());
 330   fragment_shader_->set_uniform_map(VariableMap());
 331   fragment_shader_->set_varying_map(VariableMap());
 332
 333   SetExpectationsForLoadLinkedProgram(kProgramId, &emulator);
 334
 335   cache_->Clear();
 336   cache_->LoadProgram(shader_cache_shader());
 337
 338   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram(
 339       kProgramId,
 340       vertex_shader_,
 341       NULL,
 342       fragment_shader_,
 343       NULL,
 344       NULL,
 345       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 346                  base::Unretained(this))));
 347
 348   // apparently the hash_map implementation on android doesn't have the
 349   // equality operator
 350 #if !defined(OS_ANDROID)
 351   EXPECT_EQ(vertex_attrib_map, vertex_shader_->attrib_map());
 352   EXPECT_EQ(vertex_uniform_map, vertex_shader_->uniform_map());
 353   EXPECT_EQ(vertex_varying_map, vertex_shader_->varying_map());
 354   EXPECT_EQ(fragment_attrib_map, fragment_shader_->attrib_map());
 355   EXPECT_EQ(fragment_uniform_map, fragment_shader_->uniform_map());
 356   EXPECT_EQ(fragment_varying_map, fragment_shader_->varying_map());
 357 #endif
 358 }
 359
 360 TEST_F(MemoryProgramCacheTest, LoadFailOnLinkFalse) {
 361   const GLenum kFormat = 1;
 362   const int kProgramId = 10;
 363   const int kBinaryLength = 20;
 364   char test_binary[kBinaryLength];
 365   for (int i = 0; i < kBinaryLength; ++i) {
 366     test_binary[i] = i;
 367   }
 368   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 369
 370   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
 371   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 372                             fragment_shader_, NULL, NULL,
 373                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 374                                        base::Unretained(this)));
 375
 376   SetExpectationsForLoadLinkedProgramFailure(kProgramId, &emulator);
 377   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
 378       kProgramId,
 379       vertex_shader_,
 380       NULL,
 381       fragment_shader_,
 382       NULL,
 383       NULL,
 384       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 385                  base::Unretained(this))));
 386 }
 387
 388 TEST_F(MemoryProgramCacheTest, LoadFailOnDifferentSource) {
 389   const GLenum kFormat = 1;
 390   const int kProgramId = 10;
 391   const int kBinaryLength = 20;
 392   char test_binary[kBinaryLength];
 393   for (int i = 0; i < kBinaryLength; ++i) {
 394     test_binary[i] = i;
 395   }
 396   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 397
 398   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
 399   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 400                             fragment_shader_, NULL, NULL,
 401                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 402                                        base::Unretained(this)));
 403
 404   const std::string vertex_orig_source =
 405       *vertex_shader_->signature_source();
 406   vertex_shader_->UpdateSource("different!");
 407   vertex_shader_->SetStatus(true, NULL, NULL);
 408   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
 409       kProgramId,
 410       vertex_shader_,
 411       NULL,
 412       fragment_shader_,
 413       NULL,
 414       NULL,
 415       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 416                  base::Unretained(this))));
 417
 418   vertex_shader_->UpdateSource(vertex_orig_source.c_str());
 419   vertex_shader_->SetStatus(true, NULL, NULL);
 420   fragment_shader_->UpdateSource("different!");
 421   fragment_shader_->SetStatus(true, NULL, NULL);
 422   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
 423       kProgramId,
 424       vertex_shader_,
 425       NULL,
 426       fragment_shader_,
 427       NULL,
 428       NULL,
 429       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 430                  base::Unretained(this))));
 431 }
 432
 433 TEST_F(MemoryProgramCacheTest, LoadFailOnDifferentMap) {
 434   const GLenum kFormat = 1;
 435   const int kProgramId = 10;
 436   const int kBinaryLength = 20;
 437   char test_binary[kBinaryLength];
 438   for (int i = 0; i < kBinaryLength; ++i) {
 439     test_binary[i] = i;
 440   }
 441   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 442
 443   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
 444   ProgramCache::LocationMap binding_map;
 445   binding_map["test"] = 512;
 446   cache_->SaveLinkedProgram(kProgramId,
 447                             vertex_shader_,
 448                             NULL,
 449                             fragment_shader_,
 450                             NULL,
 451                             &binding_map,
 452                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 453                                        base::Unretained(this)));
 454
 455   binding_map["different!"] = 59;
 456   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
 457       kProgramId,
 458       vertex_shader_,
 459       NULL,
 460       fragment_shader_,
 461       NULL,
 462       &binding_map,
 463       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 464                  base::Unretained(this))));
 465   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
 466       kProgramId,
 467       vertex_shader_,
 468       NULL,
 469       fragment_shader_,
 470       NULL,
 471       NULL,
 472       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 473                  base::Unretained(this))));
 474 }
 475
 476 TEST_F(MemoryProgramCacheTest, MemoryProgramCacheEviction) {
 477   const GLenum kFormat = 1;
 478   const int kProgramId = 10;
 479   const int kBinaryLength = 20;
 480   char test_binary[kBinaryLength];
 481   for (int i = 0; i < kBinaryLength; ++i) {
 482     test_binary[i] = i;
 483   }
 484   ProgramBinaryEmulator emulator1(kBinaryLength, kFormat, test_binary);
 485
 486
 487   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator1);
 488   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 489                             fragment_shader_, NULL, NULL,
 490                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 491                                        base::Unretained(this)));
 492
 493   const int kEvictingProgramId = 11;
 494   const GLuint kEvictingBinaryLength = kCacheSizeBytes - kBinaryLength + 1;
 495
 496   // save old source and modify for new program
 497   const std::string old_source =
 498       *fragment_shader_->signature_source();
 499   fragment_shader_->UpdateSource("al sdfkjdk");
 500   fragment_shader_->SetStatus(true, NULL, NULL);
 501
 502   scoped_ptr<char[]> bigTestBinary =
 503       scoped_ptr<char[]>(new char[kEvictingBinaryLength]);
 504   for (size_t i = 0; i < kEvictingBinaryLength; ++i) {
 505     bigTestBinary[i] = i % 250;
 506   }
 507   ProgramBinaryEmulator emulator2(kEvictingBinaryLength,
 508                                   kFormat,
 509                                   bigTestBinary.get());
 510
 511   SetExpectationsForSaveLinkedProgram(kEvictingProgramId, &emulator2);
 512   cache_->SaveLinkedProgram(kEvictingProgramId,
 513                             vertex_shader_,
 514                             NULL,
 515                             fragment_shader_,
 516                             NULL,
 517                             NULL,
 518                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 519                                        base::Unretained(this)));
 520
 521   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
 522       *vertex_shader_->signature_source(),
 523       NULL,
 524       *fragment_shader_->signature_source(),
 525       NULL,
 526       NULL));
 527   EXPECT_EQ(ProgramCache::LINK_UNKNOWN, cache_->GetLinkedProgramStatus(
 528       old_source,
 529       NULL,
 530       *fragment_shader_->signature_source(),
 531       NULL,
 532       NULL));
 533 }
 534
 535 TEST_F(MemoryProgramCacheTest, SaveCorrectProgram) {
 536   const GLenum kFormat = 1;
 537   const int kProgramId = 10;
 538   const int kBinaryLength = 20;
 539   char test_binary[kBinaryLength];
 540   for (int i = 0; i < kBinaryLength; ++i) {
 541     test_binary[i] = i;
 542   }
 543   ProgramBinaryEmulator emulator1(kBinaryLength, kFormat, test_binary);
 544
 545   vertex_shader_->UpdateSource("different!");
 546   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator1);
 547   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 548                             fragment_shader_, NULL, NULL,
 549                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 550                                        base::Unretained(this)));
 551
 552   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
 553       *vertex_shader_->signature_source(),
 554       NULL,
 555       *fragment_shader_->signature_source(),
 556       NULL,
 557       NULL));
 558 }
 559
 560 TEST_F(MemoryProgramCacheTest, LoadCorrectProgram) {
 561   const GLenum kFormat = 1;
 562   const int kProgramId = 10;
 563   const int kBinaryLength = 20;
 564   char test_binary[kBinaryLength];
 565   for (int i = 0; i < kBinaryLength; ++i) {
 566     test_binary[i] = i;
 567   }
 568   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 569
 570   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
 571   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 572                             fragment_shader_, NULL, NULL,
 573                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 574                                        base::Unretained(this)));
 575
 576   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
 577       *vertex_shader_->signature_source(),
 578       NULL,
 579       *fragment_shader_->signature_source(),
 580       NULL,
 581       NULL));
 582
 583   SetExpectationsForLoadLinkedProgram(kProgramId, &emulator);
 584
 585   fragment_shader_->UpdateSource("different!");
 586   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram(
 587       kProgramId,
 588       vertex_shader_,
 589       NULL,
 590       fragment_shader_,
 591       NULL,
 592       NULL,
 593       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 594                  base::Unretained(this))));
 595 }
 596
 597 TEST_F(MemoryProgramCacheTest, OverwriteOnNewSave) {
 598   const GLenum kFormat = 1;
 599   const int kProgramId = 10;
 600   const int kBinaryLength = 20;
 601   char test_binary[kBinaryLength];
 602   for (int i = 0; i < kBinaryLength; ++i) {
 603     test_binary[i] = i;
 604   }
 605   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 606
 607   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
 608   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 609                             fragment_shader_, NULL, NULL,
 610                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 611                                        base::Unretained(this)));
 612
 613
 614   char test_binary2[kBinaryLength];
 615   for (int i = 0; i < kBinaryLength; ++i) {
 616     test_binary2[i] = (i*2) % 250;
 617   }
 618   ProgramBinaryEmulator emulator2(kBinaryLength, kFormat, test_binary2);
 619   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator2);
 620   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
 621                             fragment_shader_, NULL, NULL,
 622                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 623                                        base::Unretained(this)));
 624
 625   SetExpectationsForLoadLinkedProgram(kProgramId, &emulator2);
 626   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram(
 627       kProgramId,
 628       vertex_shader_,
 629       NULL,
 630       fragment_shader_,
 631       NULL,
 632       NULL,
 633       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
 634                  base::Unretained(this))));
 635 }
 636
 637 }  // namespace gles2
 638 }  // namespace gpu