Add the ability to clear the shader disk cache.

content/browser/gpu/shader_disk_cache_impl.h

 // Copyright (c) 2013 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.
 
-#ifndef CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_
-#define CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_
+#ifndef CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_IMPL_H_
+#define CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_IMPL_H_
 
 #include <map>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
+#include "content/public/browser/shader_disk_cache.h"
 #include "net/disk_cache/disk_cache.h"
 
 namespace content {
 
 class ShaderDiskCacheEntry;
 class ShaderDiskReadHelper;
 
 // ShaderDiskCache is the interface to the on disk cache for
 // GL shaders.
 //
 // While this class is both RefCounted and SupportsWeakPtr
 // when using this class you should work with the RefCounting.
 // The WeakPtr is needed interally.
 class ShaderDiskCache
     : public base::RefCounted<ShaderDiskCache>,
       public base::SupportsWeakPtr<ShaderDiskCache> {
  public:
   void Init();
 
-  void set_host_id(int host_id) { host_id_ = host_id; }

[jonathan.backer, 2013/03/20 18:39:05]

Why not inline?

[dsinclair, 2013/03/21 17:46:59]

Will put back. Was removed because the compiler didn't like inlined when there
were virtual methods in here.

-  void set_max_cache_size(size_t max_cache_size) {
-    max_cache_size_ = max_cache_size;
-  }
+  void set_host_id(int host_id);
+  void set_max_cache_size(size_t max_cache_size);
 
   void Cache(const std::string& key, const std::string& shader);
 
+  int Clear(
+      const base::Time begin_time,
+      const base::Time end_time,
+      const net::CompletionCallback& completion_callback);
+
+  // Sets a callback for when the cache is available. If the cache is
+  // already availble the callback will not be called and net::OK is returned.
+  // If the callback is set net::ERR_IO_PENDING is returned and the callback
+  // will be executed when the cache is available.
+  int SetAvailableCallback(const net::CompletionCallback& callback);

[jonathan.backer, 2013/03/20 18:39:05]

s/availble/available

[dsinclair, 2013/03/21 17:46:59]

Done.

+
  private:
   friend class base::RefCounted<ShaderDiskCache>;
   friend class ShaderDiskCacheEntry;
   friend class ShaderDiskReadHelper;
-  friend class ShaderCacheFactory;
+  friend class ShaderCacheFactoryImpl;
 
   explicit ShaderDiskCache(const base::FilePath& cache_path);
-  ~ShaderDiskCache();
+  virtual ~ShaderDiskCache();

[jonathan.backer, 2013/03/20 18:39:05]

Why is this now virtual?

[dsinclair, 2013/03/21 17:46:59]

Done. Did have an interface which is now removed.

 
   void CacheCreatedCallback(int rv);
 
   disk_cache::Backend* backend() { return backend_; }
 
   void EntryComplete(void* entry);
   void ReadComplete();
 
   bool cache_available_;
   size_t max_cache_size_;
   int host_id_;
   base::FilePath cache_path_;
   bool is_initialized_;
+  net::CompletionCallback available_callback_;
 
   disk_cache::Backend* backend_;
 
   scoped_refptr<ShaderDiskReadHelper> helper_;
   std::map<void*, scoped_refptr<ShaderDiskCacheEntry> > entry_map_;
 
   DISALLOW_COPY_AND_ASSIGN(ShaderDiskCache);
 };
 
-// ShaderCacheFactory maintains a cache of ShaderDiskCache objects
+// ShaderCacheFactory maintains a cache of ShaderDiskCacheImpl objects
 // so we only create one per profile directory.
-class ShaderCacheFactory {
+class ShaderCacheFactoryImpl : public content::ShaderCacheFactory {
  public:
-  static ShaderCacheFactory* GetInstance();
+  static ShaderCacheFactoryImpl* GetInstance();
 
+  virtual void ClearByPath(const base::FilePath& path,
+                           const base::Time& begin_time,
+                           const base::Time& end_time,
+                           const base::Closure& callback) OVERRIDE;
+
+  scoped_refptr<ShaderDiskCache> GetByPath(const base::FilePath& path);

[jonathan.backer, 2013/03/20 18:39:05]

private?

[dsinclair, 2013/03/21 17:46:59]

Done.

   scoped_refptr<ShaderDiskCache> Get(int32 client_id);
 
   void SetCacheInfo(int32 client_id, const base::FilePath& path);
   void RemoveCacheInfo(int32 client_id);
 
   void AddToCache(const base::FilePath& path, ShaderDiskCache* cache);
   void RemoveFromCache(const base::FilePath& path);
 
  private:
-  friend struct DefaultSingletonTraits<ShaderCacheFactory>;
+  friend struct DefaultSingletonTraits<ShaderCacheFactoryImpl>;
+  friend content::ShaderCacheFactory;
 
-  ShaderCacheFactory();
-  ~ShaderCacheFactory();
+  enum OpType {
+    TERMINATE,
+    CREATE_CACHE,
+    DELETE_CACHE
+  };
+
+  ShaderCacheFactoryImpl();
+  virtual ~ShaderCacheFactoryImpl();
+
+  void DoClearShaderCache(int rv);
 
   typedef std::map<base::FilePath, ShaderDiskCache*> ShaderCacheMap;
   ShaderCacheMap shader_cache_map_;
 
   typedef std::map<int32, base::FilePath> ClientIdToPathMap;
   ClientIdToPathMap client_id_to_path_map_;
 
-  DISALLOW_COPY_AND_ASSIGN(ShaderCacheFactory);
+  // Used fo the cache Clear call.

[jonathan.backer, 2013/03/20 18:39:05]

s/fo/for

[dsinclair, 2013/03/21 17:46:59]

Done.

+  OpType op_type_;
+  base::FilePath clear_path_;
+  base::Time delete_begin_;
+  base::Time delete_end_;
+  base::Closure clear_callback_;
+  scoped_refptr<ShaderDiskCache> clear_shader_cache_;

[jonathan.backer, 2013/03/20 18:39:05]

What happens if you clear multiple times in rapid succession (say before a clear
completes)? What happens if you clear different profiles in rapid succession?

I suspect that you want some map of structs (or ClearHelpers if you're feeling
OO) of this stuff for pending clear ops.

[dsinclair, 2013/03/21 17:46:59]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(ShaderCacheFactoryImpl);
 };
 
 }  // namespace content
 
-#endif  // CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_
+#endif  // CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_IMPL_H_