Update from https://crrev.com/320931

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/strings/string_number_conversions.h"
@@ skipping 1941 matching lines @@
 
   void SetShadersCompiled() {
     TestHelper::SetShaderStates(gl_.get(), vertex_shader_, true);
     TestHelper::SetShaderStates(gl_.get(), fragment_shader_, true);
   }
 
   void SetProgramCached() {
     cache_->LinkedProgramCacheSuccess(
         vertex_shader_->source(),
         fragment_shader_->source(),
-        &program_->bind_attrib_location_map());
+        &program_->bind_attrib_location_map(),
+        program_->transform_feedback_varyings(),
+        program_->transform_feedback_buffer_mode());
   }
 
   void SetExpectationsForProgramCached() {
     SetExpectationsForProgramCached(program_,
                                     vertex_shader_,
                                     fragment_shader_);
   }
 
   void SetExpectationsForProgramCached(
       Program* program,
       Shader* vertex_shader,
       Shader* fragment_shader) {
     EXPECT_CALL(*cache_.get(), SaveLinkedProgram(
         program->service_id(),
         vertex_shader,
         fragment_shader,
         &program->bind_attrib_location_map(),
+        program_->transform_feedback_varyings(),
+        program_->transform_feedback_buffer_mode(),
         _)).Times(1);
   }
 
   void SetExpectationsForNotCachingProgram() {
     SetExpectationsForNotCachingProgram(program_,
                                         vertex_shader_,
                                         fragment_shader_);
   }
 
   void SetExpectationsForNotCachingProgram(
       Program* program,
       Shader* vertex_shader,
       Shader* fragment_shader) {
     EXPECT_CALL(*cache_.get(), SaveLinkedProgram(
         program->service_id(),
         vertex_shader,
         fragment_shader,
         &program->bind_attrib_location_map(),
+        program_->transform_feedback_varyings(),
+        program_->transform_feedback_buffer_mode(),
         _)).Times(0);
   }
 
   void SetExpectationsForProgramLoad(ProgramCache::ProgramLoadResult result) {
     SetExpectationsForProgramLoad(kServiceProgramId,
                                   program_,
                                   vertex_shader_,
                                   fragment_shader_,
                                   result);
   }
 
   void SetExpectationsForProgramLoad(
       GLuint service_program_id,
       Program* program,
       Shader* vertex_shader,
       Shader* fragment_shader,
       ProgramCache::ProgramLoadResult result) {
     EXPECT_CALL(*cache_.get(),
                 LoadLinkedProgram(service_program_id,
                                   vertex_shader,
                                   fragment_shader,
                                   &program->bind_attrib_location_map(),
+                                  program_->transform_feedback_varyings(),
+                                  program_->transform_feedback_buffer_mode(),
                                   _))
         .WillOnce(Return(result));
   }
 
   void SetExpectationsForProgramLoadSuccess() {
     SetExpectationsForProgramLoadSuccess(kServiceProgramId);
   }
 
   void SetExpectationsForProgramLoadSuccess(GLuint service_program_id) {
     TestHelper::SetupProgramSuccessExpectations(gl_.get(),
@@ skipping 89 matching lines @@
   SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS);
   SetExpectationsForNotCachingProgram();
   SetExpectationsForProgramLoadSuccess();
 
   EXPECT_TRUE(program_->Link(NULL, Program::kCountOnlyStaticallyUsed,
                              base::Bind(&ShaderCacheCb)));
 }
 
 }  // namespace gles2
 }  // namespace gpu