OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (C) 2013 Google Inc. All rights reserved. | 2 * Copyright (C) 2013 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 15 matching lines...) Expand all Loading... | |
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
29 */ | 29 */ |
30 | 30 |
31 #ifndef CallbackPromiseAdapter_h | 31 #ifndef CallbackPromiseAdapter_h |
32 #define CallbackPromiseAdapter_h | 32 #define CallbackPromiseAdapter_h |
33 | 33 |
34 #include "bindings/core/v8/ScriptPromiseResolver.h" | 34 #include "bindings/core/v8/ScriptPromiseResolver.h" |
35 #include "public/platform/WebCallbacks.h" | 35 #include "public/platform/WebCallbacks.h" |
36 #include "public/platform/WebPassOwnPtr.h" | |
37 #include "wtf/OwnPtr.h" | |
38 #include "wtf/PassOwnPtr.h" | |
36 | 39 |
37 namespace blink { | 40 namespace blink { |
38 | 41 |
39 // This class provides an easy way to convert from a Script-exposed | 42 class CallbackPromiseAdapterBase { |
40 // class (i.e. a class that has a toV8() overload) that uses Promises | 43 public: |
41 // to a WebKit API class that uses WebCallbacks. You can define | 44 // The following templates should be gone once the repositories are merged |
42 // separate Success and Error classes, but this example just uses one | 45 // and we can use C++11 libraries. |
43 // object for both. | 46 template <typename T> |
44 // | 47 struct PassTypeImpl { |
45 // To use: | 48 using Type = T; |
46 // | 49 }; |
47 // class MyClass ... { | 50 template <typename T> |
48 // typedef blink::WebMyClass WebType; | 51 struct PassTypeImpl<OwnPtr<T>> { |
49 // | 52 using Type = PassOwnPtr<T>; |
50 // // Takes ownership of |webInstance|. | 53 }; |
51 // static PassRefPtr<MyClass> take(ScriptPromiseResolver* resolver, | 54 |
52 // PassOwnPtr<blink::WebMyClass> webInstance) { | 55 template <typename T> |
53 // // convert/create as appropriate, but often it's just: | 56 struct WebPassTypeImpl { |
54 // return MyClass::create(webInstance); | 57 using Type = T; |
55 // | 58 }; |
56 // // Since promise resolving is done as an async task, it's not | 59 template <typename T> |
57 // // guaranteed that the script context has seen the promise resolve | 60 struct WebPassTypeImpl<OwnPtr<T>> { |
58 // // immediately after calling onSuccess/onError. You can use the | 61 using Type = WebPassOwnPtr<T>; |
59 // // ScriptPromise from the resolver to schedule a task that executes | 62 }; |
60 // // after resolving: | 63 template <typename T> |
61 // ScriptState::Scope scope(resolver->scriptState()); | 64 using PassType = typename PassTypeImpl<T>::Type; |
62 // resolver->promise().then(...); | 65 template <typename T> |
63 // } | 66 using WebPassType = typename WebPassTypeImpl<T>::Type; |
64 // | 67 template <typename T> |
65 // Now when calling into a WebKit API that requires a WebCallbacks<blink::WebMyC lass, blink::WebMyClass>*: | 68 static T& adopt(T& x) { return x; } |
66 // | 69 template <typename T> |
67 // // call signature: callSomeMethod(WebCallbacks<MyClass, MyClass>* callback s) | 70 static PassOwnPtr<T> adopt(WebPassOwnPtr<T>& x) { return x.release(); } |
68 // webObject->callSomeMethod(new CallbackPromiseAdapter<MyClass, MyClass>(res olver, scriptExecutionContext)); | 71 template <typename T> |
69 // | 72 static PassType<T> pass(T& x) { return x; } |
70 // Note: | 73 template <typename T> |
71 // - This class does not manage its own lifetime. In this example that ownership | 74 static PassOwnPtr<T> pass(OwnPtr<T>& x) { return x.release(); } |
72 // of the WebCallbacks instance is being passed in and it is up to the callee | 75 }; |
73 // to free the WebCallbacks instance. | 76 |
74 // - onSuccess and onError take ownership of the given WebType instance. | 77 |
78 // TODO(yhirano): Add comments. | |
haraken
2015/07/27 12:48:31
Can we add a comment in this CL?
yhirano
2015/07/29 04:01:53
I will add comments at the third CL - Is that enou
| |
75 template<typename S, typename T> | 79 template<typename S, typename T> |
76 class CallbackPromiseAdapter final : public WebCallbacks<typename S::WebType*, t ypename T::WebType*> { | 80 class CallbackPromiseAdapter final |
81 : public WebCallbacks<typename CallbackPromiseAdapterBase::WebPassType<typen ame S::WebType>, typename CallbackPromiseAdapterBase::WebPassType<typename T::We bType>>, public CallbackPromiseAdapterBase { | |
77 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); | 82 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); |
78 public: | 83 public: |
79 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) | 84 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) |
80 : m_resolver(resolver) | 85 : m_resolver(resolver) |
81 { | 86 { |
82 ASSERT(m_resolver); | 87 ASSERT(m_resolver); |
83 } | 88 } |
84 ~CallbackPromiseAdapter() override { } | 89 ~CallbackPromiseAdapter() override { } |
85 | 90 |
86 // Takes ownership of |result|. | 91 void onSuccess(WebPassType<typename S::WebType> r) override |
87 void onSuccess(typename S::WebType* result) override | |
88 { | 92 { |
89 OwnPtr<typename S::WebType> ownPtr = adoptPtr(result); | 93 typename S::WebType result(adopt(r)); |
90 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) | 94 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) |
91 return; | 95 return; |
92 m_resolver->resolve(S::take(m_resolver.get(), ownPtr.release())); | 96 m_resolver->resolve(S::take(m_resolver.get(), pass(result))); |
93 } | 97 } |
94 | 98 |
95 // Takes ownership of |error|. | 99 void onError(WebPassType<typename T::WebType> e) override |
96 void onError(typename T::WebType* error) override | |
97 { | 100 { |
98 OwnPtr<typename T::WebType> ownPtr = adoptPtr(error); | 101 typename T::WebType error(adopt(e)); |
99 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) | 102 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) |
100 return; | 103 return; |
101 m_resolver->reject(T::take(m_resolver.get(), ownPtr.release())); | 104 m_resolver->reject(T::take(m_resolver.get(), pass(error))); |
102 } | 105 } |
103 | 106 |
104 private: | 107 private: |
105 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 108 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; |
106 }; | 109 }; |
107 | 110 |
108 template<typename T> | 111 template<typename T> |
109 class CallbackPromiseAdapter<void, T> final : public WebCallbacks<void, typename T::WebType*> { | 112 class CallbackPromiseAdapter<void, T> final : public WebCallbacks<void, typename CallbackPromiseAdapterBase::WebPassType<typename T::WebType>>, public CallbackP romiseAdapterBase { |
110 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); | 113 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); |
111 public: | 114 public: |
112 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) | 115 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) |
113 : m_resolver(resolver) | 116 : m_resolver(resolver) |
114 { | 117 { |
115 ASSERT(m_resolver); | 118 ASSERT(m_resolver); |
116 } | 119 } |
117 ~CallbackPromiseAdapter() override { } | 120 ~CallbackPromiseAdapter() override { } |
118 | 121 |
119 void onSuccess() override | 122 void onSuccess() override |
120 { | 123 { |
121 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) | 124 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) |
122 return; | 125 return; |
123 m_resolver->resolve(); | 126 m_resolver->resolve(); |
124 } | 127 } |
125 | 128 |
126 // Takes ownership of |error|. | 129 void onError(WebPassType<typename T::WebType> e) override |
127 void onError(typename T::WebType* error) override | |
128 { | 130 { |
129 OwnPtr<typename T::WebType> ownPtr = adoptPtr(error); | 131 typename T::WebType error(adopt(e)); |
130 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) | 132 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) |
131 return; | 133 return; |
132 m_resolver->reject(T::take(m_resolver.get(), ownPtr.release())); | 134 m_resolver->reject(T::take(m_resolver.get(), pass(error))); |
133 } | 135 } |
134 | 136 |
135 private: | 137 private: |
136 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 138 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; |
137 }; | 139 }; |
138 | 140 |
139 template<typename S> | 141 template<typename S> |
140 class CallbackPromiseAdapter<S, void> final : public WebCallbacks<typename S::We bType*, void> { | 142 class CallbackPromiseAdapter<S, void> final : public WebCallbacks<typename Callb ackPromiseAdapterBase::WebPassType<typename S::WebType>, void>, public CallbackP romiseAdapterBase { |
141 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); | 143 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); |
142 public: | 144 public: |
143 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) | 145 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) |
144 : m_resolver(resolver) | 146 : m_resolver(resolver) |
145 { | 147 { |
146 ASSERT(m_resolver); | 148 ASSERT(m_resolver); |
147 } | 149 } |
148 ~CallbackPromiseAdapter() override { } | 150 ~CallbackPromiseAdapter() override { } |
149 | 151 |
150 // Takes ownership of |result|. | 152 void onSuccess(WebPassType<typename S::WebType> r) override |
151 void onSuccess(typename S::WebType* result) override | |
152 { | 153 { |
153 OwnPtr<typename S::WebType> ownPtr = adoptPtr(result); | 154 typename S::WebType result(adopt(r)); |
154 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) | 155 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) |
155 return; | 156 return; |
156 m_resolver->resolve(S::take(m_resolver.get(), ownPtr.release())); | 157 m_resolver->resolve(S::take(m_resolver.get(), pass(result))); |
157 } | 158 } |
158 | 159 |
159 void onError() override | 160 void onError() override |
160 { | 161 { |
161 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) | 162 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) |
162 return; | 163 return; |
163 m_resolver->reject(); | 164 m_resolver->reject(); |
164 } | 165 } |
165 | 166 |
166 private: | 167 private: |
167 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 168 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; |
168 }; | 169 }; |
169 | 170 |
170 template<typename T> | 171 template<typename T> |
171 class CallbackPromiseAdapter<bool, T> final : public WebCallbacks<bool*, typenam e T::WebType*> { | 172 class CallbackPromiseAdapter<bool, T> final : public WebCallbacks<bool*, typenam e CallbackPromiseAdapterBase::WebPassType<typename T::WebType>>, public Callback PromiseAdapterBase { |
172 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); | 173 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); |
173 public: | 174 public: |
174 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) | 175 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) |
175 : m_resolver(resolver) | 176 : m_resolver(resolver) |
176 { | 177 { |
177 ASSERT(m_resolver); | 178 ASSERT(m_resolver); |
178 } | 179 } |
179 ~CallbackPromiseAdapter() override { } | 180 ~CallbackPromiseAdapter() override { } |
180 | 181 |
181 // TODO(nhiroki): onSuccess should take ownership of a bool object for | 182 // TODO(nhiroki): onSuccess should take ownership of a bool object for |
182 // consistency. (http://crbug.com/493531) | 183 // consistency. (http://crbug.com/493531) |
183 void onSuccess(bool* result) override | 184 void onSuccess(bool* result) override |
184 { | 185 { |
185 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) | 186 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) |
186 return; | 187 return; |
187 m_resolver->resolve(*result); | 188 m_resolver->resolve(*result); |
188 } | 189 } |
189 | 190 |
190 // Takes ownership of |error|. | 191 void onError(WebPassType<typename T::WebType> e) override |
191 void onError(typename T::WebType* error) override | |
192 { | 192 { |
193 OwnPtr<typename T::WebType> ownPtr = adoptPtr(error); | 193 typename T::WebType error(adopt(e)); |
194 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) | 194 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) |
195 return; | 195 return; |
196 m_resolver->reject(T::take(m_resolver.get(), ownPtr.release())); | 196 m_resolver->reject(T::take(m_resolver.get(), pass(error))); |
197 } | 197 } |
198 | 198 |
199 private: | 199 private: |
200 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 200 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; |
201 }; | 201 }; |
202 | 202 |
203 template<> | 203 template<> |
204 class CallbackPromiseAdapter<void, void> final : public WebCallbacks<void, void> { | 204 class CallbackPromiseAdapter<void, void> final : public WebCallbacks<void, void> , public CallbackPromiseAdapterBase { |
205 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); | 205 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); |
206 public: | 206 public: |
207 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) | 207 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) |
208 : m_resolver(resolver) | 208 : m_resolver(resolver) |
209 { | 209 { |
210 ASSERT(m_resolver); | 210 ASSERT(m_resolver); |
211 } | 211 } |
212 ~CallbackPromiseAdapter() override { } | 212 ~CallbackPromiseAdapter() override { } |
213 | 213 |
214 void onSuccess() override | 214 void onSuccess() override |
215 { | 215 { |
216 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) | 216 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) |
217 return; | 217 return; |
218 m_resolver->resolve(); | 218 m_resolver->resolve(); |
219 } | 219 } |
220 | 220 |
221 void onError() override | 221 void onError() override |
222 { | 222 { |
223 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) | 223 if (!m_resolver->executionContext() || m_resolver->executionContext()->a ctiveDOMObjectsAreStopped()) |
224 return; | 224 return; |
225 m_resolver->reject(); | 225 m_resolver->reject(); |
226 } | 226 } |
227 | 227 |
228 private: | 228 private: |
229 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 229 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; |
230 }; | 230 }; |
231 | 231 |
232 template<> | 232 template<> |
233 class CallbackPromiseAdapter<bool, void> final : public WebCallbacks<bool*, void > { | 233 class CallbackPromiseAdapter<bool, void> final : public WebCallbacks<bool*, void >, public CallbackPromiseAdapterBase { |
234 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); | 234 WTF_MAKE_NONCOPYABLE(CallbackPromiseAdapter); |
235 public: | 235 public: |
236 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) | 236 explicit CallbackPromiseAdapter(PassRefPtrWillBeRawPtr<ScriptPromiseResolver > resolver) |
237 : m_resolver(resolver) | 237 : m_resolver(resolver) |
238 { | 238 { |
239 ASSERT(m_resolver); | 239 ASSERT(m_resolver); |
240 } | 240 } |
241 ~CallbackPromiseAdapter() override { } | 241 ~CallbackPromiseAdapter() override { } |
242 | 242 |
243 // TODO(nhiroki): onSuccess should take ownership of a bool object for | 243 // TODO(nhiroki): onSuccess should take ownership of a bool object for |
(...skipping 12 matching lines...) Expand all Loading... | |
256 m_resolver->reject(); | 256 m_resolver->reject(); |
257 } | 257 } |
258 | 258 |
259 private: | 259 private: |
260 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; | 260 RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver; |
261 }; | 261 }; |
262 | 262 |
263 } // namespace blink | 263 } // namespace blink |
264 | 264 |
265 #endif | 265 #endif |
OLD | NEW |