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/serviceworkers/CacheStorage.h" | 6 #include "modules/serviceworkers/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" |
11 #include "modules/serviceworkers/Cache.h" | 11 #include "modules/serviceworkers/Cache.h" |
12 #include "public/platform/WebServiceWorkerCacheError.h" | 12 #include "public/platform/WebServiceWorkerCacheError.h" |
13 #include "public/platform/WebServiceWorkerCacheStorage.h" | 13 #include "public/platform/WebServiceWorkerCacheStorage.h" |
14 | 14 |
15 namespace blink { | 15 namespace blink { |
16 | 16 |
17 namespace { | 17 namespace { |
18 | 18 |
19 PassRefPtrWillBeRawPtr<DOMException> createNoImplementationException() | 19 PassRefPtrWillBeRawPtr<DOMException> createNoImplementationException() |
20 { | 20 { |
21 return DOMException::create(NotSupportedError, "No CacheStorage implementati
on provided."); | 21 return DOMException::create(NotSupportedError, "No CacheStorage implementati
on provided."); |
22 } | 22 } |
23 | 23 |
24 } | 24 } |
25 | 25 |
26 // FIXME: Consider using CallbackPromiseAdapter. | 26 // FIXME: Consider using CallbackPromiseAdapter. |
27 class CacheStorage::Callbacks FINAL : public WebServiceWorkerCacheStorage::Cache
StorageCallbacks { | 27 class CacheStorage::Callbacks final : public WebServiceWorkerCacheStorage::Cache
StorageCallbacks { |
28 WTF_MAKE_NONCOPYABLE(Callbacks); | 28 WTF_MAKE_NONCOPYABLE(Callbacks); |
29 public: | 29 public: |
30 explicit Callbacks(PassRefPtr<ScriptPromiseResolver> resolver) | 30 explicit Callbacks(PassRefPtr<ScriptPromiseResolver> resolver) |
31 : m_resolver(resolver) { } | 31 : m_resolver(resolver) { } |
32 virtual ~Callbacks() { } | 32 virtual ~Callbacks() { } |
33 | 33 |
34 virtual void onSuccess() OVERRIDE | 34 virtual void onSuccess() override |
35 { | 35 { |
36 m_resolver->resolve(true); | 36 m_resolver->resolve(true); |
37 m_resolver.clear(); | 37 m_resolver.clear(); |
38 } | 38 } |
39 | 39 |
40 virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE | 40 virtual void onError(WebServiceWorkerCacheError* reason) override |
41 { | 41 { |
42 if (*reason == WebServiceWorkerCacheErrorNotFound) | 42 if (*reason == WebServiceWorkerCacheErrorNotFound) |
43 m_resolver->resolve(false); | 43 m_resolver->resolve(false); |
44 else | 44 else |
45 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); | 45 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); |
46 m_resolver.clear(); | 46 m_resolver.clear(); |
47 } | 47 } |
48 | 48 |
49 private: | 49 private: |
50 RefPtr<ScriptPromiseResolver> m_resolver; | 50 RefPtr<ScriptPromiseResolver> m_resolver; |
51 }; | 51 }; |
52 | 52 |
53 // FIXME: Consider using CallbackPromiseAdapter. | 53 // FIXME: Consider using CallbackPromiseAdapter. |
54 class CacheStorage::WithCacheCallbacks FINAL : public WebServiceWorkerCacheStora
ge::CacheStorageWithCacheCallbacks { | 54 class CacheStorage::WithCacheCallbacks final : public WebServiceWorkerCacheStora
ge::CacheStorageWithCacheCallbacks { |
55 WTF_MAKE_NONCOPYABLE(WithCacheCallbacks); | 55 WTF_MAKE_NONCOPYABLE(WithCacheCallbacks); |
56 public: | 56 public: |
57 WithCacheCallbacks(const String& cacheName, CacheStorage* cacheStorage, Pass
RefPtr<ScriptPromiseResolver> resolver) | 57 WithCacheCallbacks(const String& cacheName, CacheStorage* cacheStorage, Pass
RefPtr<ScriptPromiseResolver> resolver) |
58 : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resol
ver) { } | 58 : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resol
ver) { } |
59 virtual ~WithCacheCallbacks() { } | 59 virtual ~WithCacheCallbacks() { } |
60 | 60 |
61 virtual void onSuccess(WebServiceWorkerCache* webCache) OVERRIDE | 61 virtual void onSuccess(WebServiceWorkerCache* webCache) override |
62 { | 62 { |
63 // FIXME: Remove this once content's WebServiceWorkerCache implementatio
n has landed. | 63 // FIXME: Remove this once content's WebServiceWorkerCache implementatio
n has landed. |
64 if (!webCache) { | 64 if (!webCache) { |
65 m_resolver->reject("not implemented"); | 65 m_resolver->reject("not implemented"); |
66 return; | 66 return; |
67 } | 67 } |
68 Cache* cache = Cache::create(webCache); | 68 Cache* cache = Cache::create(webCache); |
69 m_cacheStorage->m_nameToCacheMap.set(m_cacheName, cache); | 69 m_cacheStorage->m_nameToCacheMap.set(m_cacheName, cache); |
70 m_resolver->resolve(cache); | 70 m_resolver->resolve(cache); |
71 m_resolver.clear(); | 71 m_resolver.clear(); |
72 } | 72 } |
73 | 73 |
74 virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE | 74 virtual void onError(WebServiceWorkerCacheError* reason) override |
75 { | 75 { |
76 if (*reason == WebServiceWorkerCacheErrorNotFound) | 76 if (*reason == WebServiceWorkerCacheErrorNotFound) |
77 m_resolver->resolve(); | 77 m_resolver->resolve(); |
78 else | 78 else |
79 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); | 79 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); |
80 m_resolver.clear(); | 80 m_resolver.clear(); |
81 } | 81 } |
82 | 82 |
83 private: | 83 private: |
84 String m_cacheName; | 84 String m_cacheName; |
85 Persistent<CacheStorage> m_cacheStorage; | 85 Persistent<CacheStorage> m_cacheStorage; |
86 RefPtr<ScriptPromiseResolver> m_resolver; | 86 RefPtr<ScriptPromiseResolver> m_resolver; |
87 }; | 87 }; |
88 | 88 |
89 // FIXME: Consider using CallbackPromiseAdapter. | 89 // FIXME: Consider using CallbackPromiseAdapter. |
90 class CacheStorage::DeleteCallbacks FINAL : public WebServiceWorkerCacheStorage:
:CacheStorageCallbacks { | 90 class CacheStorage::DeleteCallbacks final : public WebServiceWorkerCacheStorage:
:CacheStorageCallbacks { |
91 WTF_MAKE_NONCOPYABLE(DeleteCallbacks); | 91 WTF_MAKE_NONCOPYABLE(DeleteCallbacks); |
92 public: | 92 public: |
93 DeleteCallbacks(const String& cacheName, CacheStorage* cacheStorage, PassRef
Ptr<ScriptPromiseResolver> resolver) | 93 DeleteCallbacks(const String& cacheName, CacheStorage* cacheStorage, PassRef
Ptr<ScriptPromiseResolver> resolver) |
94 : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resol
ver) { } | 94 : m_cacheName(cacheName), m_cacheStorage(cacheStorage), m_resolver(resol
ver) { } |
95 virtual ~DeleteCallbacks() { } | 95 virtual ~DeleteCallbacks() { } |
96 | 96 |
97 virtual void onSuccess() OVERRIDE | 97 virtual void onSuccess() override |
98 { | 98 { |
99 m_cacheStorage->m_nameToCacheMap.remove(m_cacheName); | 99 m_cacheStorage->m_nameToCacheMap.remove(m_cacheName); |
100 m_resolver->resolve(true); | 100 m_resolver->resolve(true); |
101 m_resolver.clear(); | 101 m_resolver.clear(); |
102 } | 102 } |
103 | 103 |
104 virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE | 104 virtual void onError(WebServiceWorkerCacheError* reason) override |
105 { | 105 { |
106 if (*reason == WebServiceWorkerCacheErrorNotFound) | 106 if (*reason == WebServiceWorkerCacheErrorNotFound) |
107 m_resolver->resolve(false); | 107 m_resolver->resolve(false); |
108 else | 108 else |
109 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); | 109 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); |
110 m_resolver.clear(); | 110 m_resolver.clear(); |
111 } | 111 } |
112 | 112 |
113 private: | 113 private: |
114 String m_cacheName; | 114 String m_cacheName; |
115 Persistent<CacheStorage> m_cacheStorage; | 115 Persistent<CacheStorage> m_cacheStorage; |
116 RefPtr<ScriptPromiseResolver> m_resolver; | 116 RefPtr<ScriptPromiseResolver> m_resolver; |
117 }; | 117 }; |
118 | 118 |
119 // FIXME: Consider using CallbackPromiseAdapter. | 119 // FIXME: Consider using CallbackPromiseAdapter. |
120 class CacheStorage::KeysCallbacks FINAL : public WebServiceWorkerCacheStorage::C
acheStorageKeysCallbacks { | 120 class CacheStorage::KeysCallbacks final : public WebServiceWorkerCacheStorage::C
acheStorageKeysCallbacks { |
121 WTF_MAKE_NONCOPYABLE(KeysCallbacks); | 121 WTF_MAKE_NONCOPYABLE(KeysCallbacks); |
122 public: | 122 public: |
123 explicit KeysCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) | 123 explicit KeysCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) |
124 : m_resolver(resolver) { } | 124 : m_resolver(resolver) { } |
125 virtual ~KeysCallbacks() { } | 125 virtual ~KeysCallbacks() { } |
126 | 126 |
127 virtual void onSuccess(WebVector<WebString>* keys) OVERRIDE | 127 virtual void onSuccess(WebVector<WebString>* keys) override |
128 { | 128 { |
129 Vector<String> wtfKeys; | 129 Vector<String> wtfKeys; |
130 for (size_t i = 0; i < keys->size(); ++i) | 130 for (size_t i = 0; i < keys->size(); ++i) |
131 wtfKeys.append((*keys)[i]); | 131 wtfKeys.append((*keys)[i]); |
132 m_resolver->resolve(wtfKeys); | 132 m_resolver->resolve(wtfKeys); |
133 m_resolver.clear(); | 133 m_resolver.clear(); |
134 } | 134 } |
135 | 135 |
136 virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE | 136 virtual void onError(WebServiceWorkerCacheError* reason) override |
137 { | 137 { |
138 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); | 138 m_resolver->reject(Cache::domExceptionForCacheError(*reason)); |
139 m_resolver.clear(); | 139 m_resolver.clear(); |
140 } | 140 } |
141 | 141 |
142 private: | 142 private: |
143 RefPtr<ScriptPromiseResolver> m_resolver; | 143 RefPtr<ScriptPromiseResolver> m_resolver; |
144 }; | 144 }; |
145 | 145 |
146 CacheStorage* CacheStorage::create(WebServiceWorkerCacheStorage* webCacheStorage
) | 146 CacheStorage* CacheStorage::create(WebServiceWorkerCacheStorage* webCacheStorage
) |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
228 { | 228 { |
229 visitor->trace(m_nameToCacheMap); | 229 visitor->trace(m_nameToCacheMap); |
230 } | 230 } |
231 | 231 |
232 CacheStorage::CacheStorage(WebServiceWorkerCacheStorage* webCacheStorage) | 232 CacheStorage::CacheStorage(WebServiceWorkerCacheStorage* webCacheStorage) |
233 : m_webCacheStorage(webCacheStorage) | 233 : m_webCacheStorage(webCacheStorage) |
234 { | 234 { |
235 } | 235 } |
236 | 236 |
237 } // namespace blink | 237 } // namespace blink |
OLD | NEW |