Added null check for shader source when compiling, and fixed re-caching behavior to spec

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/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/sha1.h"
 #include "base/string_number_conversions.h"
@@ skipping 70 matching lines @@
   shader_b->set_attrib_map(value->attrib_map_1);
   shader_b->set_uniform_map(value->uniform_map_1);
   return PROGRAM_LOAD_SUCCESS;
 }
 
 void MemoryProgramCache::SaveLinkedProgram(
     GLuint program,
     const ShaderManager::ShaderInfo* shader_a,
     const ShaderManager::ShaderInfo* shader_b,
     const LocationMap* bind_attrib_location_map) {
-  GLsizei length;
   GLenum format;
-  GLsizei buffer_length = 0;
-  glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH_OES, &buffer_length);
-  if (static_cast<unsigned int>(buffer_length) > max_size_bytes_) {
+  GLsizei length = 0;
+  glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH_OES, &length);
+  if (length == 0 || static_cast<unsigned int>(length) > max_size_bytes_) {
     return;
   }
-  scoped_array<char> binary(new char[buffer_length]);
+  scoped_array<char> binary(new char[length]);
   glGetProgramBinary(program,
-                     buffer_length,
-                     &length,
+                     length,
+                     NULL,
                      &format,
                      binary.get());
-  if (length == 0) {
-    return;
-  }
 
   char a_sha[kHashLength];
   char b_sha[kHashLength];
   ComputeShaderHash(*shader_a->deferred_compilation_source(), a_sha);
   ComputeShaderHash(*shader_b->deferred_compilation_source(), b_sha);
 
   char sha[kHashLength];
   ComputeProgramHash(a_sha,
                      b_sha,
                      bind_attrib_location_map,
                      sha);
   const std::string sha_string(sha, sizeof(sha));
 
   if (store_.find(sha_string) != store_.end()) {
-    return;
+    const StoreMap::iterator found = store_.find(sha_string);
+    const ProgramCacheValue* evicting = found->second;
+    curr_size_bytes_ -= evicting->length;
+    Evict(sha_string, evicting->shader_0_hash, evicting->shader_1_hash);
+    store_.erase(found);
   }
 
   while (curr_size_bytes_ + length > max_size_bytes_) {
     DCHECK(!eviction_helper_.IsEmpty());
     const std::string* program = eviction_helper_.PeekKey();
     const StoreMap::iterator found = store_.find(*program);
     const ProgramCacheValue* evicting = found->second.get();
     curr_size_bytes_ -= evicting->length;
     Evict(*program, evicting->shader_0_hash, evicting->shader_1_hash);
     store_.erase(found);
@@ skipping 32 matching lines @@
       attrib_map_0(_attrib_map_0),
       uniform_map_0(_uniform_map_0),
       shader_1_hash(_shader_1_hash, kHashLength),
       attrib_map_1(_attrib_map_1),
       uniform_map_1(_uniform_map_1) {}
 
 MemoryProgramCache::ProgramCacheValue::~ProgramCacheValue() {}
 
 }  // namespace gles2
 }  // namespace gpu