Clear shader disk cache after glProgramBinary failure.

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 <stddef.h>
 
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
+#include "gpu/command_buffer/common/activity_flags.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_preferences.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace gpu {
 namespace gles2 {
@@ skipping 179 matching lines @@
   return gl::g_current_gl_driver &&
          (gl::g_current_gl_driver->ext.b_GL_ARB_get_program_binary ||
           gl::g_current_gl_driver->ext.b_GL_OES_get_program_binary);
 }
 
 }  // namespace
 
 MemoryProgramCache::MemoryProgramCache(
     size_t max_cache_size_bytes,
     bool disable_gpu_shader_disk_cache,
-    bool disable_program_caching_for_transform_feedback)
+    bool disable_program_caching_for_transform_feedback,
+    GpuProcessActivityFlags* activity_flags)
     : max_size_bytes_(max_cache_size_bytes),
       disable_gpu_shader_disk_cache_(disable_gpu_shader_disk_cache),
       disable_program_caching_for_transform_feedback_(
           disable_program_caching_for_transform_feedback),
       curr_size_bytes_(0),
-      store_(ProgramMRUCache::NO_AUTO_EVICT) {
-}
+      store_(ProgramMRUCache::NO_AUTO_EVICT),
+      activity_flags_(activity_flags) {}
 
 MemoryProgramCache::~MemoryProgramCache() {}
 
 void MemoryProgramCache::ClearBackend() {
   store_.Clear();
   DCHECK_EQ(0U, curr_size_bytes_);
 }
 
 ProgramCache::ProgramLoadResult MemoryProgramCache::LoadLinkedProgram(
     GLuint program,
@@ skipping 24 matching lines @@
                      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(),
-                  static_cast<const GLvoid*>(value->data()),
-                  value->length());
+
+  {
+    GpuProcessActivityFlags::ScopedSetFlag scoped_set_flag(
+        activity_flags_, ActivityFlagsBase::FLAG_LOADING_PROGRAM_BINARY);
+    glProgramBinary(program, value->format(),
+                    static_cast<const GLvoid*>(value->data()), value->length());
+  }
+
   GLint success = 0;
   glGetProgramiv(program, GL_LINK_STATUS, &success);
   if (success == GL_FALSE) {
     return PROGRAM_LOAD_FAILURE;
   }
   shader_a->set_attrib_map(value->attrib_map_0());
   shader_a->set_uniform_map(value->uniform_map_0());
   shader_a->set_varying_map(value->varying_map_0());
   shader_a->set_output_variable_list(value->output_variable_list_0());
   shader_a->set_interface_block_map(value->interface_block_map_0());
@@ skipping 224 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