gpu in-memory program cache implementation with a memory limit + lru eviction.

gpu/command_buffer/service/program_manager_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/program_manager.h"
 
 #include <algorithm>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "gpu/command_buffer/common/gl_mock.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/common_decoder.h"
+#include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/mocks.h"
 #include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::gfx::MockGLInterface;
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::MatcherCast;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::ReturnRef;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgumentPointee;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 
 namespace gpu {
 namespace gles2 {
 
 class ProgramManagerTest : public testing::Test {
  public:
-  ProgramManagerTest() { }
+  ProgramManagerTest() : manager_(NULL) { }
   ~ProgramManagerTest() {
     manager_.Destroy(false);
   }
 
  protected:
   virtual void SetUp() {
     gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
     ::gfx::GLInterface::SetGLInterface(gl_.get());
   }
 
@@ skipping 78 matching lines @@
   EXPECT_FALSE(info1->InUse());
   EXPECT_FALSE(info1->IsValid());
   EXPECT_FALSE(info1->IsDeleted());
   EXPECT_FALSE(info1->CanLink());
   EXPECT_TRUE(info1->log_info() == NULL);
 }
 
 class ProgramManagerWithShaderTest : public testing::Test {
  public:
   ProgramManagerWithShaderTest()
-      : program_info_(NULL) {
+      :  manager_(NULL), program_info_(NULL) {
   }
 
   ~ProgramManagerWithShaderTest() {
     manager_.Destroy(false);
     shader_manager_.Destroy(false);
   }
 
   static const GLint kNumVertexAttribs = 16;
 
   static const GLuint kClientProgramId = 123;
@@ skipping 63 matching lines @@
     ASSERT_TRUE(fragment_shader != NULL);
     vertex_shader->SetStatus(true, NULL, NULL);
     fragment_shader->SetStatus(true, NULL, NULL);
 
     program_info_ = manager_.CreateProgramInfo(
         kClientProgramId, kServiceProgramId);
     ASSERT_TRUE(program_info_ != NULL);
 
     program_info_->AttachShader(&shader_manager_, vertex_shader);
     program_info_->AttachShader(&shader_manager_, fragment_shader);
-    program_info_->Link();
+    program_info_->Link(NULL, NULL, NULL, NULL);
   }
 
   void SetupShader(AttribInfo* attribs, size_t num_attribs,
                    UniformInfo* uniforms, size_t num_uniforms,
                    GLuint service_id) {
     TestHelper::SetupShader(
         gl_.get(), attribs, num_attribs, uniforms, num_uniforms, service_id);
   }
 
   void SetupDefaultShaderExpectations() {
@@ skipping 12 matching lines @@
   }
 
   // Return true if link status matches expected_link_status
   bool LinkAsExpected(ProgramManager::ProgramInfo* program_info,
                       bool expected_link_status) {
     GLuint service_id = program_info->service_id();
     if (expected_link_status) {
       SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                   service_id);
     }
-    program_info->Link();
+    program_info->Link(NULL, NULL, NULL, NULL);
     GLint link_status;
     program_info->GetProgramiv(GL_LINK_STATUS, &link_status);
     return (static_cast<bool>(link_status) == expected_link_status);
   }
 
   static AttribInfo kAttribs[];
   static UniformInfo kUniforms[];
 
   scoped_ptr<StrictMock<gfx::MockGLInterface> > gl_;
 
@@ skipping 312 matching lines @@
   vshader->SetStatus(true, "", NULL);
   ShaderManager::ShaderInfo* fshader = shader_manager_.CreateShaderInfo(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   ASSERT_TRUE(fshader != NULL);
   fshader->SetStatus(true, "", NULL);
   ProgramManager::ProgramInfo* program_info =
       manager_.CreateProgramInfo(kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, fshader));
-  program_info->Link();
+  program_info->Link(NULL, NULL, NULL, NULL);
   GLint value = 0;
   program_info->GetProgramiv(GL_ACTIVE_ATTRIBUTES, &value);
   EXPECT_EQ(3, value);
   // Check that we skipped the "gl_" uniform.
   program_info->GetProgramiv(GL_ACTIVE_UNIFORMS, &value);
   EXPECT_EQ(2, value);
   // Check that our max length adds room for the array spec and is not as long
   // as the "gl_" uniform we skipped.
   // +4u is to account for "gl_" and NULL terminator.
   program_info->GetProgramiv(GL_ACTIVE_UNIFORM_MAX_LENGTH, &value);
@@ skipping 73 matching lines @@
   const size_t kNumUniforms = arraysize(kUniforms);
   static const GLuint kClientProgramId = 1234;
   static const GLuint kServiceProgramId = 5679;
   SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
               kServiceProgramId);
   ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
       kClientProgramId, kServiceProgramId);
   ASSERT_TRUE(program_info != NULL);
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, vshader));
   EXPECT_TRUE(program_info->AttachShader(&shader_manager_, fshader));
-  program_info->Link();
+  program_info->Link(NULL, NULL, NULL, NULL);
   // Check that we got the good type, not the bad.
   // Check Attribs
   for (unsigned index = 0; index < kNumAttribs; ++index) {
     const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
         program_info->GetAttribInfo(index);
     ASSERT_TRUE(attrib_info != NULL);
     ShaderTranslator::VariableMap::const_iterator it = attrib_map.find(
         attrib_info->name);
     ASSERT_TRUE(it != attrib_map.end());
     EXPECT_EQ(it->first, attrib_info->name);
@@ skipping 298 matching lines @@
         kUniform3FakeLocation,
         kUniform3RealLocation,
         kUniform3DesiredLocation,
         kUniform3GoodName,
       },
     };
     const size_t kNumAttribs = arraysize(kAttribs);
     const size_t kNumUniforms = arraysize(kUniforms);
     SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
                 kServiceProgramId);
-    program_info->Link();
+    program_info->Link(NULL, NULL, NULL, NULL);
     SetupExpectationsForClearingUniforms(kUniforms, kNumUniforms);
     manager_.ClearUniforms(program_info);
   }
 }
 
 TEST_F(ProgramManagerWithShaderTest, BindUniformLocation) {
   const GLuint kVShaderClientId = 2001;
   const GLuint kFShaderClientId = 2002;
   const GLuint kVShaderServiceId = 3001;
   const GLuint kFShaderServiceId = 3002;
@@ skipping 51 matching lines @@
       kUniform3RealLocation,
       kUniform3DesiredLocation,
       kUniform3GoodName,
     },
   };
 
   const size_t kNumAttribs = arraysize(kAttribs);
   const size_t kNumUniforms = arraysize(kUniforms);
   SetupShader(kAttribs, kNumAttribs, kUniforms, kNumUniforms,
               kServiceProgramId);
-  program_info->Link();
+  program_info->Link(NULL, NULL, NULL, NULL);
 
   EXPECT_EQ(kUniform1DesiredLocation,
             program_info->GetUniformFakeLocation(kUniform1Name));
   EXPECT_EQ(kUniform3DesiredLocation,
             program_info->GetUniformFakeLocation(kUniform3BadName));
   EXPECT_EQ(kUniform3DesiredLocation,
             program_info->GetUniformFakeLocation(kUniform3GoodName));
 }
 
+class ProgramManagerWithCacheTest : public testing::Test {
+ public:
+  static const GLuint kClientProgramId = 1;
+  static const GLuint kServiceProgramId = 10;
+  static const GLuint kVertexShaderClientId = 2;
+  static const GLuint kFragmentShaderClientId = 20;
+  static const GLuint kVertexShaderServiceId = 3;
+  static const GLuint kFragmentShaderServiceId = 30;
+
+  ProgramManagerWithCacheTest()
+      : cache_(new MockProgramCache()),
+        manager_(cache_.get()),
+        vertex_shader_(NULL),
+        fragment_shader_(NULL),
+        program_info_(NULL) {
+  }
+  ~ProgramManagerWithCacheTest() {
+    manager_.Destroy(false);
+    shader_manager_.Destroy(false);
+  }
+
+ protected:
+  virtual void SetUp() {
+    gl_.reset(new StrictMock<gfx::MockGLInterface>());
+    ::gfx::GLInterface::SetGLInterface(gl_.get());
+
+    vertex_shader_ = shader_manager_.CreateShaderInfo(
+       kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
+    fragment_shader_ = shader_manager_.CreateShaderInfo(
+       kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
+    ASSERT_TRUE(vertex_shader_ != NULL);
+    ASSERT_TRUE(fragment_shader_ != NULL);
+    vertex_shader_->UpdateSource("lka asjf bjajsdfj");
+    fragment_shader_->UpdateSource("lka asjf a   fasgag 3rdsf3 bjajsdfj");
+
+    program_info_ = manager_.CreateProgramInfo(
+        kClientProgramId, kServiceProgramId);
+    ASSERT_TRUE(program_info_ != NULL);
+
+    program_info_->AttachShader(&shader_manager_, vertex_shader_);
+    program_info_->AttachShader(&shader_manager_, fragment_shader_);
+  }
+
+  virtual void TearDown() {
+    ::gfx::GLInterface::SetGLInterface(NULL);
+  }
+
+  void SetShadersCompiled() {
+    cache_->ShaderCompilationSucceeded(*vertex_shader_->source());
+    cache_->ShaderCompilationSucceeded(*fragment_shader_->source());
+    vertex_shader_->SetStatus(true, NULL, NULL);
+    fragment_shader_->SetStatus(true, NULL, NULL);
+    vertex_shader_->FlagSourceAsCompiled(true);
+    fragment_shader_->FlagSourceAsCompiled(true);
+  }
+
+  void SetShadersNotCompiledButCached() {
+    SetShadersCompiled();
+    vertex_shader_->FlagSourceAsCompiled(false);
+    fragment_shader_->FlagSourceAsCompiled(false);
+  }
+
+  void SetProgramCached() {
+    cache_->LinkedProgramCacheSuccess(
+        vertex_shader_->source()->c_str(),
+        fragment_shader_->source()->c_str(),
+        &program_info_->bind_attrib_location_map());
+  }
+
+  void SetExpectationsForProgramCached() {
+    SetExpectationsForProgramCached(program_info_,
+                                    vertex_shader_,
+                                    fragment_shader_);
+  }
+
+  void SetExpectationsForProgramCached(
+      ProgramManager::ProgramInfo* program_info,
+      ShaderManager::ShaderInfo* vertex_shader,
+      ShaderManager::ShaderInfo* fragment_shader) {
+    EXPECT_CALL(*cache_.get(), SaveLinkedProgram(
+        program_info->service_id(),
+        vertex_shader,
+        fragment_shader,
+        &program_info->bind_attrib_location_map())).Times(1);
+  }
+
+  void SetExpectationsForNotCachingProgram() {
+    SetExpectationsForNotCachingProgram(program_info_,
+                                        vertex_shader_,
+                                        fragment_shader_);
+  }
+
+  void SetExpectationsForNotCachingProgram(
+      ProgramManager::ProgramInfo* program_info,
+      ShaderManager::ShaderInfo* vertex_shader,
+      ShaderManager::ShaderInfo* fragment_shader) {
+    EXPECT_CALL(*cache_.get(), SaveLinkedProgram(
+        program_info->service_id(),
+        vertex_shader,
+        fragment_shader,
+        &program_info->bind_attrib_location_map())).Times(0);
+  }
+
+  void SetExpectationsForProgramLoad(ProgramCache::ProgramLoadResult result) {
+    SetExpectationsForProgramLoad(kServiceProgramId,
+                                  program_info_,
+                                  vertex_shader_,
+                                  fragment_shader_,
+                                  result);
+  }
+
+  void SetExpectationsForProgramLoad(
+      GLuint service_program_id,
+      ProgramManager::ProgramInfo* program_info,
+      ShaderManager::ShaderInfo* vertex_shader,
+      ShaderManager::ShaderInfo* fragment_shader,
+      ProgramCache::ProgramLoadResult result) {
+    EXPECT_CALL(*cache_.get(),
+                LoadLinkedProgram(service_program_id,
+                                  vertex_shader,
+                                  fragment_shader,
+                                  &program_info->bind_attrib_location_map()))
+        .WillOnce(Return(result));
+  }
+
+  void SetExpectationsForProgramLoadSuccess() {
+    SetExpectationsForProgramLoadSuccess(kServiceProgramId);
+  }
+
+  void SetExpectationsForProgramLoadSuccess(GLuint service_program_id) {
+    TestHelper::SetupProgramSuccessExpectations(gl_.get(),
+                                                NULL,
+                                                0,
+                                                NULL,
+                                                0,
+                                                service_program_id);
+  }
+
+  void SetExpectationsForProgramLink() {
+    SetExpectationsForProgramLink(kServiceProgramId);
+  }
+
+  void SetExpectationsForProgramLink(GLuint service_program_id) {
+    TestHelper::SetupShader(gl_.get(), NULL, 0, NULL, 0, service_program_id);
+    if (gfx::g_GL_ARB_get_program_binary) {
+      EXPECT_CALL(*gl_.get(),
+                  ProgramParameteri(service_program_id,
+                                    PROGRAM_BINARY_RETRIEVABLE_HINT,
+                                    GL_TRUE)).Times(1);
+    }
+  }
+
+  void SetExpectationsForSuccessCompile(
+      const ShaderManager::ShaderInfo* shader) {
+    const GLuint shader_id = shader->service_id();
+    const char* src = shader->source()->c_str();
+    EXPECT_CALL(*gl_.get(),
+                ShaderSource(shader_id, 1, Pointee(src), NULL)).Times(1);
+    EXPECT_CALL(*gl_.get(), CompileShader(shader_id)).Times(1);
+    EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_COMPILE_STATUS, _))
+      .WillOnce(SetArgumentPointee<2>(GL_TRUE));
+  }
+
+  void SetExpectationsForNoCompile(const ShaderManager::ShaderInfo* shader) {
+    const GLuint shader_id = shader->service_id();
+    const char* src = shader->source()->c_str();
+    EXPECT_CALL(*gl_.get(),
+                ShaderSource(shader_id, 1, Pointee(src), NULL)).Times(0);
+    EXPECT_CALL(*gl_.get(), CompileShader(shader_id)).Times(0);
+    EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_COMPILE_STATUS, _))
+        .Times(0);
+  }
+
+  void SetExpectationsForErrorCompile(const ShaderManager::ShaderInfo* shader) {
+    const GLuint shader_id = shader->service_id();
+    const char* src = shader->source()->c_str();
+    EXPECT_CALL(*gl_.get(),
+                ShaderSource(shader_id, 1, Pointee(src), NULL)).Times(1);
+    EXPECT_CALL(*gl_.get(), CompileShader(shader_id)).Times(1);
+    EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_COMPILE_STATUS, _))
+      .WillOnce(SetArgumentPointee<2>(GL_FALSE));
+    EXPECT_CALL(*gl_.get(), GetShaderiv(shader_id, GL_INFO_LOG_LENGTH, _))
+      .WillOnce(SetArgumentPointee<2>(0));
+    EXPECT_CALL(*gl_.get(), GetShaderInfoLog(shader_id, 0, _, _))
+      .Times(1);
+  }
+
+  scoped_ptr<StrictMock<gfx::MockGLInterface> > gl_;
+
+  scoped_ptr<MockProgramCache> cache_;
+  ProgramManager manager_;
+
+  ShaderManager::ShaderInfo* vertex_shader_;
+  ShaderManager::ShaderInfo* fragment_shader_;
+  ProgramManager::ProgramInfo* program_info_;
+  ShaderManager shader_manager_;
+};
+
+// GCC requires these declarations, but MSVC requires they not be present
+#ifndef COMPILER_MSVC
+const GLuint ProgramManagerWithCacheTest::kClientProgramId;
+const GLuint ProgramManagerWithCacheTest::kServiceProgramId;
+const GLuint ProgramManagerWithCacheTest::kVertexShaderClientId;
+const GLuint ProgramManagerWithCacheTest::kFragmentShaderClientId;
+const GLuint ProgramManagerWithCacheTest::kVertexShaderServiceId;
+const GLuint ProgramManagerWithCacheTest::kFragmentShaderServiceId;
+#endif
+
+TEST_F(ProgramManagerWithCacheTest, CacheSuccessAfterShaderCompile) {
+  SetExpectationsForSuccessCompile(vertex_shader_);
+  FeatureInfo::Ref info(new FeatureInfo());
+  manager_.DoCompileShader(vertex_shader_, NULL, info.get());
+  EXPECT_EQ(ProgramCache::COMPILATION_SUCCEEDED,
+            cache_->GetShaderCompilationStatus(*vertex_shader_->source()));
+}
+
+TEST_F(ProgramManagerWithCacheTest, CacheUnknownAfterShaderError) {
+  SetExpectationsForErrorCompile(vertex_shader_);
+  FeatureInfo::Ref info(new FeatureInfo());
+  manager_.DoCompileShader(vertex_shader_, NULL, info.get());
+  EXPECT_EQ(ProgramCache::COMPILATION_UNKNOWN,
+            cache_->GetShaderCompilationStatus(*vertex_shader_->source()));
+}
+
+TEST_F(ProgramManagerWithCacheTest, NoCompileWhenShaderCached) {
+  cache_->ShaderCompilationSucceeded(vertex_shader_->source()->c_str());
+  SetExpectationsForNoCompile(vertex_shader_);
+  FeatureInfo::Ref info(new FeatureInfo());
+  manager_.DoCompileShader(vertex_shader_, NULL, info.get());
+}
+
+TEST_F(ProgramManagerWithCacheTest, CacheProgramOnSuccessfulLink) {
+  SetShadersCompiled();
+  SetExpectationsForProgramLink();
+  SetExpectationsForProgramCached();
+  EXPECT_TRUE(program_info_->Link(NULL, NULL, NULL, NULL));
+}
+
+TEST_F(ProgramManagerWithCacheTest, CompileShaderOnLinkCacheMiss) {
+  SetShadersCompiled();
+  vertex_shader_->FlagSourceAsCompiled(false);
+
+  FeatureInfo::Ref info(new FeatureInfo());
+
+  SetExpectationsForSuccessCompile(vertex_shader_);
+  SetExpectationsForProgramLink();
+  SetExpectationsForProgramCached();
+  EXPECT_TRUE(program_info_->Link(&shader_manager_, NULL, NULL, info.get()));
+}
+
+TEST_F(ProgramManagerWithCacheTest, LoadProgramOnProgramCacheHit) {
+  SetShadersNotCompiledButCached();
+  SetProgramCached();
+
+  SetExpectationsForNoCompile(vertex_shader_);
+  SetExpectationsForNoCompile(fragment_shader_);
+  SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS);
+  SetExpectationsForNotCachingProgram();
+  SetExpectationsForProgramLoadSuccess();
+
+  EXPECT_TRUE(program_info_->Link(NULL, NULL, NULL, NULL));
+}
+
+TEST_F(ProgramManagerWithCacheTest, CompileAndLinkOnProgramCacheError) {
+  SetShadersNotCompiledButCached();
+  SetProgramCached();
+
+  SetExpectationsForSuccessCompile(vertex_shader_);
+  SetExpectationsForSuccessCompile(fragment_shader_);
+  SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_FAILURE);
+  SetExpectationsForProgramLink();
+  SetExpectationsForProgramCached();
+
+  FeatureInfo::Ref info(new FeatureInfo());
+  EXPECT_TRUE(program_info_->Link(&shader_manager_, NULL, NULL, info.get()));
+}
+
+TEST_F(ProgramManagerWithCacheTest, CorrectCompileOnSourceChangeNoCompile) {
+  SetShadersNotCompiledButCached();
+  SetProgramCached();
+
+  const GLuint kNewShaderClientId = 4;
+  const GLuint kNewShaderServiceId = 40;
+  const GLuint kNewProgramClientId = 5;
+  const GLuint kNewProgramServiceId = 50;
+
+  ShaderManager::ShaderInfo* new_vertex_shader =
+      shader_manager_.CreateShaderInfo(kNewShaderClientId,
+                                       kNewShaderServiceId,
+                                       GL_VERTEX_SHADER);
+
+  const std::string original_source = *vertex_shader_->source();
+  new_vertex_shader->UpdateSource(original_source.c_str());
+
+  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
+      kNewProgramClientId, kNewProgramServiceId);
+  ASSERT_TRUE(program_info != NULL);
+  program_info->AttachShader(&shader_manager_, new_vertex_shader);
+  program_info->AttachShader(&shader_manager_, fragment_shader_);
+
+  SetExpectationsForNoCompile(new_vertex_shader);
+
+  manager_.DoCompileShader(new_vertex_shader, NULL, NULL);
+
+  new_vertex_shader->UpdateSource("different!");
+  EXPECT_EQ(original_source,
+            *new_vertex_shader->deferred_compilation_source());
+
+  EXPECT_FALSE(new_vertex_shader->source_compiled());
+  EXPECT_FALSE(fragment_shader_->source_compiled());
+
+  SetExpectationsForNoCompile(fragment_shader_);
+  SetExpectationsForNotCachingProgram(program_info,
+                                      new_vertex_shader,
+                                      fragment_shader_);
+  SetExpectationsForProgramLoad(kNewProgramServiceId,
+                                program_info,
+                                new_vertex_shader,
+                                fragment_shader_,
+                                ProgramCache::PROGRAM_LOAD_SUCCESS);
+  SetExpectationsForProgramLoadSuccess(kNewProgramServiceId);
+
+  FeatureInfo::Ref info(new FeatureInfo());
+  EXPECT_TRUE(program_info->Link(&shader_manager_, NULL, NULL, info.get()));
+}
+
+TEST_F(ProgramManagerWithCacheTest, CorrectCompileOnSourceChangeWithCompile) {
+  SetShadersNotCompiledButCached();
+  SetProgramCached();
+
+  const GLuint kNewShaderClientId = 4;
+  const GLuint kNewShaderServiceId = 40;
+  const GLuint kNewProgramClientId = 5;
+  const GLuint kNewProgramServiceId = 50;
+
+  ShaderManager::ShaderInfo* new_vertex_shader =
+      shader_manager_.CreateShaderInfo(kNewShaderClientId,
+                                       kNewShaderServiceId,
+                                       GL_VERTEX_SHADER);
+
+  new_vertex_shader->UpdateSource(vertex_shader_->source()->c_str());
+
+  ProgramManager::ProgramInfo* program_info = manager_.CreateProgramInfo(
+      kNewProgramClientId, kNewProgramServiceId);
+  ASSERT_TRUE(program_info != NULL);
+  program_info->AttachShader(&shader_manager_, new_vertex_shader);
+  program_info->AttachShader(&shader_manager_, fragment_shader_);
+
+  SetExpectationsForNoCompile(new_vertex_shader);
+
+  manager_.DoCompileShader(new_vertex_shader, NULL, NULL);
+
+  const std::string differentSource = "different!";
+  new_vertex_shader->UpdateSource(differentSource.c_str());
+  SetExpectationsForSuccessCompile(new_vertex_shader);
+
+  FeatureInfo::Ref info(new FeatureInfo());
+  manager_.DoCompileShader(new_vertex_shader, NULL, info.get());
+  EXPECT_EQ(differentSource,
+            *new_vertex_shader->deferred_compilation_source());
+
+  EXPECT_TRUE(new_vertex_shader->source_compiled());
+  EXPECT_FALSE(fragment_shader_->source_compiled());
+
+  // so we don't recompile because we were pending originally
+  SetExpectationsForNoCompile(new_vertex_shader);
+  SetExpectationsForSuccessCompile(fragment_shader_);
+  SetExpectationsForProgramCached(program_info,
+                                  new_vertex_shader,
+                                  fragment_shader_);
+  SetExpectationsForProgramLink(kNewProgramServiceId);
+
+  EXPECT_TRUE(program_info->Link(&shader_manager_, NULL, NULL, info.get()));
+}
+
 }  // namespace gles2
 }  // namespace gpu
-
-