1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_ 6 #define CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_ 7 8 #include <map> 9 #include <queue> 10 #include <string> 11 12 #include "base/files/file_path.h" 13 #include "base/memory/ref_counted.h" 14 #include "base/memory/singleton.h" 15 #include "content/common/content_export.h" 16 #include "net/disk_cache/disk_cache.h" 17 18 namespace content { 19 20 class ShaderDiskCacheEntry; 21 class ShaderDiskReadHelper; 22 class ShaderClearHelper; 23 24 // ShaderDiskCache is the interface to the on disk cache for 25 // GL shaders. 26 // 27 // While this class is both RefCounted and SupportsWeakPtr 28 // when using this class you should work with the RefCounting. 29 // The WeakPtr is needed interally. 30 class CONTENT_EXPORT ShaderDiskCache 31 : public base::RefCounted<ShaderDiskCache>, 32 public base::SupportsWeakPtr<ShaderDiskCache> { 33 public: 34 void Init(); 35 36 void set_host_id(int host_id) { host_id_ = host_id; } 37 38 // Store the |shader| into the cache under |key|. 39 void Cache(const std::string& key, const std::string& shader); 40 41 // Clear a range of entries. This supports unbounded deletes in either 42 // direction by using null Time values for either |begin_time| or |end_time|. 43 // The return value is a net error code. If this method returns 44 // ERR_IO_PENDING, the |completion_callback| will be invoked when the 45 // operation completes. 46 int Clear( 47 const base::Time begin_time, 48 const base::Time end_time, 49 const net::CompletionCallback& completion_callback); 50 51 // Sets a callback for when the cache is available. If the cache is 52 // already available the callback will not be called and net::OK is returned. 53 // If the callback is set net::ERR_IO_PENDING is returned and the callback 54 // will be executed when the cache is available. 55 int SetAvailableCallback(const net::CompletionCallback& callback); 56 57 // Returns the number of elements currently in the cache. 58 int32 Size(); 59 60 // Set a callback notification for when all current entries have been 61 // written to the cache. 62 // The return value is a net error code. If this method returns 63 // ERR_IO_PENDING, the |callback| will be invoked when all entries have 64 // been written to the cache. 65 int SetCacheCompleteCallback(const net::CompletionCallback& callback); 66 67 private: 68 friend class base::RefCounted<ShaderDiskCache>; 69 friend class ShaderDiskCacheEntry; 70 friend class ShaderDiskReadHelper; 71 friend class ShaderCacheFactory; 72 73 explicit ShaderDiskCache(const base::FilePath& cache_path); 74 ~ShaderDiskCache(); 75 76 void CacheCreatedCallback(int rv); 77 78 disk_cache::Backend* backend() { return backend_.get(); } 79 80 void EntryComplete(void* entry); 81 void ReadComplete(); 82 83 bool cache_available_; 84 int host_id_; 85 base::FilePath cache_path_; 86 bool is_initialized_; 87 net::CompletionCallback available_callback_; 88 net::CompletionCallback cache_complete_callback_; 89 90 scoped_ptr<disk_cache::Backend> backend_; 91 92 scoped_refptr<ShaderDiskReadHelper> helper_; 93 std::map<void*, scoped_refptr<ShaderDiskCacheEntry> > entry_map_; 94 95 DISALLOW_COPY_AND_ASSIGN(ShaderDiskCache); 96 }; 97 98 // ShaderCacheFactory maintains a cache of ShaderDiskCache objects 99 // so we only create one per profile directory. 100 class CONTENT_EXPORT ShaderCacheFactory { 101 public: 102 static ShaderCacheFactory* GetInstance(); 103 104 // Clear the shader disk cache for the given |path|. This supports unbounded 105 // deletes in either direction by using null Time values for either 106 // |begin_time| or |end_time|. The |callback| will be executed when the 107 // clear is complete. 108 void ClearByPath(const base::FilePath& path, 109 const base::Time& begin_time, 110 const base::Time& end_time, 111 const base::Closure& callback); 112 113 // Retrieve the shader disk cache for the provided |client_id|. 114 scoped_refptr<ShaderDiskCache> Get(int32 client_id); 115 116 // Set the |path| to be used for the disk cache for |client_id|. 117 void SetCacheInfo(int32 client_id, const base::FilePath& path); 118 119 // Remove the path mapping for |client_id|. 120 void RemoveCacheInfo(int32 client_id); 121 122 // Set the provided |cache| into the cache map for the given |path|. 123 void AddToCache(const base::FilePath& path, ShaderDiskCache* cache); 124 125 // Remove the provided |path| from our cache map. 126 void RemoveFromCache(const base::FilePath& path); 127 128 private: 129 friend struct DefaultSingletonTraits<ShaderCacheFactory>; 130 friend class ShaderClearHelper; 131 132 ShaderCacheFactory(); 133 ~ShaderCacheFactory(); 134 135 scoped_refptr<ShaderDiskCache> GetByPath(const base::FilePath& path); 136 void CacheCleared(const base::FilePath& path); 137 138 typedef std::map<base::FilePath, ShaderDiskCache*> ShaderCacheMap; 139 ShaderCacheMap shader_cache_map_; 140 141 typedef std::map<int32, base::FilePath> ClientIdToPathMap; 142 ClientIdToPathMap client_id_to_path_map_; 143 144 typedef std::queue<scoped_refptr<ShaderClearHelper> > ShaderClearQueue; 145 typedef std::map<base::FilePath, ShaderClearQueue> ShaderClearMap; 146 ShaderClearMap shader_clear_map_; 147 148 DISALLOW_COPY_AND_ASSIGN(ShaderCacheFactory); 149 }; 150 151 } // namespace content 152 153 #endif // CONTENT_BROWSER_GPU_SHADER_DISK_CACHE_H_ 154 155
