| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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_SERVICE_WORKER_SERVICE_WORKER_CACHE_STORAGE_H_ | |
| 6 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CACHE_STORAGE_H_ | |
| 7 | |
| 8 #include <map> | |
| 9 #include <string> | |
| 10 | |
| 11 #include "base/callback.h" | |
| 12 #include "base/files/file_path.h" | |
| 13 #include "base/memory/weak_ptr.h" | |
| 14 #include "content/browser/service_worker/service_worker_cache.h" | |
| 15 | |
| 16 namespace base { | |
| 17 class SequencedTaskRunner; | |
| 18 } | |
| 19 | |
| 20 namespace net { | |
| 21 class URLRequestContext; | |
| 22 } | |
| 23 | |
| 24 namespace storage { | |
| 25 class BlobStorageContext; | |
| 26 } | |
| 27 | |
| 28 namespace content { | |
| 29 class ServiceWorkerCacheScheduler; | |
| 30 | |
| 31 // TODO(jkarlin): Constrain the total bytes used per origin. | |
| 32 | |
| 33 // ServiceWorkerCacheStorage holds the set of caches for a given origin. It is | |
| 34 // owned by the ServiceWorkerCacheStorageManager. This class expects to be run | |
| 35 // on the IO thread. The asynchronous methods are executed serially. | |
| 36 class CONTENT_EXPORT ServiceWorkerCacheStorage { | |
| 37 public: | |
| 38 enum CacheStorageError { | |
| 39 CACHE_STORAGE_ERROR_NO_ERROR, | |
| 40 CACHE_STORAGE_ERROR_NOT_IMPLEMENTED, | |
| 41 CACHE_STORAGE_ERROR_NOT_FOUND, | |
| 42 CACHE_STORAGE_ERROR_EXISTS, | |
| 43 CACHE_STORAGE_ERROR_STORAGE, | |
| 44 CACHE_STORAGE_ERROR_CLOSING | |
| 45 }; | |
| 46 typedef std::vector<std::string> StringVector; | |
| 47 typedef base::Callback<void(bool, CacheStorageError)> BoolAndErrorCallback; | |
| 48 typedef base::Callback<void(const scoped_refptr<ServiceWorkerCache>&, | |
| 49 CacheStorageError)> CacheAndErrorCallback; | |
| 50 typedef base::Callback<void(const StringVector&, CacheStorageError)> | |
| 51 StringsAndErrorCallback; | |
| 52 | |
| 53 static const char kIndexFileName[]; | |
| 54 | |
| 55 ServiceWorkerCacheStorage( | |
| 56 const base::FilePath& origin_path, | |
| 57 bool memory_only, | |
| 58 base::SequencedTaskRunner* cache_task_runner, | |
| 59 net::URLRequestContext* request_context, | |
| 60 const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy, | |
| 61 base::WeakPtr<storage::BlobStorageContext> blob_context, | |
| 62 const GURL& origin); | |
| 63 | |
| 64 // Any unfinished asynchronous operations may not complete or call their | |
| 65 // callbacks. | |
| 66 virtual ~ServiceWorkerCacheStorage(); | |
| 67 | |
| 68 // Get the cache for the given key. If the cache is not found it is | |
| 69 // created. | |
| 70 void OpenCache(const std::string& cache_name, | |
| 71 const CacheAndErrorCallback& callback); | |
| 72 | |
| 73 // Calls the callback with whether or not the cache exists. | |
| 74 void HasCache(const std::string& cache_name, | |
| 75 const BoolAndErrorCallback& callback); | |
| 76 | |
| 77 // Deletes the cache if it exists. If it doesn't exist, | |
| 78 // CACHE_STORAGE_ERROR_NOT_FOUND is returned. | |
| 79 void DeleteCache(const std::string& cache_name, | |
| 80 const BoolAndErrorCallback& callback); | |
| 81 | |
| 82 // Calls the callback with a vector of cache names (keys) available. | |
| 83 void EnumerateCaches(const StringsAndErrorCallback& callback); | |
| 84 | |
| 85 // Calls match on the cache with the given |cache_name|. | |
| 86 void MatchCache(const std::string& cache_name, | |
| 87 scoped_ptr<ServiceWorkerFetchRequest> request, | |
| 88 const ServiceWorkerCache::ResponseCallback& callback); | |
| 89 | |
| 90 // Calls match on all of the caches in parallel, calling |callback| with the | |
| 91 // first response found. Note that if multiple caches have the same | |
| 92 // request/response then it is not defined which cache's response will be | |
| 93 // returned. If no response is found then |callback| is called with | |
| 94 // ServiceWorkerCache::ErrorTypeNotFound. | |
| 95 void MatchAllCaches(scoped_ptr<ServiceWorkerFetchRequest> request, | |
| 96 const ServiceWorkerCache::ResponseCallback& callback); | |
| 97 | |
| 98 // Calls close on each cache and runs the callback after all of them have | |
| 99 // closed. | |
| 100 void CloseAllCaches(const base::Closure& callback); | |
| 101 | |
| 102 // The size of all of the origin's contents in memory. Returns 0 if the cache | |
| 103 // backend is not a memory backend. Runs synchronously. | |
| 104 int64 MemoryBackedSize() const; | |
| 105 | |
| 106 // The functions below are for tests to verify that the operations run | |
| 107 // serially. | |
| 108 void StartAsyncOperationForTesting(); | |
| 109 void CompleteAsyncOperationForTesting(); | |
| 110 | |
| 111 private: | |
| 112 class MemoryLoader; | |
| 113 class SimpleCacheLoader; | |
| 114 class CacheLoader; | |
| 115 | |
| 116 typedef std::map<std::string, base::WeakPtr<ServiceWorkerCache> > CacheMap; | |
| 117 | |
| 118 // Return a ServiceWorkerCache for the given name if the name is known. If the | |
| 119 // ServiceWorkerCache has been deleted, creates a new one. | |
| 120 scoped_refptr<ServiceWorkerCache> GetLoadedCache( | |
| 121 const std::string& cache_name); | |
| 122 | |
| 123 // Initializer and its callback are below. | |
| 124 void LazyInit(); | |
| 125 void LazyInitImpl(); | |
| 126 void LazyInitDidLoadIndex( | |
| 127 scoped_ptr<std::vector<std::string> > indexed_cache_names); | |
| 128 | |
| 129 // The Open and CreateCache callbacks are below. | |
| 130 void OpenCacheImpl(const std::string& cache_name, | |
| 131 const CacheAndErrorCallback& callback); | |
| 132 void CreateCacheDidCreateCache( | |
| 133 const std::string& cache_name, | |
| 134 const CacheAndErrorCallback& callback, | |
| 135 const scoped_refptr<ServiceWorkerCache>& cache); | |
| 136 void CreateCacheDidWriteIndex(const CacheAndErrorCallback& callback, | |
| 137 const scoped_refptr<ServiceWorkerCache>& cache, | |
| 138 bool success); | |
| 139 | |
| 140 // The HasCache callbacks are below. | |
| 141 void HasCacheImpl(const std::string& cache_name, | |
| 142 const BoolAndErrorCallback& callback); | |
| 143 | |
| 144 // The DeleteCache callbacks are below. | |
| 145 void DeleteCacheImpl(const std::string& cache_name, | |
| 146 const BoolAndErrorCallback& callback); | |
| 147 | |
| 148 void DeleteCacheDidClose(const std::string& cache_name, | |
| 149 const BoolAndErrorCallback& callback, | |
| 150 const StringVector& ordered_cache_names, | |
| 151 const scoped_refptr<ServiceWorkerCache>& cache); | |
| 152 void DeleteCacheDidWriteIndex(const std::string& cache_name, | |
| 153 const BoolAndErrorCallback& callback, | |
| 154 bool success); | |
| 155 void DeleteCacheDidCleanUp(const BoolAndErrorCallback& callback, | |
| 156 bool success); | |
| 157 | |
| 158 // The EnumerateCache callbacks are below. | |
| 159 void EnumerateCachesImpl(const StringsAndErrorCallback& callback); | |
| 160 | |
| 161 // The MatchCache callbacks are below. | |
| 162 void MatchCacheImpl(const std::string& cache_name, | |
| 163 scoped_ptr<ServiceWorkerFetchRequest> request, | |
| 164 const ServiceWorkerCache::ResponseCallback& callback); | |
| 165 void MatchCacheDidMatch(const scoped_refptr<ServiceWorkerCache>& cache, | |
| 166 const ServiceWorkerCache::ResponseCallback& callback, | |
| 167 ServiceWorkerCache::ErrorType error, | |
| 168 scoped_ptr<ServiceWorkerResponse> response, | |
| 169 scoped_ptr<storage::BlobDataHandle> handle); | |
| 170 | |
| 171 // The MatchAllCaches callbacks are below. | |
| 172 void MatchAllCachesImpl(scoped_ptr<ServiceWorkerFetchRequest> request, | |
| 173 const ServiceWorkerCache::ResponseCallback& callback); | |
| 174 void MatchAllCachesDidMatch(scoped_refptr<ServiceWorkerCache> cache, | |
| 175 const base::Closure& barrier_closure, | |
| 176 ServiceWorkerCache::ResponseCallback* callback, | |
| 177 ServiceWorkerCache::ErrorType error, | |
| 178 scoped_ptr<ServiceWorkerResponse> response, | |
| 179 scoped_ptr<storage::BlobDataHandle> handle); | |
| 180 void MatchAllCachesDidMatchAll( | |
| 181 scoped_ptr<ServiceWorkerCache::ResponseCallback> callback); | |
| 182 | |
| 183 // The CloseAllCaches callbacks are below. | |
| 184 void CloseAllCachesImpl(const base::Closure& callback); | |
| 185 | |
| 186 void PendingClosure(const base::Closure& callback); | |
| 187 void PendingBoolAndErrorCallback(const BoolAndErrorCallback& callback, | |
| 188 bool found, | |
| 189 CacheStorageError error); | |
| 190 void PendingCacheAndErrorCallback( | |
| 191 const CacheAndErrorCallback& callback, | |
| 192 const scoped_refptr<ServiceWorkerCache>& cache, | |
| 193 CacheStorageError error); | |
| 194 void PendingStringsAndErrorCallback(const StringsAndErrorCallback& callback, | |
| 195 const StringVector& strings, | |
| 196 CacheStorageError error); | |
| 197 void PendingResponseCallback( | |
| 198 const ServiceWorkerCache::ResponseCallback& callback, | |
| 199 ServiceWorkerCache::ErrorType error, | |
| 200 scoped_ptr<ServiceWorkerResponse> response, | |
| 201 scoped_ptr<storage::BlobDataHandle> blob_data_handle); | |
| 202 | |
| 203 // Whether or not we've loaded the list of cache names into memory. | |
| 204 bool initialized_; | |
| 205 bool initializing_; | |
| 206 | |
| 207 // The pending operation scheduler. | |
| 208 scoped_ptr<ServiceWorkerCacheScheduler> scheduler_; | |
| 209 | |
| 210 // The map of cache names to ServiceWorkerCache objects. | |
| 211 CacheMap cache_map_; | |
| 212 | |
| 213 // The names of caches in the order that they were created. | |
| 214 StringVector ordered_cache_names_; | |
| 215 | |
| 216 // The file path for this CacheStorage. | |
| 217 base::FilePath origin_path_; | |
| 218 | |
| 219 // The TaskRunner to run file IO on. | |
| 220 scoped_refptr<base::SequencedTaskRunner> cache_task_runner_; | |
| 221 | |
| 222 // Whether or not to store data in disk or memory. | |
| 223 bool memory_only_; | |
| 224 | |
| 225 // Performs backend specific operations (memory vs disk). | |
| 226 scoped_ptr<CacheLoader> cache_loader_; | |
| 227 | |
| 228 base::WeakPtrFactory<ServiceWorkerCacheStorage> weak_factory_; | |
| 229 | |
| 230 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerCacheStorage); | |
| 231 }; | |
| 232 | |
| 233 } // namespace content | |
| 234 | |
| 235 #endif // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_CACHE_STORAGE_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1039763002:
Cache Storage: Move files to content/*/cache_storage, rename classes (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master