1 // Copyright (c) 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 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_ 6 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_ 7 8 #include <list> 9 #include <map> 10 #include <string> 11 #include <vector> 12 13 #include "base/basictypes.h" 14 #include "base/memory/ref_counted.h" 15 #include "content/browser/indexed_db/indexed_db.h" 16 #include "content/browser/indexed_db/indexed_db_callbacks.h" 17 #include "content/browser/indexed_db/indexed_db_metadata.h" 18 #include "content/browser/indexed_db/indexed_db_transaction_coordinator.h" 19 #include "content/browser/indexed_db/list_set.h" 20 21 namespace content { 22 23 class IndexedDBConnection; 24 class IndexedDBDatabaseCallbacks; 25 class IndexedDBBackingStore; 26 class IndexedDBFactory; 27 class IndexedDBKey; 28 class IndexedDBKeyPath; 29 class IndexedDBKeyRange; 30 class IndexedDBTransaction; 31 32 class CONTENT_EXPORT IndexedDBDatabase 33 : NON_EXPORTED_BASE(public base::RefCounted<IndexedDBDatabase>) { 34 public: 35 enum TaskType { 36 NORMAL_TASK = 0, 37 PREEMPTIVE_TASK 38 }; 39 40 enum PutMode { 41 ADD_OR_UPDATE, 42 ADD_ONLY, 43 CURSOR_UPDATE 44 }; 45 46 typedef std::vector<IndexedDBKey> IndexKeys; 47 // Identifier is pair of (origin identifier, database name). 48 typedef std::pair<std::string, base::string16> Identifier; 49 50 static const int64 kInvalidId = 0; 51 static const int64 kMinimumIndexId = 30; 52 53 static scoped_refptr<IndexedDBDatabase> Create( 54 const string16& name, 55 IndexedDBBackingStore* database, 56 IndexedDBFactory* factory, 57 const Identifier& unique_identifier); 58 scoped_refptr<IndexedDBBackingStore> BackingStore() const; 59 60 int64 id() const { return metadata_.id; } 61 const base::string16& name() const { return metadata_.name; } 62 63 void AddObjectStore(const IndexedDBObjectStoreMetadata& metadata, 64 int64 new_max_object_store_id); 65 void RemoveObjectStore(int64 object_store_id); 66 void AddIndex(int64 object_store_id, 67 const IndexedDBIndexMetadata& metadata, 68 int64 new_max_index_id); 69 void RemoveIndex(int64 object_store_id, int64 index_id); 70 71 void OpenConnection( 72 scoped_refptr<IndexedDBCallbacks> callbacks, 73 scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks, 74 int64 transaction_id, 75 int64 version); 76 void OpenConnection( 77 scoped_refptr<IndexedDBCallbacks> callbacks, 78 scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks, 79 int64 transaction_id, 80 int64 version, 81 WebKit::WebIDBCallbacks::DataLoss data_loss); 82 void DeleteDatabase(scoped_refptr<IndexedDBCallbacks> callbacks); 83 const IndexedDBDatabaseMetadata& metadata() const { return metadata_; } 84 85 void CreateObjectStore(int64 transaction_id, 86 int64 object_store_id, 87 const string16& name, 88 const IndexedDBKeyPath& key_path, 89 bool auto_increment); 90 void DeleteObjectStore(int64 transaction_id, int64 object_store_id); 91 void CreateTransaction(int64 transaction_id, 92 IndexedDBConnection* connection, 93 const std::vector<int64>& object_store_ids, 94 uint16 mode); 95 void Close(IndexedDBConnection* connection); 96 97 void Commit(int64 transaction_id); 98 void Abort(int64 transaction_id); 99 void Abort(int64 transaction_id, const IndexedDBDatabaseError& error); 100 101 void CreateIndex(int64 transaction_id, 102 int64 object_store_id, 103 int64 index_id, 104 const string16& name, 105 const IndexedDBKeyPath& key_path, 106 bool unique, 107 bool multi_entry); 108 void DeleteIndex(int64 transaction_id, int64 object_store_id, int64 index_id); 109 110 IndexedDBTransactionCoordinator& transaction_coordinator() { 111 return transaction_coordinator_; 112 } 113 const IndexedDBTransactionCoordinator& transaction_coordinator() const { 114 return transaction_coordinator_; 115 } 116 117 void TransactionStarted(IndexedDBTransaction* transaction); 118 void TransactionFinished(IndexedDBTransaction* transaction); 119 void TransactionFinishedAndCompleteFired(IndexedDBTransaction* transaction); 120 void TransactionFinishedAndAbortFired(IndexedDBTransaction* transaction); 121 122 void Get(int64 transaction_id, 123 int64 object_store_id, 124 int64 index_id, 125 scoped_ptr<IndexedDBKeyRange> key_range, 126 bool key_only, 127 scoped_refptr<IndexedDBCallbacks> callbacks); 128 void Put(int64 transaction_id, 129 int64 object_store_id, 130 std::string* value, 131 scoped_ptr<IndexedDBKey> key, 132 PutMode mode, 133 scoped_refptr<IndexedDBCallbacks> callbacks, 134 const std::vector<int64>& index_ids, 135 const std::vector<IndexKeys>& index_keys); 136 void SetIndexKeys(int64 transaction_id, 137 int64 object_store_id, 138 scoped_ptr<IndexedDBKey> primary_key, 139 const std::vector<int64>& index_ids, 140 const std::vector<IndexKeys>& index_keys); 141 void SetIndexesReady(int64 transaction_id, 142 int64 object_store_id, 143 const std::vector<int64>& index_ids); 144 void OpenCursor(int64 transaction_id, 145 int64 object_store_id, 146 int64 index_id, 147 scoped_ptr<IndexedDBKeyRange> key_range, 148 indexed_db::CursorDirection, 149 bool key_only, 150 TaskType task_type, 151 scoped_refptr<IndexedDBCallbacks> callbacks); 152 void Count(int64 transaction_id, 153 int64 object_store_id, 154 int64 index_id, 155 scoped_ptr<IndexedDBKeyRange> key_range, 156 scoped_refptr<IndexedDBCallbacks> callbacks); 157 void DeleteRange(int64 transaction_id, 158 int64 object_store_id, 159 scoped_ptr<IndexedDBKeyRange> key_range, 160 scoped_refptr<IndexedDBCallbacks> callbacks); 161 void Clear(int64 transaction_id, 162 int64 object_store_id, 163 scoped_refptr<IndexedDBCallbacks> callbacks); 164 165 // Number of connections that have progressed passed initial open call. 166 size_t ConnectionCount() const; 167 // Number of open calls that are blocked on other connections. 168 size_t PendingOpenCount() const; 169 // Number of pending upgrades (0 or 1). Also included in ConnectionCount(). 170 size_t PendingUpgradeCount() const; 171 // Number of running upgrades (0 or 1). Also included in ConnectionCount(). 172 size_t RunningUpgradeCount() const; 173 // Number of pending deletes, blocked on other connections. 174 size_t PendingDeleteCount() const; 175 176 private: 177 friend class base::RefCounted<IndexedDBDatabase>; 178 179 IndexedDBDatabase( 180 const string16& name, 181 IndexedDBBackingStore* database, 182 IndexedDBFactory* factory, 183 const Identifier& unique_identifier); 184 ~IndexedDBDatabase(); 185 186 bool IsOpenConnectionBlocked() const; 187 bool OpenInternal(); 188 void RunVersionChangeTransaction(scoped_refptr<IndexedDBCallbacks> callbacks, 189 scoped_ptr<IndexedDBConnection> connection, 190 int64 transaction_id, 191 int64 requested_version, 192 WebKit::WebIDBCallbacks::DataLoss data_loss); 193 void RunVersionChangeTransactionFinal( 194 scoped_refptr<IndexedDBCallbacks> callbacks, 195 scoped_ptr<IndexedDBConnection> connection, 196 int64 transaction_id, 197 int64 requested_version); 198 void RunVersionChangeTransactionFinal( 199 scoped_refptr<IndexedDBCallbacks> callbacks, 200 scoped_ptr<IndexedDBConnection> connection, 201 int64 transaction_id, 202 int64 requested_version, 203 WebKit::WebIDBCallbacks::DataLoss data_loss); 204 void ProcessPendingCalls(); 205 206 bool IsDeleteDatabaseBlocked() const; 207 void DeleteDatabaseFinal(scoped_refptr<IndexedDBCallbacks> callbacks); 208 209 IndexedDBTransaction* GetTransaction(int64 transaction_id) const; 210 211 bool ValidateObjectStoreId(int64 object_store_id) const; 212 bool ValidateObjectStoreIdAndIndexId(int64 object_store_id, 213 int64 index_id) const; 214 bool ValidateObjectStoreIdAndOptionalIndexId(int64 object_store_id, 215 int64 index_id) const; 216 bool ValidateObjectStoreIdAndNewIndexId(int64 object_store_id, 217 int64 index_id) const; 218 219 class VersionChangeOperation; 220 221 // When a "versionchange" transaction aborts, these restore the back-end 222 // object hierarchy. 223 class VersionChangeAbortOperation; 224 225 scoped_refptr<IndexedDBBackingStore> backing_store_; 226 IndexedDBDatabaseMetadata metadata_; 227 228 const Identifier identifier_; 229 // This might not need to be a scoped_refptr since the factory's lifetime is 230 // that of the page group, but it's better to be conservitive than sorry. 231 scoped_refptr<IndexedDBFactory> factory_; 232 233 IndexedDBTransactionCoordinator transaction_coordinator_; 234 IndexedDBTransaction* running_version_change_transaction_; 235 236 typedef std::map<int64, IndexedDBTransaction*> TransactionMap; 237 TransactionMap transactions_; 238 239 class PendingOpenCall; 240 typedef std::list<PendingOpenCall*> PendingOpenCallList; 241 PendingOpenCallList pending_open_calls_; 242 243 class PendingUpgradeCall; 244 scoped_ptr<PendingUpgradeCall> pending_run_version_change_transaction_call_; 245 class PendingSuccessCall; 246 scoped_ptr<PendingSuccessCall> pending_second_half_open_; 247 248 class PendingDeleteCall; 249 typedef std::list<PendingDeleteCall*> PendingDeleteCallList; 250 PendingDeleteCallList pending_delete_calls_; 251 252 typedef list_set<IndexedDBConnection*> ConnectionSet; 253 ConnectionSet connections_; 254 255 bool closing_connection_; 256 }; 257 258 } // namespace content 259 260 #endif // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_ 261