Home | History | Annotate | Download | only in service 
      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 "gpu/command_buffer/service/test_helper.h"
     14 #include "testing/gtest/include/gtest/gtest.h"
     15 #include "ui/gl/gl_bindings.h"
     16 #include "ui/gl/gl_mock.h"
     17 
     18 using ::testing::_;
     19 using ::testing::ElementsAreArray;
     20 using ::testing::Invoke;
     21 using ::testing::SetArgPointee;
     22 using ::testing::SetArrayArgument;
     23 
     24 namespace {
     25 typedef gpu::gles2::ShaderTranslator::VariableMap VariableMap;
     26 }  // anonymous namespace
     27 
     28 namespace gpu {
     29 namespace gles2 {
     30 
     31 class ProgramBinaryEmulator {
     32  public:
     33   ProgramBinaryEmulator(GLsizei length,
     34                         GLenum format,
     35                         const char* binary)
     36       : length_(length),
     37         format_(format),
     38         binary_(binary) { }
     39 
     40   void GetProgramBinary(GLuint program,
     41                         GLsizei buffer_size,
     42                         GLsizei* length,
     43                         GLenum* format,
     44                         GLvoid* binary) {
     45     if (length) {
     46       *length = length_;
     47     }
     48     *format = format_;
     49     memcpy(binary, binary_, length_);
     50   }
     51 
     52   void ProgramBinary(GLuint program,
     53                      GLenum format,
     54                      const GLvoid* binary,
     55                      GLsizei length) {
     56     // format and length are verified by matcher
     57     EXPECT_EQ(0, memcmp(binary_, binary, length));
     58   }
     59 
     60   GLsizei length() const { return length_; }
     61   GLenum format() const { return format_; }
     62   const char* binary() const { return binary_; }
     63 
     64  private:
     65   GLsizei length_;
     66   GLenum format_;
     67   const char* binary_;
     68 };
     69 
     70 class MemoryProgramCacheTest : public GpuServiceTest {
     71  public:
     72   static const size_t kCacheSizeBytes = 1024;
     73   static const GLuint kVertexShaderClientId = 90;
     74   static const GLuint kVertexShaderServiceId = 100;
     75   static const GLuint kFragmentShaderClientId = 91;
     76   static const GLuint kFragmentShaderServiceId = 100;
     77 
     78   MemoryProgramCacheTest()
     79       : cache_(new MemoryProgramCache(kCacheSizeBytes)),
     80         vertex_shader_(NULL),
     81         fragment_shader_(NULL),
     82         shader_cache_count_(0) { }
     83   virtual ~MemoryProgramCacheTest() {
     84     shader_manager_.Destroy(false);
     85   }
     86 
     87   void ShaderCacheCb(const std::string& key, const std::string& shader) {
     88     shader_cache_count_++;
     89     shader_cache_shader_ = shader;
     90   }
     91 
     92   int32 shader_cache_count() { return shader_cache_count_; }
     93   const std::string& shader_cache_shader() { return shader_cache_shader_; }
     94 
     95  protected:
     96   virtual void SetUp() {
     97     GpuServiceTest::SetUp();
     98 
     99     vertex_shader_ = shader_manager_.CreateShader(kVertexShaderClientId,
    100                                                   kVertexShaderServiceId,
    101                                                   GL_VERTEX_SHADER);
    102     fragment_shader_ = shader_manager_.CreateShader(
    103         kFragmentShaderClientId,
    104         kFragmentShaderServiceId,
    105         GL_FRAGMENT_SHADER);
    106     ASSERT_TRUE(vertex_shader_ != NULL);
    107     ASSERT_TRUE(fragment_shader_ != NULL);
    108     typedef ShaderTranslatorInterface::VariableInfo VariableInfo;
    109     typedef ShaderTranslator::VariableMap VariableMap;
    110     VariableMap vertex_attrib_map;
    111     VariableMap vertex_uniform_map;
    112     VariableMap vertex_varying_map;
    113     VariableMap fragment_attrib_map;
    114     VariableMap fragment_uniform_map;
    115     VariableMap fragment_varying_map;
    116 
    117     vertex_attrib_map["a"] = VariableInfo(1, 34, SH_PRECISION_LOWP, 0, "a");
    118     vertex_uniform_map["a"] = VariableInfo(0, 10, SH_PRECISION_MEDIUMP, 1, "a");
    119     vertex_uniform_map["b"] = VariableInfo(2, 3114, SH_PRECISION_HIGHP, 1, "b");
    120     vertex_varying_map["c"] = VariableInfo(3, 2, SH_PRECISION_HIGHP, 1, "c");
    121     fragment_attrib_map["jjjbb"] =
    122         VariableInfo(463, 1114, SH_PRECISION_MEDIUMP, 0, "jjjbb");
    123     fragment_uniform_map["k"] =
    124         VariableInfo(10, 34413, SH_PRECISION_MEDIUMP, 1, "k");
    125     fragment_varying_map["c"] = VariableInfo(3, 2, SH_PRECISION_HIGHP, 1, "c");
    126 
    127     vertex_shader_->set_source("bbbalsldkdkdkd");
    128     fragment_shader_->set_source("bbbal   sldkdkdkas 134 ad");
    129 
    130     TestHelper::SetShaderStates(
    131         gl_.get(), vertex_shader_, true, NULL, NULL,
    132         &vertex_attrib_map, &vertex_uniform_map, &vertex_varying_map,
    133         NULL);
    134     TestHelper::SetShaderStates(
    135         gl_.get(), fragment_shader_, true, NULL, NULL,
    136         &fragment_attrib_map, &fragment_uniform_map, &fragment_varying_map,
    137         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 = vertex_shader_->signature_source();
    405   vertex_shader_->set_source("different!");
    406   TestHelper::SetShaderStates(gl_.get(), vertex_shader_, true);
    407   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
    408       kProgramId,
    409       vertex_shader_,
    410       NULL,
    411       fragment_shader_,
    412       NULL,
    413       NULL,
    414       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    415                  base::Unretained(this))));
    416 
    417   vertex_shader_->set_source(vertex_orig_source);
    418   TestHelper::SetShaderStates(gl_.get(), vertex_shader_, true);
    419   fragment_shader_->set_source("different!");
    420   TestHelper::SetShaderStates(gl_.get(), fragment_shader_, true);
    421   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
    422       kProgramId,
    423       vertex_shader_,
    424       NULL,
    425       fragment_shader_,
    426       NULL,
    427       NULL,
    428       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    429                  base::Unretained(this))));
    430 }
    431 
    432 TEST_F(MemoryProgramCacheTest, LoadFailOnDifferentMap) {
    433   const GLenum kFormat = 1;
    434   const int kProgramId = 10;
    435   const int kBinaryLength = 20;
    436   char test_binary[kBinaryLength];
    437   for (int i = 0; i < kBinaryLength; ++i) {
    438     test_binary[i] = i;
    439   }
    440   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
    441 
    442   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
    443   ProgramCache::LocationMap binding_map;
    444   binding_map["test"] = 512;
    445   cache_->SaveLinkedProgram(kProgramId,
    446                             vertex_shader_,
    447                             NULL,
    448                             fragment_shader_,
    449                             NULL,
    450                             &binding_map,
    451                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    452                                        base::Unretained(this)));
    453 
    454   binding_map["different!"] = 59;
    455   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
    456       kProgramId,
    457       vertex_shader_,
    458       NULL,
    459       fragment_shader_,
    460       NULL,
    461       &binding_map,
    462       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    463                  base::Unretained(this))));
    464   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
    465       kProgramId,
    466       vertex_shader_,
    467       NULL,
    468       fragment_shader_,
    469       NULL,
    470       NULL,
    471       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    472                  base::Unretained(this))));
    473 }
    474 
    475 TEST_F(MemoryProgramCacheTest, MemoryProgramCacheEviction) {
    476   const GLenum kFormat = 1;
    477   const int kProgramId = 10;
    478   const int kBinaryLength = 20;
    479   char test_binary[kBinaryLength];
    480   for (int i = 0; i < kBinaryLength; ++i) {
    481     test_binary[i] = i;
    482   }
    483   ProgramBinaryEmulator emulator1(kBinaryLength, kFormat, test_binary);
    484 
    485 
    486   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator1);
    487   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
    488                             fragment_shader_, NULL, NULL,
    489                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    490                                        base::Unretained(this)));
    491 
    492   const int kEvictingProgramId = 11;
    493   const GLuint kEvictingBinaryLength = kCacheSizeBytes - kBinaryLength + 1;
    494 
    495   // save old source and modify for new program
    496   const std::string& old_source = fragment_shader_->signature_source();
    497   fragment_shader_->set_source("al sdfkjdk");
    498   TestHelper::SetShaderStates(gl_.get(), fragment_shader_, true);
    499 
    500   scoped_ptr<char[]> bigTestBinary =
    501       scoped_ptr<char[]>(new char[kEvictingBinaryLength]);
    502   for (size_t i = 0; i < kEvictingBinaryLength; ++i) {
    503     bigTestBinary[i] = i % 250;
    504   }
    505   ProgramBinaryEmulator emulator2(kEvictingBinaryLength,
    506                                   kFormat,
    507                                   bigTestBinary.get());
    508 
    509   SetExpectationsForSaveLinkedProgram(kEvictingProgramId, &emulator2);
    510   cache_->SaveLinkedProgram(kEvictingProgramId,
    511                             vertex_shader_,
    512                             NULL,
    513                             fragment_shader_,
    514                             NULL,
    515                             NULL,
    516                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    517                                        base::Unretained(this)));
    518 
    519   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
    520       vertex_shader_->signature_source(),
    521       NULL,
    522       fragment_shader_->signature_source(),
    523       NULL,
    524       NULL));
    525   EXPECT_EQ(ProgramCache::LINK_UNKNOWN, cache_->GetLinkedProgramStatus(
    526       old_source,
    527       NULL,
    528       fragment_shader_->signature_source(),
    529       NULL,
    530       NULL));
    531 }
    532 
    533 TEST_F(MemoryProgramCacheTest, SaveCorrectProgram) {
    534   const GLenum kFormat = 1;
    535   const int kProgramId = 10;
    536   const int kBinaryLength = 20;
    537   char test_binary[kBinaryLength];
    538   for (int i = 0; i < kBinaryLength; ++i) {
    539     test_binary[i] = i;
    540   }
    541   ProgramBinaryEmulator emulator1(kBinaryLength, kFormat, test_binary);
    542 
    543   vertex_shader_->set_source("different!");
    544   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator1);
    545   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
    546                             fragment_shader_, NULL, NULL,
    547                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    548                                        base::Unretained(this)));
    549 
    550   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
    551       vertex_shader_->signature_source(),
    552       NULL,
    553       fragment_shader_->signature_source(),
    554       NULL,
    555       NULL));
    556 }
    557 
    558 TEST_F(MemoryProgramCacheTest, LoadCorrectProgram) {
    559   const GLenum kFormat = 1;
    560   const int kProgramId = 10;
    561   const int kBinaryLength = 20;
    562   char test_binary[kBinaryLength];
    563   for (int i = 0; i < kBinaryLength; ++i) {
    564     test_binary[i] = i;
    565   }
    566   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
    567 
    568   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
    569   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
    570                             fragment_shader_, NULL, NULL,
    571                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    572                                        base::Unretained(this)));
    573 
    574   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
    575       vertex_shader_->signature_source(),
    576       NULL,
    577       fragment_shader_->signature_source(),
    578       NULL,
    579       NULL));
    580 
    581   SetExpectationsForLoadLinkedProgram(kProgramId, &emulator);
    582 
    583   fragment_shader_->set_source("different!");
    584   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram(
    585       kProgramId,
    586       vertex_shader_,
    587       NULL,
    588       fragment_shader_,
    589       NULL,
    590       NULL,
    591       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    592                  base::Unretained(this))));
    593 }
    594 
    595 TEST_F(MemoryProgramCacheTest, OverwriteOnNewSave) {
    596   const GLenum kFormat = 1;
    597   const int kProgramId = 10;
    598   const int kBinaryLength = 20;
    599   char test_binary[kBinaryLength];
    600   for (int i = 0; i < kBinaryLength; ++i) {
    601     test_binary[i] = i;
    602   }
    603   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
    604 
    605   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
    606   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
    607                             fragment_shader_, NULL, NULL,
    608                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    609                                        base::Unretained(this)));
    610 
    611 
    612   char test_binary2[kBinaryLength];
    613   for (int i = 0; i < kBinaryLength; ++i) {
    614     test_binary2[i] = (i*2) % 250;
    615   }
    616   ProgramBinaryEmulator emulator2(kBinaryLength, kFormat, test_binary2);
    617   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator2);
    618   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
    619                             fragment_shader_, NULL, NULL,
    620                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    621                                        base::Unretained(this)));
    622 
    623   SetExpectationsForLoadLinkedProgram(kProgramId, &emulator2);
    624   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram(
    625       kProgramId,
    626       vertex_shader_,
    627       NULL,
    628       fragment_shader_,
    629       NULL,
    630       NULL,
    631       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
    632                  base::Unretained(this))));
    633 }
    634 
    635 }  // namespace gles2
    636 }  // namespace gpu
    637