OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/child/indexed_db/indexed_db_callbacks_impl.h" | |
6 | |
7 #include "content/child/indexed_db/indexed_db_dispatcher.h" | |
8 #include "content/child/indexed_db/indexed_db_key_builders.h" | |
9 #include "content/child/thread_safe_sender.h" | |
10 #include "content/common/indexed_db/indexed_db_constants.h" | |
11 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBCallbacks.h " | |
12 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseErr or.h" | |
13 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBMetadata.h" | |
14 | |
15 using blink::WebIDBCallbacks; | |
16 using blink::WebIDBDatabase; | |
17 using blink::WebIDBMetadata; | |
18 using blink::WebString; | |
19 using blink::WebVector; | |
20 using indexed_db::mojom::DatabaseMetadataPtr; | |
21 | |
22 namespace content { | |
23 | |
24 namespace { | |
25 | |
26 WebIDBMetadata ConvertMetadata(DatabaseMetadataPtr metadata) { | |
27 WebIDBMetadata web_metadata; | |
28 web_metadata.id = metadata->id; | |
29 web_metadata.name = metadata->name; | |
30 web_metadata.version = metadata->version; | |
31 web_metadata.maxObjectStoreId = metadata->max_object_store_id; | |
32 web_metadata.objectStores = | |
33 WebVector<WebIDBMetadata::ObjectStore>(metadata->object_stores.size()); | |
34 | |
35 for (size_t i = 0; i < metadata->object_stores.size(); ++i) { | |
36 const indexed_db::mojom::ObjectStoreMetadataPtr& store_metadata = | |
37 metadata->object_stores[i]; | |
38 WebIDBMetadata::ObjectStore& web_store_metadata = | |
39 web_metadata.objectStores[i]; | |
40 | |
41 web_store_metadata.id = store_metadata->id; | |
42 web_store_metadata.name = store_metadata->name; | |
43 web_store_metadata.keyPath = | |
44 WebIDBKeyPathBuilder::Build(store_metadata->key_path); | |
45 web_store_metadata.autoIncrement = store_metadata->auto_increment; | |
46 web_store_metadata.maxIndexId = store_metadata->max_index_id; | |
47 web_store_metadata.indexes = | |
48 WebVector<WebIDBMetadata::Index>(store_metadata->indexes.size()); | |
49 | |
50 for (size_t j = 0; j < store_metadata->indexes.size(); ++j) { | |
51 const indexed_db::mojom::IndexMetadataPtr& index_metadata = | |
52 store_metadata->indexes[j]; | |
53 WebIDBMetadata::Index& web_index_metadata = web_store_metadata.indexes[j]; | |
54 | |
55 web_index_metadata.id = index_metadata->id; | |
56 web_index_metadata.name = index_metadata->name; | |
57 web_index_metadata.keyPath = | |
58 WebIDBKeyPathBuilder::Build(index_metadata->key_path); | |
59 web_index_metadata.unique = index_metadata->unique; | |
60 web_index_metadata.multiEntry = index_metadata->multi_entry; | |
61 } | |
62 } | |
63 | |
64 return web_metadata; | |
65 } | |
66 | |
67 } // namespace | |
68 | |
69 class IndexedDBCallbacksImpl::InternalState { | |
70 public: | |
71 InternalState(blink::WebIDBCallbacks* callbacks, | |
72 scoped_refptr<ThreadSafeSender> thread_safe_sender); | |
73 ~InternalState(); | |
74 | |
75 void Blocked(int64_t existing_version); | |
76 void Error(int32_t code, const base::string16& message); | |
77 void SuccessDatabase(int32_t database_id, | |
78 indexed_db::mojom::DatabaseMetadataPtr metadata); | |
79 void SuccessInteger(int64_t value); | |
80 void SuccessStringList(const std::vector<base::string16>& value); | |
81 void UpgradeNeeded(int32_t database_id, | |
82 int64_t old_version, | |
83 blink::WebIDBDataLoss data_loss, | |
84 const std::string& data_loss_message, | |
85 indexed_db::mojom::DatabaseMetadataPtr metadata); | |
86 | |
87 private: | |
88 std::unique_ptr<WebIDBCallbacks> callbacks_; | |
89 scoped_refptr<ThreadSafeSender> thread_safe_sender_; | |
cmumford
2016/10/11 18:30:54
DISALLOW_COPY_AND_ASSIGN(InternalState);
Reilly Grant (use Gerrit)
2016/10/11 23:46:13
Done.
| |
90 }; | |
91 | |
92 IndexedDBCallbacksImpl::IndexedDBCallbacksImpl( | |
93 WebIDBCallbacks* callbacks, | |
94 scoped_refptr<ThreadSafeSender> thread_safe_sender) | |
95 : callback_runner_(base::ThreadTaskRunnerHandle::Get()) { | |
96 internal_state_ = new InternalState(callbacks, std::move(thread_safe_sender)); | |
cmumford
2016/10/11 18:30:54
Initialize |internal_state_| in initializer sectio
Reilly Grant (use Gerrit)
2016/10/11 23:46:13
Done.
| |
97 } | |
98 | |
99 IndexedDBCallbacksImpl::~IndexedDBCallbacksImpl() { | |
100 callback_runner_->DeleteSoon(FROM_HERE, internal_state_); | |
101 } | |
102 | |
103 void IndexedDBCallbacksImpl::Blocked(int64_t existing_version) { | |
104 callback_runner_->PostTask( | |
105 FROM_HERE, | |
106 base::Bind(&InternalState::Blocked, base::Unretained(internal_state_), | |
107 existing_version)); | |
108 } | |
109 | |
110 void IndexedDBCallbacksImpl::Error(int32_t code, | |
111 const base::string16& message) { | |
112 callback_runner_->PostTask( | |
113 FROM_HERE, base::Bind(&InternalState::Error, | |
114 base::Unretained(internal_state_), code, message)); | |
115 } | |
116 | |
117 void IndexedDBCallbacksImpl::SuccessDatabase(int32_t database_id, | |
118 DatabaseMetadataPtr metadata) { | |
119 callback_runner_->PostTask( | |
120 FROM_HERE, base::Bind(&InternalState::SuccessDatabase, | |
121 base::Unretained(internal_state_), database_id, | |
122 base::Passed(&metadata))); | |
123 } | |
124 | |
125 void IndexedDBCallbacksImpl::SuccessInteger(int64_t value) { | |
126 callback_runner_->PostTask( | |
127 FROM_HERE, base::Bind(&InternalState::SuccessInteger, | |
128 base::Unretained(internal_state_), value)); | |
129 } | |
130 | |
131 void IndexedDBCallbacksImpl::SuccessStringList( | |
132 const std::vector<base::string16>& value) { | |
133 callback_runner_->PostTask( | |
134 FROM_HERE, base::Bind(&InternalState::SuccessStringList, | |
135 base::Unretained(internal_state_), value)); | |
136 } | |
137 | |
138 void IndexedDBCallbacksImpl::UpgradeNeeded(int32_t database_id, | |
139 int64_t old_version, | |
140 blink::WebIDBDataLoss data_loss, | |
141 const std::string& data_loss_message, | |
142 DatabaseMetadataPtr metadata) { | |
143 callback_runner_->PostTask( | |
144 FROM_HERE, | |
145 base::Bind(&InternalState::UpgradeNeeded, | |
146 base::Unretained(internal_state_), database_id, old_version, | |
147 data_loss, data_loss_message, base::Passed(&metadata))); | |
148 } | |
149 | |
150 IndexedDBCallbacksImpl::InternalState::InternalState( | |
151 blink::WebIDBCallbacks* callbacks, | |
152 scoped_refptr<ThreadSafeSender> thread_safe_sender) | |
153 : callbacks_(callbacks), | |
154 thread_safe_sender_(std::move(thread_safe_sender)) {} | |
155 | |
156 IndexedDBCallbacksImpl::InternalState::~InternalState() {} | |
157 | |
158 void IndexedDBCallbacksImpl::InternalState::Blocked(int64_t existing_version) { | |
159 callbacks_->onBlocked(existing_version); | |
160 } | |
161 | |
162 void IndexedDBCallbacksImpl::InternalState::Error( | |
163 int32_t code, | |
164 const base::string16& message) { | |
165 callbacks_->onError(blink::WebIDBDatabaseError(code, message)); | |
166 } | |
167 | |
168 void IndexedDBCallbacksImpl::InternalState::SuccessDatabase( | |
169 int32_t database_id, | |
170 DatabaseMetadataPtr metadata) { | |
171 WebIDBDatabase* database = nullptr; | |
172 if (database_id != kNoDatabase) { | |
173 IndexedDBDispatcher* dispatcher = | |
174 IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get()); | |
175 database = dispatcher->RegisterDatabase(database_id); | |
176 } | |
177 callbacks_->onSuccess(database, ConvertMetadata(std::move(metadata))); | |
178 } | |
179 | |
180 void IndexedDBCallbacksImpl::InternalState::SuccessInteger(int64_t value) { | |
181 callbacks_->onSuccess(value); | |
182 } | |
183 | |
184 void IndexedDBCallbacksImpl::InternalState::SuccessStringList( | |
185 const std::vector<base::string16>& value) { | |
186 callbacks_->onSuccess(WebVector<WebString>(value)); | |
187 } | |
188 | |
189 void IndexedDBCallbacksImpl::InternalState::UpgradeNeeded( | |
190 int32_t database_id, | |
191 int64_t old_version, | |
192 blink::WebIDBDataLoss data_loss, | |
193 const std::string& data_loss_message, | |
194 DatabaseMetadataPtr metadata) { | |
195 IndexedDBDispatcher* dispatcher = | |
196 IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get()); | |
197 WebIDBDatabase* database = dispatcher->RegisterDatabase(database_id); | |
198 callbacks_->onUpgradeNeeded(old_version, database, | |
199 ConvertMetadata(std::move(metadata)), data_loss, | |
200 WebString::fromUTF8(data_loss_message)); | |
201 } | |
202 | |
203 } // namespace content | |
OLD | NEW |