Update from https://crrev.com/316786

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"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/service/disk_cache_proto.pb.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/shader_manager.h"
-#include "gpu/command_buffer/service/shader_translator.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace {
 
 size_t GetCacheSizeBytes() {
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kGpuProgramCacheSizeKb)) {
     size_t size;
     if (base::StringToSizeT(
@@ skipping 137 matching lines @@
 MemoryProgramCache::~MemoryProgramCache() {}
 
 void MemoryProgramCache::ClearBackend() {
   store_.Clear();
   DCHECK_EQ(0U, curr_size_bytes_);
 }
 
 ProgramCache::ProgramLoadResult MemoryProgramCache::LoadLinkedProgram(
     GLuint program,
     Shader* shader_a,
-    const ShaderTranslatorInterface* translator_a,
     Shader* shader_b,
-    const ShaderTranslatorInterface* translator_b,
     const LocationMap* bind_attrib_location_map,
     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_source(), translator_a, a_sha);
+      shader_a->last_compiled_signature(), a_sha);
   ComputeShaderHash(
-      shader_b->last_compiled_source(), translator_b, b_sha);
+      shader_b->last_compiled_signature(), b_sha);
 
   char sha[kHashLength];
   ComputeProgramHash(a_sha,
                      b_sha,
                      bind_attrib_location_map,
                      sha);
   const std::string sha_string(sha, kHashLength);
 
   ProgramMRUCache::iterator found = store_.Get(sha_string);
   if (found == store_.end()) {
@@ skipping 29 matching lines @@
     FillShaderProto(proto->mutable_fragment_shader(), b_sha, shader_b);
     RunShaderCallback(shader_callback, proto.get(), sha_string);
   }
 
   return PROGRAM_LOAD_SUCCESS;
 }
 
 void MemoryProgramCache::SaveLinkedProgram(
     GLuint program,
     const Shader* shader_a,
-    const ShaderTranslatorInterface* translator_a,
     const Shader* shader_b,
-    const ShaderTranslatorInterface* translator_b,
     const LocationMap* bind_attrib_location_map,
     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_source(), translator_a, a_sha);
+      shader_a->last_compiled_signature(), a_sha);
   ComputeShaderHash(
-      shader_b->last_compiled_source(), translator_b, b_sha);
+      shader_b->last_compiled_signature(), b_sha);
 
   char sha[kHashLength];
   ComputeProgramHash(a_sha,
                      b_sha,
                      bind_attrib_location_map,
                      sha);
   const std::string sha_string(sha, sizeof(sha));
 
   UMA_HISTOGRAM_COUNTS("GPU.ProgramCache.MemorySizeBeforeKb",
                        curr_size_bytes_ / 1024);
@@ skipping 133 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