• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
set_host_id(int host_id)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 
backend()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