OLD | NEW |
---|---|
(Empty) | |
1 | |
jsbell
2017/05/25 18:49:42
Nit: remove blank line
pwnall
2017/05/25 20:01:10
Done.
Thank you for noticing!
| |
2 // Copyright 2017 The Chromium Authors. All rights reserved. | |
3 // Use of this source code is governed by a BSD-style license that can be | |
4 // found in the LICENSE file. | |
5 | |
6 #include "modules/indexeddb/IDBRequestQueueItem.h" | |
7 | |
8 #include "core/dom/DOMException.h" | |
9 #include "modules/indexeddb/IDBKey.h" | |
10 #include "modules/indexeddb/IDBRequest.h" | |
11 #include "modules/indexeddb/IDBRequestLoader.h" | |
12 #include "modules/indexeddb/IDBValue.h" | |
13 #include "platform/wtf/PtrUtil.h" | |
14 #include "public/platform/modules/indexeddb/WebIDBCursor.h" | |
15 | |
16 namespace blink { | |
17 | |
18 IDBRequestQueueItem::IDBRequestQueueItem( | |
19 IDBRequest* request, | |
20 DOMException* error, | |
21 std::unique_ptr<WTF::Closure> on_result_load_complete) | |
22 : request_(request), | |
23 error_(error), | |
24 on_result_load_complete_(std::move(on_result_load_complete)), | |
25 response_type_(kError), | |
26 ready_(true) { | |
27 DCHECK(on_result_load_complete_); | |
28 DCHECK_EQ(request->queue_item_, nullptr); | |
29 request_->queue_item_ = this; | |
30 } | |
31 | |
32 IDBRequestQueueItem::IDBRequestQueueItem( | |
33 IDBRequest* request, | |
34 int64_t value, | |
35 std::unique_ptr<WTF::Closure> on_result_load_complete) | |
36 : request_(request), | |
37 on_result_load_complete_(std::move(on_result_load_complete)), | |
38 int64_value_(value), | |
39 response_type_(kNumber), | |
40 ready_(true) { | |
41 DCHECK(on_result_load_complete_); | |
42 DCHECK_EQ(request->queue_item_, nullptr); | |
43 request_->queue_item_ = this; | |
44 } | |
45 | |
46 IDBRequestQueueItem::IDBRequestQueueItem( | |
47 IDBRequest* request, | |
48 std::unique_ptr<WTF::Closure> on_result_load_complete) | |
49 : request_(request), | |
50 on_result_load_complete_(std::move(on_result_load_complete)), | |
51 response_type_(kVoid), | |
52 ready_(true) { | |
53 DCHECK(on_result_load_complete_); | |
54 DCHECK_EQ(request->queue_item_, nullptr); | |
55 request_->queue_item_ = this; | |
56 } | |
57 | |
58 IDBRequestQueueItem::IDBRequestQueueItem( | |
59 IDBRequest* request, | |
60 IDBKey* key, | |
61 std::unique_ptr<WTF::Closure> on_result_load_complete) | |
62 : request_(request), | |
63 key_(key), | |
64 on_result_load_complete_(std::move(on_result_load_complete)), | |
65 response_type_(kKey), | |
66 ready_(true) { | |
67 DCHECK(on_result_load_complete_); | |
68 DCHECK_EQ(request->queue_item_, nullptr); | |
69 request_->queue_item_ = this; | |
70 } | |
71 | |
72 IDBRequestQueueItem::IDBRequestQueueItem( | |
73 IDBRequest* request, | |
74 PassRefPtr<IDBValue> value, | |
75 bool attach_loader, | |
76 std::unique_ptr<WTF::Closure> on_result_load_complete) | |
77 : request_(request), | |
78 on_result_load_complete_(std::move(on_result_load_complete)), | |
79 response_type_(kValue), | |
80 ready_(!attach_loader) { | |
81 DCHECK(on_result_load_complete_); | |
82 DCHECK_EQ(request->queue_item_, nullptr); | |
83 request_->queue_item_ = this; | |
84 values_.push_back(std::move(value)); | |
85 if (attach_loader) | |
86 loader_ = WTF::MakeUnique<IDBRequestLoader>(this, &values_); | |
87 } | |
88 | |
89 IDBRequestQueueItem::IDBRequestQueueItem( | |
90 IDBRequest* request, | |
91 const Vector<RefPtr<IDBValue>>& values, | |
92 bool attach_loader, | |
93 std::unique_ptr<WTF::Closure> on_result_load_complete) | |
94 : request_(request), | |
95 values_(values), | |
96 on_result_load_complete_(std::move(on_result_load_complete)), | |
97 response_type_(kValueArray), | |
98 ready_(!attach_loader) { | |
99 DCHECK(on_result_load_complete_); | |
100 DCHECK_EQ(request->queue_item_, nullptr); | |
101 request_->queue_item_ = this; | |
102 if (attach_loader) | |
103 loader_ = WTF::MakeUnique<IDBRequestLoader>(this, &values_); | |
104 } | |
105 | |
106 IDBRequestQueueItem::IDBRequestQueueItem( | |
107 IDBRequest* request, | |
108 IDBKey* key, | |
109 IDBKey* primary_key, | |
110 PassRefPtr<IDBValue> value, | |
111 bool attach_loader, | |
112 std::unique_ptr<WTF::Closure> on_result_load_complete) | |
113 : request_(request), | |
114 key_(key), | |
115 primary_key_(primary_key), | |
116 on_result_load_complete_(std::move(on_result_load_complete)), | |
117 response_type_(kKeyPrimaryKeyValue), | |
118 ready_(!attach_loader) { | |
119 DCHECK(on_result_load_complete_); | |
120 DCHECK_EQ(request->queue_item_, nullptr); | |
121 request_->queue_item_ = this; | |
122 values_.push_back(std::move(value)); | |
123 if (attach_loader) | |
124 loader_ = WTF::MakeUnique<IDBRequestLoader>(this, &values_); | |
125 } | |
126 | |
127 IDBRequestQueueItem::IDBRequestQueueItem( | |
128 IDBRequest* request, | |
129 std::unique_ptr<WebIDBCursor> cursor, | |
130 IDBKey* key, | |
131 IDBKey* primary_key, | |
132 PassRefPtr<IDBValue> value, | |
133 bool attach_loader, | |
134 std::unique_ptr<WTF::Closure> on_result_load_complete) | |
135 : request_(request), | |
136 key_(key), | |
137 primary_key_(primary_key), | |
138 cursor_(std::move(cursor)), | |
139 on_result_load_complete_(std::move(on_result_load_complete)), | |
140 response_type_(kCursorKeyPrimaryKeyValue), | |
141 ready_(!attach_loader) { | |
142 DCHECK(on_result_load_complete_); | |
143 DCHECK_EQ(request->queue_item_, nullptr); | |
144 request_->queue_item_ = this; | |
145 values_.push_back(std::move(value)); | |
146 if (attach_loader) | |
147 loader_ = WTF::MakeUnique<IDBRequestLoader>(this, &values_); | |
148 } | |
149 | |
150 IDBRequestQueueItem::~IDBRequestQueueItem() { | |
151 #if DCHECK_IS_ON() | |
152 DCHECK(ready_); | |
153 DCHECK(callback_fired_); | |
154 #endif // DCHECK_IS_ON() | |
155 } | |
156 | |
157 void IDBRequestQueueItem::OnResultLoadComplete() { | |
158 DCHECK(!ready_); | |
159 ready_ = true; | |
160 | |
161 DCHECK(on_result_load_complete_); | |
162 (*on_result_load_complete_)(); | |
163 } | |
164 | |
165 void IDBRequestQueueItem::OnResultLoadComplete(DOMException* error) { | |
166 DCHECK(!ready_); | |
167 DCHECK(response_type_ != kError); | |
168 | |
169 response_type_ = kError; | |
170 error_ = error; | |
171 | |
172 // This is not necessary, but releases non-trivial amounts of memory early. | |
173 values_.clear(); | |
174 | |
175 OnResultLoadComplete(); | |
176 } | |
177 | |
178 void IDBRequestQueueItem::StartLoading() { | |
179 if (request_->request_aborted_) { | |
180 // The backing store can get the result back to the request after it's been | |
181 // aborted due to a transaction abort. In this case, we can't rely on | |
182 // IDBRequest::Abort() to call CancelLoading(). | |
183 CancelLoading(); | |
184 return; | |
185 } | |
186 | |
187 if (loader_) { | |
188 DCHECK(!ready_); | |
189 loader_->Start(); | |
190 } | |
191 } | |
192 | |
193 void IDBRequestQueueItem::CancelLoading() { | |
194 if (ready_) | |
195 return; | |
196 | |
197 if (loader_) { | |
198 loader_->Cancel(); | |
199 loader_ = nullptr; | |
200 } | |
201 | |
202 // Mark this item as ready so the transaction's result queue can be drained. | |
203 response_type_ = kCanceled; | |
204 values_.clear(); | |
205 OnResultLoadComplete(); | |
206 } | |
207 | |
208 void IDBRequestQueueItem::EnqueueResponse() { | |
209 DCHECK(ready_); | |
210 #if DCHECK_IS_ON() | |
211 DCHECK(!callback_fired_); | |
212 callback_fired_ = true; | |
213 #endif // DCHECK_IS_ON() | |
214 DCHECK_EQ(request_->queue_item_, this); | |
215 request_->queue_item_ = nullptr; | |
216 | |
217 switch (response_type_) { | |
218 case kCanceled: | |
219 DCHECK_EQ(values_.size(), 0U); | |
220 break; | |
221 | |
222 case kCursorKeyPrimaryKeyValue: | |
223 DCHECK_EQ(values_.size(), 1U); | |
224 request_->EnqueueResponse(std::move(cursor_), key_, primary_key_, | |
225 std::move(values_.front())); | |
226 break; | |
227 | |
228 case kError: | |
229 DCHECK(error_); | |
230 request_->EnqueueResponse(error_); | |
231 break; | |
232 | |
233 case kKeyPrimaryKeyValue: | |
234 DCHECK_EQ(values_.size(), 1U); | |
235 request_->EnqueueResponse(key_, primary_key_, std::move(values_.front())); | |
236 break; | |
237 | |
238 case kKey: | |
239 DCHECK_EQ(values_.size(), 0U); | |
240 request_->EnqueueResponse(key_); | |
241 break; | |
242 | |
243 case kNumber: | |
244 DCHECK_EQ(values_.size(), 0U); | |
245 request_->EnqueueResponse(int64_value_); | |
246 break; | |
247 | |
248 case kValue: | |
249 DCHECK_EQ(values_.size(), 1U); | |
250 request_->EnqueueResponse(std::move(values_.front())); | |
251 break; | |
252 | |
253 case kValueArray: | |
254 request_->EnqueueResponse(values_); | |
255 break; | |
256 | |
257 case kVoid: | |
258 DCHECK_EQ(values_.size(), 0U); | |
259 request_->EnqueueResponse(); | |
260 break; | |
261 } | |
262 } | |
263 | |
264 } // namespace blink | |
OLD | NEW |