content/child/indexed_db/webidbdatabase_impl.cc

   1 // Copyright 2013 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/webidbdatabase_impl.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "content/child/indexed_db/indexed_db_dispatcher.h"
  11 #include "content/child/indexed_db/indexed_db_key_builders.h"
  12 #include "content/child/thread_safe_sender.h"
  13 #include "content/child/worker_task_runner.h"
  14 #include "content/common/indexed_db/indexed_db_messages.h"
  15 #include "third_party/WebKit/public/platform/WebBlobInfo.h"
  16 #include "third_party/WebKit/public/platform/WebString.h"
  17 #include "third_party/WebKit/public/platform/WebVector.h"
  18 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBKeyPath.h"
  19 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBMetadata.h"
  20
  21 using blink::WebBlobInfo;
  22 using blink::WebIDBCallbacks;
  23 using blink::WebIDBCursor;
  24 using blink::WebIDBDatabase;
  25 using blink::WebIDBDatabaseCallbacks;
  26 using blink::WebIDBMetadata;
  27 using blink::WebIDBKey;
  28 using blink::WebIDBKeyPath;
  29 using blink::WebIDBKeyRange;
  30 using blink::WebString;
  31 using blink::WebVector;
  32
  33 namespace content {
  34
  35 WebIDBDatabaseImpl::WebIDBDatabaseImpl(int32 ipc_database_id,
  36                                        int32 ipc_database_callbacks_id,
  37                                        ThreadSafeSender* thread_safe_sender)
  38     : ipc_database_id_(ipc_database_id),
  39       ipc_database_callbacks_id_(ipc_database_callbacks_id),
  40       thread_safe_sender_(thread_safe_sender) {}
  41
  42 WebIDBDatabaseImpl::~WebIDBDatabaseImpl() {
  43   // It's not possible for there to be pending callbacks that address this
  44   // object since inside WebKit, they hold a reference to the object which owns
  45   // this object. But, if that ever changed, then we'd need to invalidate
  46   // any such pointers.
  47   thread_safe_sender_->Send(
  48       new IndexedDBHostMsg_DatabaseDestroyed(ipc_database_id_));
  49   IndexedDBDispatcher* dispatcher =
  50       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
  51   dispatcher->DatabaseDestroyed(ipc_database_id_);
  52 }
  53
  54 void WebIDBDatabaseImpl::createObjectStore(long long transaction_id,
  55                                            long long object_store_id,
  56                                            const WebString& name,
  57                                            const WebIDBKeyPath& key_path,
  58                                            bool auto_increment) {
  59   IndexedDBHostMsg_DatabaseCreateObjectStore_Params params;
  60   params.ipc_database_id = ipc_database_id_;
  61   params.transaction_id = transaction_id;
  62   params.object_store_id = object_store_id;
  63   params.name = name;
  64   params.key_path = IndexedDBKeyPathBuilder::Build(key_path);
  65   params.auto_increment = auto_increment;
  66
  67   thread_safe_sender_->Send(
  68       new IndexedDBHostMsg_DatabaseCreateObjectStore(params));
  69 }
  70
  71 void WebIDBDatabaseImpl::deleteObjectStore(long long transaction_id,
  72                                            long long object_store_id) {
  73   thread_safe_sender_->Send(new IndexedDBHostMsg_DatabaseDeleteObjectStore(
  74       ipc_database_id_, transaction_id, object_store_id));
  75 }
  76
  77 void WebIDBDatabaseImpl::createTransaction(
  78     long long transaction_id,
  79     WebIDBDatabaseCallbacks* callbacks,
  80     const WebVector<long long>& object_store_ids,
  81     blink::WebIDBTransactionMode mode) {
  82   IndexedDBDispatcher* dispatcher =
  83       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
  84   dispatcher->RequestIDBDatabaseCreateTransaction(
  85       ipc_database_id_, transaction_id, callbacks, object_store_ids, mode);
  86 }
  87
  88 void WebIDBDatabaseImpl::close() {
  89   IndexedDBDispatcher* dispatcher =
  90       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
  91   dispatcher->RequestIDBDatabaseClose(ipc_database_id_,
  92                                       ipc_database_callbacks_id_);
  93 }
  94
  95 void WebIDBDatabaseImpl::versionChangeIgnored() {
  96   IndexedDBDispatcher* dispatcher =
  97       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
  98   dispatcher->NotifyIDBDatabaseVersionChangeIgnored(ipc_database_id_);
  99 }
 100
 101 void WebIDBDatabaseImpl::get(long long transaction_id,
 102                              long long object_store_id,
 103                              long long index_id,
 104                              const WebIDBKeyRange& key_range,
 105                              bool key_only,
 106                              WebIDBCallbacks* callbacks) {
 107   IndexedDBDispatcher* dispatcher =
 108       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
 109   dispatcher->RequestIDBDatabaseGet(ipc_database_id_,
 110                                     transaction_id,
 111                                     object_store_id,
 112                                     index_id,
 113                                     IndexedDBKeyRangeBuilder::Build(key_range),
 114                                     key_only,
 115                                     callbacks);
 116 }
 117
 118 void WebIDBDatabaseImpl::getAll(long long transaction_id,
 119                                 long long object_store_id,
 120                                 long long index_id,
 121                                 const WebIDBKeyRange& key_range,
 122                                 long long max_count,
 123                                 bool key_only,
 124                                 WebIDBCallbacks* callbacks) {
 125   IndexedDBDispatcher* dispatcher =
 126       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
 127   dispatcher->RequestIDBDatabaseGetAll(
 128       ipc_database_id_, transaction_id, object_store_id, index_id,
 129       IndexedDBKeyRangeBuilder::Build(key_range), key_only, max_count,
 130       callbacks);
 131 }
 132
 133 void WebIDBDatabaseImpl::put(long long transaction_id,
 134                              long long object_store_id,
 135                              const blink::WebData& value,
 136                              const blink::WebVector<WebBlobInfo>& web_blob_info,
 137                              const WebIDBKey& key,
 138                              blink::WebIDBPutMode put_mode,
 139                              WebIDBCallbacks* callbacks,
 140                              const WebVector<long long>& web_index_ids,
 141                              const WebVector<WebIndexKeys>& web_index_keys) {
 142   IndexedDBDispatcher* dispatcher =
 143       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
 144   dispatcher->RequestIDBDatabasePut(ipc_database_id_,
 145                                     transaction_id,
 146                                     object_store_id,
 147                                     value,
 148                                     web_blob_info,
 149                                     IndexedDBKeyBuilder::Build(key),
 150                                     put_mode,
 151                                     callbacks,
 152                                     web_index_ids,
 153                                     web_index_keys);
 154 }
 155
 156 void WebIDBDatabaseImpl::setIndexKeys(
 157     long long transaction_id,
 158     long long object_store_id,
 159     const WebIDBKey& primary_key,
 160     const WebVector<long long>& index_ids,
 161     const WebVector<WebIndexKeys>& index_keys) {
 162   IndexedDBHostMsg_DatabaseSetIndexKeys_Params params;
 163   params.ipc_database_id = ipc_database_id_;
 164   params.transaction_id = transaction_id;
 165   params.object_store_id = object_store_id;
 166   params.primary_key = IndexedDBKeyBuilder::Build(primary_key);
 167
 168   DCHECK_EQ(index_ids.size(), index_keys.size());
 169   params.index_keys.resize(index_ids.size());
 170   for (size_t i = 0, len = index_ids.size(); i < len; ++i) {
 171     params.index_keys[i].first = index_ids[i];
 172     params.index_keys[i].second.resize(index_keys[i].size());
 173     for (size_t j = 0; j < index_keys[i].size(); ++j) {
 174       params.index_keys[i].second[j] =
 175           IndexedDBKey(IndexedDBKeyBuilder::Build(index_keys[i][j]));
 176     }
 177   }
 178
 179   thread_safe_sender_->Send(new IndexedDBHostMsg_DatabaseSetIndexKeys(params));
 180 }
 181
 182 void WebIDBDatabaseImpl::setIndexesReady(
 183     long long transaction_id,
 184     long long object_store_id,
 185     const WebVector<long long>& web_index_ids) {
 186   std::vector<int64> index_ids(web_index_ids.data(),
 187                                web_index_ids.data() + web_index_ids.size());
 188   thread_safe_sender_->Send(new IndexedDBHostMsg_DatabaseSetIndexesReady(
 189       ipc_database_id_, transaction_id, object_store_id, index_ids));
 190 }
 191
 192 void WebIDBDatabaseImpl::openCursor(long long transaction_id,
 193                                     long long object_store_id,
 194                                     long long index_id,
 195                                     const WebIDBKeyRange& key_range,
 196                                     blink::WebIDBCursorDirection direction,
 197                                     bool key_only,
 198                                     blink::WebIDBTaskType task_type,
 199                                     WebIDBCallbacks* callbacks) {
 200   IndexedDBDispatcher* dispatcher =
 201       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
 202   dispatcher->RequestIDBDatabaseOpenCursor(
 203       ipc_database_id_,
 204       transaction_id,
 205       object_store_id,
 206       index_id,
 207       IndexedDBKeyRangeBuilder::Build(key_range),
 208       direction,
 209       key_only,
 210       task_type,
 211       callbacks);
 212 }
 213
 214 void WebIDBDatabaseImpl::count(long long transaction_id,
 215                                long long object_store_id,
 216                                long long index_id,
 217                                const WebIDBKeyRange& key_range,
 218                                WebIDBCallbacks* callbacks) {
 219   IndexedDBDispatcher* dispatcher =
 220       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
 221   dispatcher->RequestIDBDatabaseCount(
 222       ipc_database_id_,
 223       transaction_id,
 224       object_store_id,
 225       index_id,
 226       IndexedDBKeyRangeBuilder::Build(key_range),
 227       callbacks);
 228 }
 229
 230 void WebIDBDatabaseImpl::deleteRange(long long transaction_id,
 231                                      long long object_store_id,
 232                                      const WebIDBKeyRange& key_range,
 233                                      WebIDBCallbacks* callbacks) {
 234   IndexedDBDispatcher* dispatcher =
 235       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
 236   dispatcher->RequestIDBDatabaseDeleteRange(
 237       ipc_database_id_,
 238       transaction_id,
 239       object_store_id,
 240       IndexedDBKeyRangeBuilder::Build(key_range),
 241       callbacks);
 242 }
 243
 244 void WebIDBDatabaseImpl::clear(long long transaction_id,
 245                                long long object_store_id,
 246                                WebIDBCallbacks* callbacks) {
 247   IndexedDBDispatcher* dispatcher =
 248       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
 249   dispatcher->RequestIDBDatabaseClear(
 250       ipc_database_id_, transaction_id, object_store_id, callbacks);
 251 }
 252
 253 void WebIDBDatabaseImpl::createIndex(long long transaction_id,
 254                                      long long object_store_id,
 255                                      long long index_id,
 256                                      const WebString& name,
 257                                      const WebIDBKeyPath& key_path,
 258                                      bool unique,
 259                                      bool multi_entry) {
 260   IndexedDBHostMsg_DatabaseCreateIndex_Params params;
 261   params.ipc_database_id = ipc_database_id_;
 262   params.transaction_id = transaction_id;
 263   params.object_store_id = object_store_id;
 264   params.index_id = index_id;
 265   params.name = name;
 266   params.key_path = IndexedDBKeyPathBuilder::Build(key_path);
 267   params.unique = unique;
 268   params.multi_entry = multi_entry;
 269
 270   thread_safe_sender_->Send(new IndexedDBHostMsg_DatabaseCreateIndex(params));
 271 }
 272
 273 void WebIDBDatabaseImpl::deleteIndex(long long transaction_id,
 274                                      long long object_store_id,
 275                                      long long index_id) {
 276   thread_safe_sender_->Send(new IndexedDBHostMsg_DatabaseDeleteIndex(
 277       ipc_database_id_, transaction_id, object_store_id, index_id));
 278 }
 279
 280 void WebIDBDatabaseImpl::abort(long long transaction_id) {
 281   thread_safe_sender_->Send(
 282       new IndexedDBHostMsg_DatabaseAbort(ipc_database_id_, transaction_id));
 283 }
 284
 285 void WebIDBDatabaseImpl::commit(long long transaction_id) {
 286   thread_safe_sender_->Send(
 287       new IndexedDBHostMsg_DatabaseCommit(ipc_database_id_, transaction_id));
 288 }
 289
 290 void WebIDBDatabaseImpl::ackReceivedBlobs(const WebVector<WebString>& uuids) {
 291   DCHECK(uuids.size());
 292   std::vector<std::string> param(uuids.size());
 293   for (size_t i = 0; i < uuids.size(); ++i)
 294     param[i] = uuids[i].latin1().data();
 295   thread_safe_sender_->Send(new IndexedDBHostMsg_AckReceivedBlobs(param));
 296 }
 297
 298 }  // namespace content