Update from https://crrev.com/320931

gpu/command_buffer/service/memory_program_cache.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/memory_program_cache.h"
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/sha1.h"
@@ skipping 156 matching lines @@
 void MemoryProgramCache::ClearBackend() {
   store_.Clear();
   DCHECK_EQ(0U, curr_size_bytes_);
 }
 
 ProgramCache::ProgramLoadResult MemoryProgramCache::LoadLinkedProgram(
     GLuint program,
     Shader* shader_a,
     Shader* shader_b,
     const LocationMap* bind_attrib_location_map,
+    const std::vector<std::string>& transform_feedback_varyings,
+    GLenum transform_feedback_buffer_mode,
     const ShaderCacheCallback& shader_callback) {
   char a_sha[kHashLength];
   char b_sha[kHashLength];
   DCHECK(shader_a && !shader_a->last_compiled_source().empty() &&
          shader_b && !shader_b->last_compiled_source().empty());
   ComputeShaderHash(
       shader_a->last_compiled_signature(), a_sha);
   ComputeShaderHash(
       shader_b->last_compiled_signature(), b_sha);
 
   char sha[kHashLength];
   ComputeProgramHash(a_sha,
                      b_sha,
                      bind_attrib_location_map,
+                     transform_feedback_varyings,
+                     transform_feedback_buffer_mode,
                      sha);
   const std::string sha_string(sha, kHashLength);
 
   ProgramMRUCache::iterator found = store_.Get(sha_string);
   if (found == store_.end()) {
     return PROGRAM_LOAD_FAILURE;
   }
   const scoped_refptr<ProgramCacheValue> value = found->second;
   glProgramBinary(program,
                   value->format(),
@@ skipping 26 matching lines @@
   }
 
   return PROGRAM_LOAD_SUCCESS;
 }
 
 void MemoryProgramCache::SaveLinkedProgram(
     GLuint program,
     const Shader* shader_a,
     const Shader* shader_b,
     const LocationMap* bind_attrib_location_map,
+    const std::vector<std::string>& transform_feedback_varyings,
+    GLenum transform_feedback_buffer_mode,
     const ShaderCacheCallback& shader_callback) {
   GLenum format;
   GLsizei length = 0;
   glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH_OES, &length);
   if (length == 0 || static_cast<unsigned int>(length) > max_size_bytes_) {
     return;
   }
   scoped_ptr<char[]> binary(new char[length]);
   glGetProgramBinary(program,
                      length,
                      NULL,
                      &format,
                      binary.get());
   UMA_HISTOGRAM_COUNTS("GPU.ProgramCache.ProgramBinarySizeBytes", length);
 
   char a_sha[kHashLength];
   char b_sha[kHashLength];
   DCHECK(shader_a && !shader_a->last_compiled_source().empty() &&
          shader_b && !shader_b->last_compiled_source().empty());
   ComputeShaderHash(
       shader_a->last_compiled_signature(), a_sha);
   ComputeShaderHash(
       shader_b->last_compiled_signature(), b_sha);
 
   char sha[kHashLength];
   ComputeProgramHash(a_sha,
                      b_sha,
                      bind_attrib_location_map,
+                     transform_feedback_varyings,
+                     transform_feedback_buffer_mode,
                      sha);
   const std::string sha_string(sha, sizeof(sha));
 
   UMA_HISTOGRAM_COUNTS("GPU.ProgramCache.MemorySizeBeforeKb",
                        curr_size_bytes_ / 1024);
 
   // Evict any cached program with the same key in favor of the least recently
   // accessed.
   ProgramMRUCache::iterator existing = store_.Peek(sha_string);
   if(existing != store_.end())
@@ skipping 128 matching lines @@
   program_cache_->LinkedProgramCacheSuccess(program_hash);
 }
 
 MemoryProgramCache::ProgramCacheValue::~ProgramCacheValue() {
   program_cache_->curr_size_bytes_ -= length_;
   program_cache_->Evict(program_hash_);
 }
 
 }  // namespace gles2
 }  // namespace gpu