OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "config.h" | 5 #include "config.h" |
6 #include "modules/cachestorage/CacheStorage.h" | 6 #include "modules/cachestorage/CacheStorage.h" |
7 | 7 |
8 #include "bindings/core/v8/ScriptPromiseResolver.h" | 8 #include "bindings/core/v8/ScriptPromiseResolver.h" |
9 #include "bindings/core/v8/ScriptState.h" | 9 #include "bindings/core/v8/ScriptState.h" |
10 #include "core/dom/DOMException.h" | 10 #include "core/dom/DOMException.h" |
(...skipping 12 matching lines...) Expand all Loading... | |
23 { | 23 { |
24 return DOMException::create(NotSupportedError, "No CacheStorage implementati on provided."); | 24 return DOMException::create(NotSupportedError, "No CacheStorage implementati on provided."); |
25 } | 25 } |
26 | 26 |
27 } | 27 } |
28 | 28 |
29 // FIXME: Consider using CallbackPromiseAdapter. | 29 // FIXME: Consider using CallbackPromiseAdapter. |
30 class CacheStorage::Callbacks final : public WebServiceWorkerCacheStorage::Cache StorageCallbacks { | 30 class CacheStorage::Callbacks final : public WebServiceWorkerCacheStorage::Cache StorageCallbacks { |
31 WTF_MAKE_NONCOPYABLE(Callbacks); | 31 WTF_MAKE_NONCOPYABLE(Callbacks); |
32 public: | 32 public: |
33 explicit Callbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver) | 33 explicit Callbacks(ScriptPromiseResolver* resolver) |
34 : m_resolver(resolver) { } | 34 : m_resolver(resolver) { } |
35 ~Callbacks() override { } | 35 ~Callbacks() override { } |
36 | 36 |
37 void onSuccess() override | 37 void onSuccess() override |
38 { | 38 { |
39 m_resolver->resolve(true); | 39 m_resolver->resolve(true); |
40 m_resolver.clear(); | 40 m_resolver.clear(); |
41 } | 41 } |
42 | 42 |
43 // Ownership of |rawReason| must be passed. | 43 // Ownership of |rawReason| must be passed. |
44 void onError(WebServiceWorkerCacheError* rawReason) override | 44 void onError(WebServiceWorkerCacheError* rawReason) override |
45 { | 45 { |
46 OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason); | 46 OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason); |
47 if (*reason == WebServiceWorkerCacheErrorNotFound) | 47 if (*reason == WebServiceWorkerCacheErrorNotFound) |
48 m_resolver->resolve(false); | 48 m_resolver->resolve(false); |
49 else | 49 else |
50 m_resolver->reject(CacheStorageError::createException(*reason)); | 50 m_resolver->reject(CacheStorageError::createException(*reason)); |
51 m_resolver.clear(); | 51 m_resolver.clear(); |
52 } | 52 } |
53 | 53 |
54 private: | 54 private: |
55 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 55 Persistent<ScriptPromiseResolver> m_resolver; |
56 }; | 56 }; |
57 | 57 |
58 // FIXME: Consider using CallbackPromiseAdapter. | 58 // FIXME: Consider using CallbackPromiseAdapter. |
59 class CacheStorage::WithCacheCallbacks final : public WebServiceWorkerCacheStora ge::CacheStorageWithCacheCallbacks { | 59 class CacheStorage::WithCacheCallbacks final : public WebServiceWorkerCacheStora ge::CacheStorageWithCacheCallbacks { |
60 WTF_MAKE_NONCOPYABLE(WithCacheCallbacks); | 60 WTF_MAKE_NONCOPYABLE(WithCacheCallbacks); |
61 public: | 61 public: |
62 WithCacheCallbacks(const String& cacheName, CacheStorage* cacheStorage, Pass RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver) | 62 WithCacheCallbacks(const String& cacheName, CacheStorage* cacheStorage, Scri ptPromiseResolver* resolver) |
63 : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resol ver) { } | 63 : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resol ver) { } |
64 ~WithCacheCallbacks() override { } | 64 ~WithCacheCallbacks() override { } |
65 | 65 |
66 void onSuccess(WebServiceWorkerCache* webCache) override | 66 void onSuccess(WebServiceWorkerCache* webCache) override |
67 { | 67 { |
68 // FIXME: Remove this once content's WebServiceWorkerCache implementatio n has landed. | 68 // FIXME: Remove this once content's WebServiceWorkerCache implementatio n has landed. |
69 if (!webCache) { | 69 if (!webCache) { |
70 m_resolver->reject("not implemented"); | 70 m_resolver->reject("not implemented"); |
71 return; | 71 return; |
72 } | 72 } |
(...skipping 10 matching lines...) Expand all Loading... | |
83 if (*reason == WebServiceWorkerCacheErrorNotFound) | 83 if (*reason == WebServiceWorkerCacheErrorNotFound) |
84 m_resolver->resolve(); | 84 m_resolver->resolve(); |
85 else | 85 else |
86 m_resolver->reject(CacheStorageError::createException(*reason)); | 86 m_resolver->reject(CacheStorageError::createException(*reason)); |
87 m_resolver.clear(); | 87 m_resolver.clear(); |
88 } | 88 } |
89 | 89 |
90 private: | 90 private: |
91 String m_cacheName; | 91 String m_cacheName; |
92 Persistent<CacheStorage> m_cacheStorage; | 92 Persistent<CacheStorage> m_cacheStorage; |
93 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 93 Persistent<ScriptPromiseResolver> m_resolver; |
94 }; | 94 }; |
95 | 95 |
96 // FIXME: Consider using CallbackPromiseAdapter. | 96 // FIXME: Consider using CallbackPromiseAdapter. |
97 class CacheStorage::MatchCallbacks : public WebServiceWorkerCacheStorage::CacheS torageMatchCallbacks { | 97 class CacheStorage::MatchCallbacks : public WebServiceWorkerCacheStorage::CacheS torageMatchCallbacks { |
98 WTF_MAKE_NONCOPYABLE(MatchCallbacks); | 98 WTF_MAKE_NONCOPYABLE(MatchCallbacks); |
99 public: | 99 public: |
100 MatchCallbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver) | 100 MatchCallbacks(ScriptPromiseResolver* resolver) |
haraken
2015/07/18 08:01:24
Add explicit.
sof
2015/07/18 20:46:08
Done.
| |
101 : m_resolver(resolver) { } | 101 : m_resolver(resolver) { } |
102 | 102 |
103 void onSuccess(WebServiceWorkerResponse* webResponse) override | 103 void onSuccess(WebServiceWorkerResponse* webResponse) override |
104 { | 104 { |
105 m_resolver->resolve(Response::create(m_resolver->scriptState()->executio nContext(), *webResponse)); | 105 m_resolver->resolve(Response::create(m_resolver->scriptState()->executio nContext(), *webResponse)); |
106 m_resolver.clear(); | 106 m_resolver.clear(); |
107 } | 107 } |
108 | 108 |
109 // Ownership of |rawReason| must be passed. | 109 // Ownership of |rawReason| must be passed. |
110 void onError(WebServiceWorkerCacheError* rawReason) override | 110 void onError(WebServiceWorkerCacheError* rawReason) override |
111 { | 111 { |
112 OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason); | 112 OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason); |
113 if (*reason == WebServiceWorkerCacheErrorNotFound) | 113 if (*reason == WebServiceWorkerCacheErrorNotFound) |
114 m_resolver->resolve(); | 114 m_resolver->resolve(); |
115 else | 115 else |
116 m_resolver->reject(CacheStorageError::createException(*reason)); | 116 m_resolver->reject(CacheStorageError::createException(*reason)); |
117 m_resolver.clear(); | 117 m_resolver.clear(); |
118 } | 118 } |
119 | 119 |
120 private: | 120 private: |
121 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 121 Persistent<ScriptPromiseResolver> m_resolver; |
122 }; | 122 }; |
123 | 123 |
124 | 124 |
125 // FIXME: Consider using CallbackPromiseAdapter. | 125 // FIXME: Consider using CallbackPromiseAdapter. |
126 class CacheStorage::DeleteCallbacks final : public WebServiceWorkerCacheStorage: :CacheStorageCallbacks { | 126 class CacheStorage::DeleteCallbacks final : public WebServiceWorkerCacheStorage: :CacheStorageCallbacks { |
127 WTF_MAKE_NONCOPYABLE(DeleteCallbacks); | 127 WTF_MAKE_NONCOPYABLE(DeleteCallbacks); |
128 public: | 128 public: |
129 DeleteCallbacks(const String& cacheName, CacheStorage* cacheStorage, PassRef PtrWillBeRawPtr<ScriptPromiseResolver> resolver) | 129 DeleteCallbacks(const String& cacheName, CacheStorage* cacheStorage, ScriptP romiseResolver* resolver) |
130 : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resol ver) { } | 130 : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resol ver) { } |
131 ~DeleteCallbacks() override { } | 131 ~DeleteCallbacks() override { } |
132 | 132 |
133 void onSuccess() override | 133 void onSuccess() override |
134 { | 134 { |
135 m_cacheStorage->m_nameToCacheMap.remove(m_cacheName); | 135 m_cacheStorage->m_nameToCacheMap.remove(m_cacheName); |
136 m_resolver->resolve(true); | 136 m_resolver->resolve(true); |
137 m_resolver.clear(); | 137 m_resolver.clear(); |
138 } | 138 } |
139 | 139 |
140 // Ownership of |rawReason| must be passed. | 140 // Ownership of |rawReason| must be passed. |
141 void onError(WebServiceWorkerCacheError* rawReason) override | 141 void onError(WebServiceWorkerCacheError* rawReason) override |
142 { | 142 { |
143 OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason); | 143 OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason); |
144 if (*reason == WebServiceWorkerCacheErrorNotFound) | 144 if (*reason == WebServiceWorkerCacheErrorNotFound) |
145 m_resolver->resolve(false); | 145 m_resolver->resolve(false); |
146 else | 146 else |
147 m_resolver->reject(CacheStorageError::createException(*reason)); | 147 m_resolver->reject(CacheStorageError::createException(*reason)); |
148 m_resolver.clear(); | 148 m_resolver.clear(); |
149 } | 149 } |
150 | 150 |
151 private: | 151 private: |
152 String m_cacheName; | 152 String m_cacheName; |
153 Persistent<CacheStorage> m_cacheStorage; | 153 Persistent<CacheStorage> m_cacheStorage; |
154 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 154 Persistent<ScriptPromiseResolver> m_resolver; |
155 }; | 155 }; |
156 | 156 |
157 // FIXME: Consider using CallbackPromiseAdapter. | 157 // FIXME: Consider using CallbackPromiseAdapter. |
158 class CacheStorage::KeysCallbacks final : public WebServiceWorkerCacheStorage::C acheStorageKeysCallbacks { | 158 class CacheStorage::KeysCallbacks final : public WebServiceWorkerCacheStorage::C acheStorageKeysCallbacks { |
159 WTF_MAKE_NONCOPYABLE(KeysCallbacks); | 159 WTF_MAKE_NONCOPYABLE(KeysCallbacks); |
160 public: | 160 public: |
161 explicit KeysCallbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolve r) | 161 explicit KeysCallbacks(ScriptPromiseResolver* resolver) |
162 : m_resolver(resolver) { } | 162 : m_resolver(resolver) { } |
163 ~KeysCallbacks() override { } | 163 ~KeysCallbacks() override { } |
164 | 164 |
165 void onSuccess(WebVector<WebString>* keys) override | 165 void onSuccess(WebVector<WebString>* keys) override |
166 { | 166 { |
167 Vector<String> wtfKeys; | 167 Vector<String> wtfKeys; |
168 for (size_t i = 0; i < keys->size(); ++i) | 168 for (size_t i = 0; i < keys->size(); ++i) |
169 wtfKeys.append((*keys)[i]); | 169 wtfKeys.append((*keys)[i]); |
170 m_resolver->resolve(wtfKeys); | 170 m_resolver->resolve(wtfKeys); |
171 m_resolver.clear(); | 171 m_resolver.clear(); |
172 } | 172 } |
173 | 173 |
174 // Ownership of |rawReason| must be passed. | 174 // Ownership of |rawReason| must be passed. |
175 void onError(WebServiceWorkerCacheError* rawReason) override | 175 void onError(WebServiceWorkerCacheError* rawReason) override |
176 { | 176 { |
177 OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason); | 177 OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason); |
178 m_resolver->reject(CacheStorageError::createException(*reason)); | 178 m_resolver->reject(CacheStorageError::createException(*reason)); |
179 m_resolver.clear(); | 179 m_resolver.clear(); |
180 } | 180 } |
181 | 181 |
182 private: | 182 private: |
183 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 183 Persistent<ScriptPromiseResolver> m_resolver; |
184 }; | 184 }; |
185 | 185 |
186 CacheStorage* CacheStorage::create(WeakPtr<GlobalFetch::ScopedFetcher> fetcher, WebServiceWorkerCacheStorage* webCacheStorage) | 186 CacheStorage* CacheStorage::create(WeakPtr<GlobalFetch::ScopedFetcher> fetcher, WebServiceWorkerCacheStorage* webCacheStorage) |
187 { | 187 { |
188 return new CacheStorage(fetcher, adoptPtr(webCacheStorage)); | 188 return new CacheStorage(fetcher, adoptPtr(webCacheStorage)); |
189 } | 189 } |
190 | 190 |
191 ScriptPromise CacheStorage::open(ScriptState* scriptState, const String& cacheNa me) | 191 ScriptPromise CacheStorage::open(ScriptState* scriptState, const String& cacheNa me) |
192 { | 192 { |
193 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | 193 ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState) ; |
194 const ScriptPromise promise = resolver->promise(); | 194 const ScriptPromise promise = resolver->promise(); |
195 | 195 |
196 if (m_nameToCacheMap.contains(cacheName)) { | 196 if (m_nameToCacheMap.contains(cacheName)) { |
197 Cache* cache = m_nameToCacheMap.find(cacheName)->value; | 197 Cache* cache = m_nameToCacheMap.find(cacheName)->value; |
198 resolver->resolve(cache); | 198 resolver->resolve(cache); |
199 return promise; | 199 return promise; |
200 } | 200 } |
201 | 201 |
202 if (m_webCacheStorage) | 202 if (m_webCacheStorage) |
203 m_webCacheStorage->dispatchOpen(new WithCacheCallbacks(cacheName, this, resolver), cacheName); | 203 m_webCacheStorage->dispatchOpen(new WithCacheCallbacks(cacheName, this, resolver), cacheName); |
204 else | 204 else |
205 resolver->reject(createNoImplementationException()); | 205 resolver->reject(createNoImplementationException()); |
206 | 206 |
207 return promise; | 207 return promise; |
208 } | 208 } |
209 | 209 |
210 ScriptPromise CacheStorage::has(ScriptState* scriptState, const String& cacheNam e) | 210 ScriptPromise CacheStorage::has(ScriptState* scriptState, const String& cacheNam e) |
211 { | 211 { |
212 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | 212 ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState) ; |
213 const ScriptPromise promise = resolver->promise(); | 213 const ScriptPromise promise = resolver->promise(); |
214 | 214 |
215 if (m_nameToCacheMap.contains(cacheName)) { | 215 if (m_nameToCacheMap.contains(cacheName)) { |
216 resolver->resolve(true); | 216 resolver->resolve(true); |
217 return promise; | 217 return promise; |
218 } | 218 } |
219 | 219 |
220 if (m_webCacheStorage) | 220 if (m_webCacheStorage) |
221 m_webCacheStorage->dispatchHas(new Callbacks(resolver), cacheName); | 221 m_webCacheStorage->dispatchHas(new Callbacks(resolver), cacheName); |
222 else | 222 else |
223 resolver->reject(createNoImplementationException()); | 223 resolver->reject(createNoImplementationException()); |
224 | 224 |
225 return promise; | 225 return promise; |
226 } | 226 } |
227 | 227 |
228 ScriptPromise CacheStorage::deleteFunction(ScriptState* scriptState, const Strin g& cacheName) | 228 ScriptPromise CacheStorage::deleteFunction(ScriptState* scriptState, const Strin g& cacheName) |
229 { | 229 { |
230 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | 230 ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState) ; |
231 const ScriptPromise promise = resolver->promise(); | 231 const ScriptPromise promise = resolver->promise(); |
232 | 232 |
233 if (m_webCacheStorage) | 233 if (m_webCacheStorage) |
234 m_webCacheStorage->dispatchDelete(new DeleteCallbacks(cacheName, this, r esolver), cacheName); | 234 m_webCacheStorage->dispatchDelete(new DeleteCallbacks(cacheName, this, r esolver), cacheName); |
235 else | 235 else |
236 resolver->reject(createNoImplementationException()); | 236 resolver->reject(createNoImplementationException()); |
237 | 237 |
238 return promise; | 238 return promise; |
239 } | 239 } |
240 | 240 |
241 ScriptPromise CacheStorage::keys(ScriptState* scriptState) | 241 ScriptPromise CacheStorage::keys(ScriptState* scriptState) |
242 { | 242 { |
243 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | 243 ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState) ; |
244 const ScriptPromise promise = resolver->promise(); | 244 const ScriptPromise promise = resolver->promise(); |
245 | 245 |
246 if (m_webCacheStorage) | 246 if (m_webCacheStorage) |
247 m_webCacheStorage->dispatchKeys(new KeysCallbacks(resolver)); | 247 m_webCacheStorage->dispatchKeys(new KeysCallbacks(resolver)); |
248 else | 248 else |
249 resolver->reject(createNoImplementationException()); | 249 resolver->reject(createNoImplementationException()); |
250 | 250 |
251 return promise; | 251 return promise; |
252 } | 252 } |
253 | 253 |
254 ScriptPromise CacheStorage::match(ScriptState* scriptState, const RequestInfo& r equest, const CacheQueryOptions& options, ExceptionState& exceptionState) | 254 ScriptPromise CacheStorage::match(ScriptState* scriptState, const RequestInfo& r equest, const CacheQueryOptions& options, ExceptionState& exceptionState) |
255 { | 255 { |
256 ASSERT(!request.isNull()); | 256 ASSERT(!request.isNull()); |
257 | 257 |
258 if (request.isRequest()) | 258 if (request.isRequest()) |
259 return matchImpl(scriptState, request.getAsRequest(), options); | 259 return matchImpl(scriptState, request.getAsRequest(), options); |
260 Request* newRequest = Request::create(scriptState, request.getAsUSVString(), exceptionState); | 260 Request* newRequest = Request::create(scriptState, request.getAsUSVString(), exceptionState); |
261 if (exceptionState.hadException()) | 261 if (exceptionState.hadException()) |
262 return ScriptPromise(); | 262 return ScriptPromise(); |
263 return matchImpl(scriptState, newRequest, options); | 263 return matchImpl(scriptState, newRequest, options); |
264 } | 264 } |
265 | 265 |
266 ScriptPromise CacheStorage::matchImpl(ScriptState* scriptState, const Request* r equest, const CacheQueryOptions& options) | 266 ScriptPromise CacheStorage::matchImpl(ScriptState* scriptState, const Request* r equest, const CacheQueryOptions& options) |
267 { | 267 { |
268 WebServiceWorkerRequest webRequest; | 268 WebServiceWorkerRequest webRequest; |
269 request->populateWebServiceWorkerRequest(webRequest); | 269 request->populateWebServiceWorkerRequest(webRequest); |
270 | 270 |
271 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | 271 ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState) ; |
272 const ScriptPromise promise = resolver->promise(); | 272 const ScriptPromise promise = resolver->promise(); |
273 | 273 |
274 if (m_webCacheStorage) | 274 if (m_webCacheStorage) |
275 m_webCacheStorage->dispatchMatch(new MatchCallbacks(resolver), webReques t, Cache::toWebQueryParams(options)); | 275 m_webCacheStorage->dispatchMatch(new MatchCallbacks(resolver), webReques t, Cache::toWebQueryParams(options)); |
276 else | 276 else |
277 resolver->reject(createNoImplementationException()); | 277 resolver->reject(createNoImplementationException()); |
278 | 278 |
279 return promise; | 279 return promise; |
280 } | 280 } |
281 | 281 |
(...skipping 11 matching lines...) Expand all Loading... | |
293 { | 293 { |
294 m_webCacheStorage.clear(); | 294 m_webCacheStorage.clear(); |
295 } | 295 } |
296 | 296 |
297 DEFINE_TRACE(CacheStorage) | 297 DEFINE_TRACE(CacheStorage) |
298 { | 298 { |
299 visitor->trace(m_nameToCacheMap); | 299 visitor->trace(m_nameToCacheMap); |
300 } | 300 } |
301 | 301 |
302 } // namespace blink | 302 } // namespace blink |
OLD | NEW |