OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "content/browser/indexed_db/indexed_db_callbacks.h" | 5 #include "content/browser/indexed_db/indexed_db_callbacks.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "content/browser/indexed_db/indexed_db_connection.h" | 10 #include "content/browser/indexed_db/indexed_db_connection.h" |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
60 ipc_thread_id_(ipc_thread_id), | 60 ipc_thread_id_(ipc_thread_id), |
61 ipc_cursor_id_(kNoCursor), | 61 ipc_cursor_id_(kNoCursor), |
62 host_transaction_id_(host_transaction_id), | 62 host_transaction_id_(host_transaction_id), |
63 origin_url_(origin_url), | 63 origin_url_(origin_url), |
64 ipc_database_id_(kNoDatabase), | 64 ipc_database_id_(kNoDatabase), |
65 ipc_database_callbacks_id_(ipc_database_callbacks_id) {} | 65 ipc_database_callbacks_id_(ipc_database_callbacks_id) {} |
66 | 66 |
67 IndexedDBCallbacks::~IndexedDBCallbacks() {} | 67 IndexedDBCallbacks::~IndexedDBCallbacks() {} |
68 | 68 |
69 void IndexedDBCallbacks::OnError(const IndexedDBDatabaseError& error) { | 69 void IndexedDBCallbacks::OnError(const IndexedDBDatabaseError& error) { |
70 DCHECK(dispatcher_host_); | 70 DCHECK(dispatcher_host_.get()); |
71 | 71 |
72 dispatcher_host_->Send(new IndexedDBMsg_CallbacksError( | 72 dispatcher_host_->Send(new IndexedDBMsg_CallbacksError( |
73 ipc_thread_id_, ipc_callbacks_id_, error.code(), error.message())); | 73 ipc_thread_id_, ipc_callbacks_id_, error.code(), error.message())); |
74 dispatcher_host_ = NULL; | 74 dispatcher_host_ = NULL; |
75 } | 75 } |
76 | 76 |
77 void IndexedDBCallbacks::OnSuccess(const std::vector<string16>& value) { | 77 void IndexedDBCallbacks::OnSuccess(const std::vector<string16>& value) { |
78 DCHECK(dispatcher_host_); | 78 DCHECK(dispatcher_host_.get()); |
79 | 79 |
80 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 80 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
81 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 81 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
82 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 82 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
83 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 83 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
84 | 84 |
85 std::vector<string16> list; | 85 std::vector<string16> list; |
86 for (unsigned i = 0; i < value.size(); ++i) | 86 for (unsigned i = 0; i < value.size(); ++i) |
87 list.push_back(value[i]); | 87 list.push_back(value[i]); |
88 | 88 |
89 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessStringList( | 89 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessStringList( |
90 ipc_thread_id_, ipc_callbacks_id_, list)); | 90 ipc_thread_id_, ipc_callbacks_id_, list)); |
91 dispatcher_host_ = NULL; | 91 dispatcher_host_ = NULL; |
92 } | 92 } |
93 | 93 |
94 void IndexedDBCallbacks::OnBlocked(int64 existing_version) { | 94 void IndexedDBCallbacks::OnBlocked(int64 existing_version) { |
95 DCHECK(dispatcher_host_); | 95 DCHECK(dispatcher_host_.get()); |
96 | 96 |
97 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 97 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
98 // No transaction/db callbacks for DeleteDatabase. | 98 // No transaction/db callbacks for DeleteDatabase. |
99 DCHECK_EQ(kNoTransaction == host_transaction_id_, | 99 DCHECK_EQ(kNoTransaction == host_transaction_id_, |
100 kNoDatabaseCallbacks == ipc_database_callbacks_id_); | 100 kNoDatabaseCallbacks == ipc_database_callbacks_id_); |
101 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 101 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
102 | 102 |
103 dispatcher_host_->Send(new IndexedDBMsg_CallbacksIntBlocked( | 103 dispatcher_host_->Send(new IndexedDBMsg_CallbacksIntBlocked( |
104 ipc_thread_id_, ipc_callbacks_id_, existing_version)); | 104 ipc_thread_id_, ipc_callbacks_id_, existing_version)); |
105 } | 105 } |
106 | 106 |
107 void IndexedDBCallbacks::OnUpgradeNeeded( | 107 void IndexedDBCallbacks::OnUpgradeNeeded( |
108 int64 old_version, | 108 int64 old_version, |
109 scoped_ptr<IndexedDBConnection> connection, | 109 scoped_ptr<IndexedDBConnection> connection, |
110 const IndexedDBDatabaseMetadata& metadata, | 110 const IndexedDBDatabaseMetadata& metadata, |
111 WebIDBCallbacks::DataLoss data_loss) { | 111 WebIDBCallbacks::DataLoss data_loss) { |
112 DCHECK(dispatcher_host_); | 112 DCHECK(dispatcher_host_.get()); |
113 | 113 |
114 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 114 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
115 DCHECK_NE(kNoTransaction, host_transaction_id_); | 115 DCHECK_NE(kNoTransaction, host_transaction_id_); |
116 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 116 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
117 DCHECK_NE(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 117 DCHECK_NE(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
118 | 118 |
119 dispatcher_host_->RegisterTransactionId(host_transaction_id_, origin_url_); | 119 dispatcher_host_->RegisterTransactionId(host_transaction_id_, origin_url_); |
120 int32 ipc_database_id = | 120 int32 ipc_database_id = |
121 dispatcher_host_->Add(connection.release(), ipc_thread_id_, origin_url_); | 121 dispatcher_host_->Add(connection.release(), ipc_thread_id_, origin_url_); |
122 ipc_database_id_ = ipc_database_id; | 122 ipc_database_id_ = ipc_database_id; |
123 IndexedDBMsg_CallbacksUpgradeNeeded_Params params; | 123 IndexedDBMsg_CallbacksUpgradeNeeded_Params params; |
124 params.ipc_thread_id = ipc_thread_id_; | 124 params.ipc_thread_id = ipc_thread_id_; |
125 params.ipc_callbacks_id = ipc_callbacks_id_; | 125 params.ipc_callbacks_id = ipc_callbacks_id_; |
126 params.ipc_database_id = ipc_database_id; | 126 params.ipc_database_id = ipc_database_id; |
127 params.ipc_database_callbacks_id = ipc_database_callbacks_id_; | 127 params.ipc_database_callbacks_id = ipc_database_callbacks_id_; |
128 params.old_version = old_version; | 128 params.old_version = old_version; |
129 params.idb_metadata = IndexedDBDispatcherHost::ConvertMetadata(metadata); | 129 params.idb_metadata = IndexedDBDispatcherHost::ConvertMetadata(metadata); |
130 params.data_loss = data_loss; | 130 params.data_loss = data_loss; |
131 dispatcher_host_->Send(new IndexedDBMsg_CallbacksUpgradeNeeded(params)); | 131 dispatcher_host_->Send(new IndexedDBMsg_CallbacksUpgradeNeeded(params)); |
132 } | 132 } |
133 | 133 |
134 void IndexedDBCallbacks::OnSuccess(scoped_ptr<IndexedDBConnection> connection, | 134 void IndexedDBCallbacks::OnSuccess(scoped_ptr<IndexedDBConnection> connection, |
135 const IndexedDBDatabaseMetadata& metadata) { | 135 const IndexedDBDatabaseMetadata& metadata) { |
136 DCHECK(dispatcher_host_); | 136 DCHECK(dispatcher_host_.get()); |
137 | 137 |
138 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 138 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
139 DCHECK_NE(kNoTransaction, host_transaction_id_); | 139 DCHECK_NE(kNoTransaction, host_transaction_id_); |
140 DCHECK_NE(ipc_database_id_ == kNoDatabase, !connection); | 140 DCHECK_NE(ipc_database_id_ == kNoDatabase, !connection); |
141 DCHECK_NE(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 141 DCHECK_NE(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
142 | 142 |
143 scoped_refptr<IndexedDBCallbacks> self(this); | 143 scoped_refptr<IndexedDBCallbacks> self(this); |
144 | 144 |
145 int32 ipc_object_id = ipc_database_id_; | 145 int32 ipc_object_id = ipc_database_id_; |
146 if (ipc_object_id == kNoDatabase) { | 146 if (ipc_object_id == kNoDatabase) { |
147 ipc_object_id = dispatcher_host_->Add( | 147 ipc_object_id = dispatcher_host_->Add( |
148 connection.release(), ipc_thread_id_, origin_url_); | 148 connection.release(), ipc_thread_id_, origin_url_); |
149 } | 149 } |
150 | 150 |
151 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBDatabase( | 151 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBDatabase( |
152 ipc_thread_id_, | 152 ipc_thread_id_, |
153 ipc_callbacks_id_, | 153 ipc_callbacks_id_, |
154 ipc_database_callbacks_id_, | 154 ipc_database_callbacks_id_, |
155 ipc_object_id, | 155 ipc_object_id, |
156 IndexedDBDispatcherHost::ConvertMetadata(metadata))); | 156 IndexedDBDispatcherHost::ConvertMetadata(metadata))); |
157 dispatcher_host_ = NULL; | 157 dispatcher_host_ = NULL; |
158 } | 158 } |
159 | 159 |
160 void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor, | 160 void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor, |
161 const IndexedDBKey& key, | 161 const IndexedDBKey& key, |
162 const IndexedDBKey& primary_key, | 162 const IndexedDBKey& primary_key, |
163 std::vector<char>* value) { | 163 std::vector<char>* value) { |
164 DCHECK(dispatcher_host_); | 164 DCHECK(dispatcher_host_.get()); |
165 | 165 |
166 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 166 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
167 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 167 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
168 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 168 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
169 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 169 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
170 | 170 |
171 int32 ipc_object_id = dispatcher_host_->Add(cursor); | 171 int32 ipc_object_id = dispatcher_host_->Add(cursor.get()); |
172 IndexedDBMsg_CallbacksSuccessIDBCursor_Params params; | 172 IndexedDBMsg_CallbacksSuccessIDBCursor_Params params; |
173 params.ipc_thread_id = ipc_thread_id_; | 173 params.ipc_thread_id = ipc_thread_id_; |
174 params.ipc_callbacks_id = ipc_callbacks_id_; | 174 params.ipc_callbacks_id = ipc_callbacks_id_; |
175 params.ipc_cursor_id = ipc_object_id; | 175 params.ipc_cursor_id = ipc_object_id; |
176 params.key = key; | 176 params.key = key; |
177 params.primary_key = primary_key; | 177 params.primary_key = primary_key; |
178 if (value && !value->empty()) | 178 if (value && !value->empty()) |
179 std::swap(params.value, *value); | 179 std::swap(params.value, *value); |
180 // TODO(alecflett): Avoid a copy here: the whole params object is | 180 // TODO(alecflett): Avoid a copy here: the whole params object is |
181 // being copied into the message. | 181 // being copied into the message. |
182 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBCursor(params)); | 182 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIDBCursor(params)); |
183 | 183 |
184 dispatcher_host_ = NULL; | 184 dispatcher_host_ = NULL; |
185 } | 185 } |
186 | 186 |
187 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key, | 187 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key, |
188 const IndexedDBKey& primary_key, | 188 const IndexedDBKey& primary_key, |
189 std::vector<char>* value) { | 189 std::vector<char>* value) { |
190 DCHECK(dispatcher_host_); | 190 DCHECK(dispatcher_host_.get()); |
191 | 191 |
192 DCHECK_NE(kNoCursor, ipc_cursor_id_); | 192 DCHECK_NE(kNoCursor, ipc_cursor_id_); |
193 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 193 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
194 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 194 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
195 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 195 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
196 | 196 |
197 IndexedDBCursor* idb_cursor = | 197 IndexedDBCursor* idb_cursor = |
198 dispatcher_host_->GetCursorFromId(ipc_cursor_id_); | 198 dispatcher_host_->GetCursorFromId(ipc_cursor_id_); |
199 | 199 |
200 DCHECK(idb_cursor); | 200 DCHECK(idb_cursor); |
(...skipping 14 matching lines...) Expand all Loading... |
215 dispatcher_host_ = NULL; | 215 dispatcher_host_ = NULL; |
216 } | 216 } |
217 | 217 |
218 void IndexedDBCallbacks::OnSuccessWithPrefetch( | 218 void IndexedDBCallbacks::OnSuccessWithPrefetch( |
219 const std::vector<IndexedDBKey>& keys, | 219 const std::vector<IndexedDBKey>& keys, |
220 const std::vector<IndexedDBKey>& primary_keys, | 220 const std::vector<IndexedDBKey>& primary_keys, |
221 const std::vector<std::vector<char> >& values) { | 221 const std::vector<std::vector<char> >& values) { |
222 DCHECK_EQ(keys.size(), primary_keys.size()); | 222 DCHECK_EQ(keys.size(), primary_keys.size()); |
223 DCHECK_EQ(keys.size(), values.size()); | 223 DCHECK_EQ(keys.size(), values.size()); |
224 | 224 |
225 DCHECK(dispatcher_host_); | 225 DCHECK(dispatcher_host_.get()); |
226 | 226 |
227 DCHECK_NE(kNoCursor, ipc_cursor_id_); | 227 DCHECK_NE(kNoCursor, ipc_cursor_id_); |
228 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 228 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
229 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 229 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
230 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 230 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
231 | 231 |
232 std::vector<IndexedDBKey> msgKeys; | 232 std::vector<IndexedDBKey> msgKeys; |
233 std::vector<IndexedDBKey> msgPrimaryKeys; | 233 std::vector<IndexedDBKey> msgPrimaryKeys; |
234 | 234 |
235 for (size_t i = 0; i < keys.size(); ++i) { | 235 for (size_t i = 0; i < keys.size(); ++i) { |
236 msgKeys.push_back(keys[i]); | 236 msgKeys.push_back(keys[i]); |
237 msgPrimaryKeys.push_back(primary_keys[i]); | 237 msgPrimaryKeys.push_back(primary_keys[i]); |
238 } | 238 } |
239 | 239 |
240 IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params params; | 240 IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params params; |
241 params.ipc_thread_id = ipc_thread_id_; | 241 params.ipc_thread_id = ipc_thread_id_; |
242 params.ipc_callbacks_id = ipc_callbacks_id_; | 242 params.ipc_callbacks_id = ipc_callbacks_id_; |
243 params.ipc_cursor_id = ipc_cursor_id_; | 243 params.ipc_cursor_id = ipc_cursor_id_; |
244 params.keys = msgKeys; | 244 params.keys = msgKeys; |
245 params.primary_keys = msgPrimaryKeys; | 245 params.primary_keys = msgPrimaryKeys; |
246 params.values = values; | 246 params.values = values; |
247 dispatcher_host_->Send( | 247 dispatcher_host_->Send( |
248 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(params)); | 248 new IndexedDBMsg_CallbacksSuccessCursorPrefetch(params)); |
249 dispatcher_host_ = NULL; | 249 dispatcher_host_ = NULL; |
250 } | 250 } |
251 | 251 |
252 void IndexedDBCallbacks::OnSuccess(std::vector<char>* value, | 252 void IndexedDBCallbacks::OnSuccess(std::vector<char>* value, |
253 const IndexedDBKey& key, | 253 const IndexedDBKey& key, |
254 const IndexedDBKeyPath& key_path) { | 254 const IndexedDBKeyPath& key_path) { |
255 DCHECK(dispatcher_host_); | 255 DCHECK(dispatcher_host_.get()); |
256 | 256 |
257 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 257 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
258 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 258 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
259 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 259 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
260 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 260 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
261 | 261 |
262 std::vector<char> value_copy; | 262 std::vector<char> value_copy; |
263 if (value && !value->empty()) | 263 if (value && !value->empty()) |
264 std::swap(value_copy, *value); | 264 std::swap(value_copy, *value); |
265 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValueWithKey( | 265 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValueWithKey( |
266 ipc_thread_id_, | 266 ipc_thread_id_, |
267 ipc_callbacks_id_, | 267 ipc_callbacks_id_, |
268 // TODO(alecflett): Avoid a copy here. | 268 // TODO(alecflett): Avoid a copy here. |
269 value_copy, | 269 value_copy, |
270 key, | 270 key, |
271 key_path)); | 271 key_path)); |
272 dispatcher_host_ = NULL; | 272 dispatcher_host_ = NULL; |
273 } | 273 } |
274 | 274 |
275 void IndexedDBCallbacks::OnSuccess(std::vector<char>* value) { | 275 void IndexedDBCallbacks::OnSuccess(std::vector<char>* value) { |
276 DCHECK(dispatcher_host_); | 276 DCHECK(dispatcher_host_.get()); |
277 | 277 |
278 DCHECK(kNoCursor == ipc_cursor_id_ || value == NULL); | 278 DCHECK(kNoCursor == ipc_cursor_id_ || value == NULL); |
279 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 279 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
280 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 280 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
281 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 281 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
282 | 282 |
283 std::vector<char> value_copy; | 283 std::vector<char> value_copy; |
284 if (value && !value->empty()) | 284 if (value && !value->empty()) |
285 std::swap(value_copy, *value); | 285 std::swap(value_copy, *value); |
286 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValue( | 286 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessValue( |
287 ipc_thread_id_, | 287 ipc_thread_id_, |
288 ipc_callbacks_id_, | 288 ipc_callbacks_id_, |
289 // TODO(alecflett): avoid a copy here. | 289 // TODO(alecflett): avoid a copy here. |
290 value_copy)); | 290 value_copy)); |
291 dispatcher_host_ = NULL; | 291 dispatcher_host_ = NULL; |
292 } | 292 } |
293 | 293 |
294 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) { | 294 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) { |
295 DCHECK(dispatcher_host_); | 295 DCHECK(dispatcher_host_.get()); |
296 | 296 |
297 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 297 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
298 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 298 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
299 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 299 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
300 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 300 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
301 | 301 |
302 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIndexedDBKey( | 302 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIndexedDBKey( |
303 ipc_thread_id_, ipc_callbacks_id_, value)); | 303 ipc_thread_id_, ipc_callbacks_id_, value)); |
304 dispatcher_host_ = NULL; | 304 dispatcher_host_ = NULL; |
305 } | 305 } |
306 | 306 |
307 void IndexedDBCallbacks::OnSuccess(int64 value) { | 307 void IndexedDBCallbacks::OnSuccess(int64 value) { |
308 DCHECK(dispatcher_host_); | 308 DCHECK(dispatcher_host_.get()); |
309 | 309 |
310 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 310 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
311 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 311 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
312 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 312 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
313 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 313 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
314 | 314 |
315 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessInteger( | 315 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessInteger( |
316 ipc_thread_id_, ipc_callbacks_id_, value)); | 316 ipc_thread_id_, ipc_callbacks_id_, value)); |
317 dispatcher_host_ = NULL; | 317 dispatcher_host_ = NULL; |
318 } | 318 } |
319 | 319 |
320 void IndexedDBCallbacks::OnSuccess() { | 320 void IndexedDBCallbacks::OnSuccess() { |
321 DCHECK(dispatcher_host_); | 321 DCHECK(dispatcher_host_.get()); |
322 | 322 |
323 DCHECK_EQ(kNoCursor, ipc_cursor_id_); | 323 DCHECK_EQ(kNoCursor, ipc_cursor_id_); |
324 DCHECK_EQ(kNoTransaction, host_transaction_id_); | 324 DCHECK_EQ(kNoTransaction, host_transaction_id_); |
325 DCHECK_EQ(kNoDatabase, ipc_database_id_); | 325 DCHECK_EQ(kNoDatabase, ipc_database_id_); |
326 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); | 326 DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_); |
327 | 327 |
328 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessUndefined( | 328 dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessUndefined( |
329 ipc_thread_id_, ipc_callbacks_id_)); | 329 ipc_thread_id_, ipc_callbacks_id_)); |
330 dispatcher_host_ = NULL; | 330 dispatcher_host_ = NULL; |
331 } | 331 } |
332 | 332 |
333 } // namespace content | 333 } // namespace content |
OLD | NEW |