Update from https://crrev.com/316786

gpu/command_buffer/service/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/program_cache.h"
 
 #include <string>
 #include "base/memory/scoped_ptr.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 
 namespace gpu {
 namespace gles2 {
 
 ProgramCache::ProgramCache() {}
 ProgramCache::~ProgramCache() {}
 
 void ProgramCache::Clear() {
   ClearBackend();
   link_status_.clear();
 }
 
 ProgramCache::LinkedProgramStatus ProgramCache::GetLinkedProgramStatus(
-    const std::string& untranslated_a,
-    const ShaderTranslatorInterface* translator_a,
-    const std::string& untranslated_b,
-    const ShaderTranslatorInterface* translator_b,
+    const std::string& shader_signature_a,
+    const std::string& shader_signature_b,
     const std::map<std::string, GLint>* bind_attrib_location_map) const {
   char a_sha[kHashLength];
   char b_sha[kHashLength];
-  ComputeShaderHash(untranslated_a, translator_a, a_sha);
-  ComputeShaderHash(untranslated_b, translator_b, b_sha);
+  ComputeShaderHash(shader_signature_a, a_sha);
+  ComputeShaderHash(shader_signature_b, b_sha);
 
   char sha[kHashLength];
   ComputeProgramHash(a_sha,
                      b_sha,
                      bind_attrib_location_map,
                      sha);
   const std::string sha_string(sha, kHashLength);
 
   LinkStatusMap::const_iterator found = link_status_.find(sha_string);
   if (found == link_status_.end()) {
     return ProgramCache::LINK_UNKNOWN;
   } else {
     return found->second;
   }
 }
 
 void ProgramCache::LinkedProgramCacheSuccess(
-    const std::string& shader_a,
-    const ShaderTranslatorInterface* translator_a,
-    const std::string& shader_b,
-    const ShaderTranslatorInterface* translator_b,
+    const std::string& shader_signature_a,
+    const std::string& shader_signature_b,
     const LocationMap* bind_attrib_location_map) {
   char a_sha[kHashLength];
   char b_sha[kHashLength];
-  ComputeShaderHash(shader_a, translator_a, a_sha);
-  ComputeShaderHash(shader_b, translator_b, b_sha);
+  ComputeShaderHash(shader_signature_a, a_sha);
+  ComputeShaderHash(shader_signature_b, b_sha);
   char sha[kHashLength];
   ComputeProgramHash(a_sha,
                      b_sha,
                      bind_attrib_location_map,
                      sha);
   const std::string sha_string(sha, kHashLength);
 
   LinkedProgramCacheSuccess(sha_string);
 }
 
 void ProgramCache::LinkedProgramCacheSuccess(const std::string& program_hash) {
   link_status_[program_hash] = LINK_SUCCEEDED;
 }
 
 void ProgramCache::ComputeShaderHash(
     const std::string& str,
-    const ShaderTranslatorInterface* translator,
     char* result) const {
-  std::string s((
-      translator ? translator->GetStringForOptionsThatWouldAffectCompilation() :
-                   std::string()) + str);
-  base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(s.c_str()),
-                      s.length(), reinterpret_cast<unsigned char*>(result));
+  base::SHA1HashBytes(reinterpret_cast<const unsigned char*>(str.c_str()),
+                      str.length(), reinterpret_cast<unsigned char*>(result));
 }
 
 void ProgramCache::Evict(const std::string& program_hash) {
   link_status_.erase(program_hash);
 }
 
 namespace {
 size_t CalculateMapSize(const std::map<std::string, GLint>* map) {
   if (!map) {
     return 0;
@@ skipping 36 matching lines @@
       buffer[current_pos++] = static_cast<unsigned char>(value >> 8);
       buffer[current_pos++] = static_cast<unsigned char>(value);
     }
   }
   base::SHA1HashBytes(buffer.get(),
                       total_size, reinterpret_cast<unsigned char*>(result));
 }
 
 }  // namespace gles2
 }  // namespace gpu