| 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 #include "config.h" | |
| 6 #include "modules/serviceworkers/CacheStorage.h" | |
| 7 | |
| 8 #include "bindings/core/v8/ScriptPromiseResolver.h" | |
| 9 #include "bindings/core/v8/ScriptState.h" | |
| 10 #include "core/dom/DOMException.h" | |
| 11 #include "core/dom/ExceptionCode.h" | |
| 12 #include "modules/fetch/Request.h" | |
| 13 #include "modules/fetch/Response.h" | |
| 14 #include "public/platform/WebServiceWorkerCacheError.h" | |
| 15 #include "public/platform/WebServiceWorkerCacheStorage.h" | |
| 16 | |
| 17 namespace blink { | |
| 18 | |
| 19 namespace { | |
| 20 | |
| 21 PassRefPtrWillBeRawPtr<DOMException> createNoImplementationException() | |
| 22 { | |
| 23 return DOMException::create(NotSupportedError, "No CacheStorage implementati
on provided."); | |
| 24 } | |
| 25 | |
| 26 } | |
| 27 | |
| 28 // FIXME: Consider using CallbackPromiseAdapter. | |
| 29 class CacheStorage::Callbacks final : public WebServiceWorkerCacheStorage::Cache
StorageCallbacks { | |
| 30 WTF_MAKE_NONCOPYABLE(Callbacks); | |
| 31 public: | |
| 32 explicit Callbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver) | |
| 33 : m_resolver(resolver) { } | |
| 34 virtual ~Callbacks() { } | |
| 35 | |
| 36 virtual void onSuccess() override | |
| 37 { | |
| 38 m_resolver->resolve(true); | |
| 39 m_resolver.clear(); | |
| 40 } | |
| 41 | |
| 42 virtual void onError(WebServiceWorkerCacheError* reason) override | |
| 43 { | |
| 44 if (*reason == WebServiceWorkerCacheErrorNotFound) | |
| 45 m_resolver->resolve(false); | |
| 46 else | |
| 47 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); | |
| 48 m_resolver.clear(); | |
| 49 } | |
| 50 | |
| 51 private: | |
| 52 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | |
| 53 }; | |
| 54 | |
| 55 // FIXME: Consider using CallbackPromiseAdapter. | |
| 56 class CacheStorage::WithCacheCallbacks final : public WebServiceWorkerCacheStora
ge::CacheStorageWithCacheCallbacks { | |
| 57 WTF_MAKE_NONCOPYABLE(WithCacheCallbacks); | |
| 58 public: | |
| 59 WithCacheCallbacks(const String& cacheName, CacheStorage* cacheStorage, Pass
RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver) | |
| 60 : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resol
ver) { } | |
| 61 virtual ~WithCacheCallbacks() { } | |
| 62 | |
| 63 virtual void onSuccess(WebServiceWorkerCache* webCache) override | |
| 64 { | |
| 65 // FIXME: Remove this once content's WebServiceWorkerCache implementatio
n has landed. | |
| 66 if (!webCache) { | |
| 67 m_resolver->reject("not implemented"); | |
| 68 return; | |
| 69 } | |
| 70 Cache* cache = Cache::create(webCache); | |
| 71 m_cacheStorage->m_nameToCacheMap.set(m_cacheName, cache); | |
| 72 m_resolver->resolve(cache); | |
| 73 m_resolver.clear(); | |
| 74 } | |
| 75 | |
| 76 virtual void onError(WebServiceWorkerCacheError* reason) override | |
| 77 { | |
| 78 if (*reason == WebServiceWorkerCacheErrorNotFound) | |
| 79 m_resolver->resolve(); | |
| 80 else | |
| 81 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); | |
| 82 m_resolver.clear(); | |
| 83 } | |
| 84 | |
| 85 private: | |
| 86 String m_cacheName; | |
| 87 Persistent<CacheStorage> m_cacheStorage; | |
| 88 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | |
| 89 }; | |
| 90 | |
| 91 // FIXME: Consider using CallbackPromiseAdapter. | |
| 92 class CacheStorage::MatchCallbacks : public WebServiceWorkerCacheStorage::CacheS
torageMatchCallbacks { | |
| 93 WTF_MAKE_NONCOPYABLE(MatchCallbacks); | |
| 94 public: | |
| 95 MatchCallbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver) | |
| 96 : m_resolver(resolver) { } | |
| 97 | |
| 98 virtual void onSuccess(WebServiceWorkerResponse* webResponse) override | |
| 99 { | |
| 100 m_resolver->resolve(Response::create(m_resolver->scriptState()->executio
nContext(), *webResponse)); | |
| 101 m_resolver.clear(); | |
| 102 } | |
| 103 | |
| 104 virtual void onError(WebServiceWorkerCacheError* reason) override | |
| 105 { | |
| 106 if (*reason == WebServiceWorkerCacheErrorNotFound) | |
| 107 m_resolver->resolve(); | |
| 108 else | |
| 109 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); | |
| 110 m_resolver.clear(); | |
| 111 } | |
| 112 | |
| 113 private: | |
| 114 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | |
| 115 }; | |
| 116 | |
| 117 | |
| 118 // FIXME: Consider using CallbackPromiseAdapter. | |
| 119 class CacheStorage::DeleteCallbacks final : public WebServiceWorkerCacheStorage:
:CacheStorageCallbacks { | |
| 120 WTF_MAKE_NONCOPYABLE(DeleteCallbacks); | |
| 121 public: | |
| 122 DeleteCallbacks(const String& cacheName, CacheStorage* cacheStorage, PassRef
PtrWillBeRawPtr<ScriptPromiseResolver> resolver) | |
| 123 : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resol
ver) { } | |
| 124 virtual ~DeleteCallbacks() { } | |
| 125 | |
| 126 virtual void onSuccess() override | |
| 127 { | |
| 128 m_cacheStorage->m_nameToCacheMap.remove(m_cacheName); | |
| 129 m_resolver->resolve(true); | |
| 130 m_resolver.clear(); | |
| 131 } | |
| 132 | |
| 133 virtual void onError(WebServiceWorkerCacheError* reason) override | |
| 134 { | |
| 135 if (*reason == WebServiceWorkerCacheErrorNotFound) | |
| 136 m_resolver->resolve(false); | |
| 137 else | |
| 138 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); | |
| 139 m_resolver.clear(); | |
| 140 } | |
| 141 | |
| 142 private: | |
| 143 String m_cacheName; | |
| 144 Persistent<CacheStorage> m_cacheStorage; | |
| 145 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | |
| 146 }; | |
| 147 | |
| 148 // FIXME: Consider using CallbackPromiseAdapter. | |
| 149 class CacheStorage::KeysCallbacks final : public WebServiceWorkerCacheStorage::C
acheStorageKeysCallbacks { | |
| 150 WTF_MAKE_NONCOPYABLE(KeysCallbacks); | |
| 151 public: | |
| 152 explicit KeysCallbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolve
r) | |
| 153 : m_resolver(resolver) { } | |
| 154 virtual ~KeysCallbacks() { } | |
| 155 | |
| 156 virtual void onSuccess(WebVector<WebString>* keys) override | |
| 157 { | |
| 158 Vector<String> wtfKeys; | |
| 159 for (size_t i = 0; i < keys->size(); ++i) | |
| 160 wtfKeys.append((*keys)[i]); | |
| 161 m_resolver->resolve(wtfKeys); | |
| 162 m_resolver.clear(); | |
| 163 } | |
| 164 | |
| 165 virtual void onError(WebServiceWorkerCacheError* reason) override | |
| 166 { | |
| 167 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); | |
| 168 m_resolver.clear(); | |
| 169 } | |
| 170 | |
| 171 private: | |
| 172 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | |
| 173 }; | |
| 174 | |
| 175 CacheStorage* CacheStorage::create(WebServiceWorkerCacheStorage* webCacheStorage
) | |
| 176 { | |
| 177 return new CacheStorage(adoptPtr(webCacheStorage)); | |
| 178 } | |
| 179 | |
| 180 ScriptPromise CacheStorage::open(ScriptState* scriptState, const String& cacheNa
me) | |
| 181 { | |
| 182 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::
create(scriptState); | |
| 183 const ScriptPromise promise = resolver->promise(); | |
| 184 | |
| 185 if (m_nameToCacheMap.contains(cacheName)) { | |
| 186 Cache* cache = m_nameToCacheMap.find(cacheName)->value; | |
| 187 resolver->resolve(cache); | |
| 188 return promise; | |
| 189 } | |
| 190 | |
| 191 if (m_webCacheStorage) | |
| 192 m_webCacheStorage->dispatchOpen(new WithCacheCallbacks(cacheName, this,
resolver), cacheName); | |
| 193 else | |
| 194 resolver->reject(createNoImplementationException()); | |
| 195 | |
| 196 return promise; | |
| 197 } | |
| 198 | |
| 199 ScriptPromise CacheStorage::has(ScriptState* scriptState, const String& cacheNam
e) | |
| 200 { | |
| 201 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::
create(scriptState); | |
| 202 const ScriptPromise promise = resolver->promise(); | |
| 203 | |
| 204 if (m_nameToCacheMap.contains(cacheName)) { | |
| 205 resolver->resolve(true); | |
| 206 return promise; | |
| 207 } | |
| 208 | |
| 209 if (m_webCacheStorage) | |
| 210 m_webCacheStorage->dispatchHas(new Callbacks(resolver), cacheName); | |
| 211 else | |
| 212 resolver->reject(createNoImplementationException()); | |
| 213 | |
| 214 return promise; | |
| 215 } | |
| 216 | |
| 217 ScriptPromise CacheStorage::deleteFunction(ScriptState* scriptState, const Strin
g& cacheName) | |
| 218 { | |
| 219 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::
create(scriptState); | |
| 220 const ScriptPromise promise = resolver->promise(); | |
| 221 | |
| 222 if (m_webCacheStorage) | |
| 223 m_webCacheStorage->dispatchDelete(new DeleteCallbacks(cacheName, this, r
esolver), cacheName); | |
| 224 else | |
| 225 resolver->reject(createNoImplementationException()); | |
| 226 | |
| 227 return promise; | |
| 228 } | |
| 229 | |
| 230 ScriptPromise CacheStorage::keys(ScriptState* scriptState) | |
| 231 { | |
| 232 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::
create(scriptState); | |
| 233 const ScriptPromise promise = resolver->promise(); | |
| 234 | |
| 235 if (m_webCacheStorage) | |
| 236 m_webCacheStorage->dispatchKeys(new KeysCallbacks(resolver)); | |
| 237 else | |
| 238 resolver->reject(createNoImplementationException()); | |
| 239 | |
| 240 return promise; | |
| 241 } | |
| 242 | |
| 243 ScriptPromise CacheStorage::match(ScriptState* scriptState, const RequestInfo& r
equest, const CacheQueryOptions& options, ExceptionState& exceptionState) | |
| 244 { | |
| 245 ASSERT(!request.isNull()); | |
| 246 | |
| 247 if (request.isRequest()) | |
| 248 return matchImpl(scriptState, request.getAsRequest(), options); | |
| 249 Request* newRequest = Request::create(scriptState->executionContext(), reque
st.getAsUSVString(), exceptionState); | |
| 250 if (exceptionState.hadException()) | |
| 251 return ScriptPromise(); | |
| 252 return matchImpl(scriptState, newRequest, options); | |
| 253 } | |
| 254 | |
| 255 ScriptPromise CacheStorage::matchImpl(ScriptState* scriptState, const Request* r
equest, const CacheQueryOptions& options) | |
| 256 { | |
| 257 WebServiceWorkerRequest webRequest; | |
| 258 request->populateWebServiceWorkerRequest(webRequest); | |
| 259 | |
| 260 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::
create(scriptState); | |
| 261 const ScriptPromise promise = resolver->promise(); | |
| 262 | |
| 263 if (m_webCacheStorage) | |
| 264 m_webCacheStorage->dispatchMatch(new MatchCallbacks(resolver), webReques
t, Cache::toWebQueryParams(options)); | |
| 265 else | |
| 266 resolver->reject(createNoImplementationException()); | |
| 267 | |
| 268 return promise; | |
| 269 } | |
| 270 | |
| 271 DEFINE_TRACE(CacheStorage) | |
| 272 { | |
| 273 visitor->trace(m_nameToCacheMap); | |
| 274 } | |
| 275 | |
| 276 CacheStorage::CacheStorage(PassOwnPtr<WebServiceWorkerCacheStorage> webCacheStor
age) | |
| 277 : m_webCacheStorage(webCacheStorage) | |
| 278 { | |
| 279 } | |
| 280 | |
| 281 } // namespace blink | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1055543004:
Move Cache Storage API implementation to modules/cachestorage (Closed)
Base URL: svn://svn.chromium.org/blink/trunk