| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "webkit/browser/dom_storage/dom_storage_database.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/file_util.h" | |
| 9 #include "base/logging.h" | |
| 10 #include "sql/statement.h" | |
| 11 #include "sql/transaction.h" | |
| 12 #include "third_party/sqlite/sqlite3.h" | |
| 13 | |
| 14 namespace { | |
| 15 | |
| 16 const base::FilePath::CharType kJournal[] = FILE_PATH_LITERAL("-journal"); | |
| 17 | |
| 18 } // anon namespace | |
| 19 | |
| 20 namespace dom_storage { | |
| 21 | |
| 22 // static | |
| 23 base::FilePath DomStorageDatabase::GetJournalFilePath( | |
| 24 const base::FilePath& database_path) { | |
| 25 base::FilePath::StringType journal_file_name = | |
| 26 database_path.BaseName().value() + kJournal; | |
| 27 return database_path.DirName().Append(journal_file_name); | |
| 28 } | |
| 29 | |
| 30 DomStorageDatabase::DomStorageDatabase(const base::FilePath& file_path) | |
| 31 : file_path_(file_path) { | |
| 32 // Note: in normal use we should never get an empty backing path here. | |
| 33 // However, the unit test for this class can contruct an instance | |
| 34 // with an empty path. | |
| 35 Init(); | |
| 36 } | |
| 37 | |
| 38 DomStorageDatabase::DomStorageDatabase() { | |
| 39 Init(); | |
| 40 } | |
| 41 | |
| 42 void DomStorageDatabase::Init() { | |
| 43 failed_to_open_ = false; | |
| 44 tried_to_recreate_ = false; | |
| 45 known_to_be_empty_ = false; | |
| 46 } | |
| 47 | |
| 48 DomStorageDatabase::~DomStorageDatabase() { | |
| 49 if (known_to_be_empty_ && !file_path_.empty()) { | |
| 50 // Delete the db and any lingering journal file from disk. | |
| 51 Close(); | |
| 52 sql::Connection::Delete(file_path_); | |
| 53 } | |
| 54 } | |
| 55 | |
| 56 void DomStorageDatabase::ReadAllValues(ValuesMap* result) { | |
| 57 if (!LazyOpen(false)) | |
| 58 return; | |
| 59 | |
| 60 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, | |
| 61 "SELECT * from ItemTable")); | |
| 62 DCHECK(statement.is_valid()); | |
| 63 | |
| 64 while (statement.Step()) { | |
| 65 base::string16 key = statement.ColumnString16(0); | |
| 66 base::string16 value; | |
| 67 statement.ColumnBlobAsString16(1, &value); | |
| 68 (*result)[key] = base::NullableString16(value, false); | |
| 69 } | |
| 70 known_to_be_empty_ = result->empty(); | |
| 71 } | |
| 72 | |
| 73 bool DomStorageDatabase::CommitChanges(bool clear_all_first, | |
| 74 const ValuesMap& changes) { | |
| 75 if (!LazyOpen(!changes.empty())) { | |
| 76 // If we're being asked to commit changes that will result in an | |
| 77 // empty database, we return true if the database file doesn't exist. | |
| 78 return clear_all_first && changes.empty() && | |
| 79 !base::PathExists(file_path_); | |
| 80 } | |
| 81 | |
| 82 bool old_known_to_be_empty = known_to_be_empty_; | |
| 83 sql::Transaction transaction(db_.get()); | |
| 84 if (!transaction.Begin()) | |
| 85 return false; | |
| 86 | |
| 87 if (clear_all_first) { | |
| 88 if (!db_->Execute("DELETE FROM ItemTable")) | |
| 89 return false; | |
| 90 known_to_be_empty_ = true; | |
| 91 } | |
| 92 | |
| 93 bool did_delete = false; | |
| 94 bool did_insert = false; | |
| 95 ValuesMap::const_iterator it = changes.begin(); | |
| 96 for(; it != changes.end(); ++it) { | |
| 97 sql::Statement statement; | |
| 98 base::string16 key = it->first; | |
| 99 base::NullableString16 value = it->second; | |
| 100 if (value.is_null()) { | |
| 101 statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, | |
| 102 "DELETE FROM ItemTable WHERE key=?")); | |
| 103 statement.BindString16(0, key); | |
| 104 did_delete = true; | |
| 105 } else { | |
| 106 statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, | |
| 107 "INSERT INTO ItemTable VALUES (?,?)")); | |
| 108 statement.BindString16(0, key); | |
| 109 statement.BindBlob(1, value.string().data(), | |
| 110 value.string().length() * sizeof(char16)); | |
| 111 known_to_be_empty_ = false; | |
| 112 did_insert = true; | |
| 113 } | |
| 114 DCHECK(statement.is_valid()); | |
| 115 statement.Run(); | |
| 116 } | |
| 117 | |
| 118 if (!known_to_be_empty_ && did_delete && !did_insert) { | |
| 119 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, | |
| 120 "SELECT count(key) from ItemTable")); | |
| 121 if (statement.Step()) | |
| 122 known_to_be_empty_ = statement.ColumnInt(0) == 0; | |
| 123 } | |
| 124 | |
| 125 bool success = transaction.Commit(); | |
| 126 if (!success) | |
| 127 known_to_be_empty_ = old_known_to_be_empty; | |
| 128 return success; | |
| 129 } | |
| 130 | |
| 131 bool DomStorageDatabase::LazyOpen(bool create_if_needed) { | |
| 132 if (failed_to_open_) { | |
| 133 // Don't try to open a database that we know has failed | |
| 134 // already. | |
| 135 return false; | |
| 136 } | |
| 137 | |
| 138 if (IsOpen()) | |
| 139 return true; | |
| 140 | |
| 141 bool database_exists = base::PathExists(file_path_); | |
| 142 | |
| 143 if (!database_exists && !create_if_needed) { | |
| 144 // If the file doesn't exist already and we haven't been asked to create | |
| 145 // a file on disk, then we don't bother opening the database. This means | |
| 146 // we wait until we absolutely need to put something onto disk before we | |
| 147 // do so. | |
| 148 return false; | |
| 149 } | |
| 150 | |
| 151 db_.reset(new sql::Connection()); | |
| 152 db_->set_histogram_tag("DomStorageDatabase"); | |
| 153 | |
| 154 if (file_path_.empty()) { | |
| 155 // This code path should only be triggered by unit tests. | |
| 156 if (!db_->OpenInMemory()) { | |
| 157 NOTREACHED() << "Unable to open DOM storage database in memory."; | |
| 158 failed_to_open_ = true; | |
| 159 return false; | |
| 160 } | |
| 161 } else { | |
| 162 if (!db_->Open(file_path_)) { | |
| 163 LOG(ERROR) << "Unable to open DOM storage database at " | |
| 164 << file_path_.value() | |
| 165 << " error: " << db_->GetErrorMessage(); | |
| 166 if (database_exists && !tried_to_recreate_) | |
| 167 return DeleteFileAndRecreate(); | |
| 168 failed_to_open_ = true; | |
| 169 return false; | |
| 170 } | |
| 171 } | |
| 172 | |
| 173 // sql::Connection uses UTF-8 encoding, but WebCore style databases use | |
| 174 // UTF-16, so ensure we match. | |
| 175 ignore_result(db_->Execute("PRAGMA encoding=\"UTF-16\"")); | |
| 176 | |
| 177 if (!database_exists) { | |
| 178 // This is a new database, create the table and we're done! | |
| 179 if (CreateTableV2()) | |
| 180 return true; | |
| 181 } else { | |
| 182 // The database exists already - check if we need to upgrade | |
| 183 // and whether it's usable (i.e. not corrupted). | |
| 184 SchemaVersion current_version = DetectSchemaVersion(); | |
| 185 | |
| 186 if (current_version == V2) { | |
| 187 return true; | |
| 188 } else if (current_version == V1) { | |
| 189 if (UpgradeVersion1To2()) | |
| 190 return true; | |
| 191 } | |
| 192 } | |
| 193 | |
| 194 // This is the exceptional case - to try and recover we'll attempt | |
| 195 // to delete the file and start again. | |
| 196 Close(); | |
| 197 return DeleteFileAndRecreate(); | |
| 198 } | |
| 199 | |
| 200 DomStorageDatabase::SchemaVersion DomStorageDatabase::DetectSchemaVersion() { | |
| 201 DCHECK(IsOpen()); | |
| 202 | |
| 203 // Connection::Open() may succeed even if the file we try and open is not a | |
| 204 // database, however in the case that the database is corrupted to the point | |
| 205 // that SQLite doesn't actually think it's a database, | |
| 206 // sql::Connection::GetCachedStatement will DCHECK when we later try and | |
| 207 // run statements. So we run a query here that will not DCHECK but fail | |
| 208 // on an invalid database to verify that what we've opened is usable. | |
| 209 if (db_->ExecuteAndReturnErrorCode("PRAGMA auto_vacuum") != SQLITE_OK) | |
| 210 return INVALID; | |
| 211 | |
| 212 // Look at the current schema - if it doesn't look right, assume corrupt. | |
| 213 if (!db_->DoesTableExist("ItemTable") || | |
| 214 !db_->DoesColumnExist("ItemTable", "key") || | |
| 215 !db_->DoesColumnExist("ItemTable", "value")) | |
| 216 return INVALID; | |
| 217 | |
| 218 // We must use a unique statement here as we aren't going to step it. | |
| 219 sql::Statement statement( | |
| 220 db_->GetUniqueStatement("SELECT key,value from ItemTable LIMIT 1")); | |
| 221 if (statement.DeclaredColumnType(0) != sql::COLUMN_TYPE_TEXT) | |
| 222 return INVALID; | |
| 223 | |
| 224 switch (statement.DeclaredColumnType(1)) { | |
| 225 case sql::COLUMN_TYPE_BLOB: | |
| 226 return V2; | |
| 227 case sql::COLUMN_TYPE_TEXT: | |
| 228 return V1; | |
| 229 default: | |
| 230 return INVALID; | |
| 231 } | |
| 232 NOTREACHED(); | |
| 233 return INVALID; | |
| 234 } | |
| 235 | |
| 236 bool DomStorageDatabase::CreateTableV2() { | |
| 237 DCHECK(IsOpen()); | |
| 238 | |
| 239 return db_->Execute( | |
| 240 "CREATE TABLE ItemTable (" | |
| 241 "key TEXT UNIQUE ON CONFLICT REPLACE, " | |
| 242 "value BLOB NOT NULL ON CONFLICT FAIL)"); | |
| 243 } | |
| 244 | |
| 245 bool DomStorageDatabase::DeleteFileAndRecreate() { | |
| 246 DCHECK(!IsOpen()); | |
| 247 DCHECK(base::PathExists(file_path_)); | |
| 248 | |
| 249 // We should only try and do this once. | |
| 250 if (tried_to_recreate_) | |
| 251 return false; | |
| 252 | |
| 253 tried_to_recreate_ = true; | |
| 254 | |
| 255 // If it's not a directory and we can delete the file, try and open it again. | |
| 256 if (!base::DirectoryExists(file_path_) && | |
| 257 sql::Connection::Delete(file_path_)) { | |
| 258 return LazyOpen(true); | |
| 259 } | |
| 260 | |
| 261 failed_to_open_ = true; | |
| 262 return false; | |
| 263 } | |
| 264 | |
| 265 bool DomStorageDatabase::UpgradeVersion1To2() { | |
| 266 DCHECK(IsOpen()); | |
| 267 DCHECK(DetectSchemaVersion() == V1); | |
| 268 | |
| 269 sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, | |
| 270 "SELECT * FROM ItemTable")); | |
| 271 DCHECK(statement.is_valid()); | |
| 272 | |
| 273 // Need to migrate from TEXT value column to BLOB. | |
| 274 // Store the current database content so we can re-insert | |
| 275 // the data into the new V2 table. | |
| 276 ValuesMap values; | |
| 277 while (statement.Step()) { | |
| 278 base::string16 key = statement.ColumnString16(0); | |
| 279 base::NullableString16 value(statement.ColumnString16(1), false); | |
| 280 values[key] = value; | |
| 281 } | |
| 282 | |
| 283 sql::Transaction migration(db_.get()); | |
| 284 return migration.Begin() && | |
| 285 db_->Execute("DROP TABLE ItemTable") && | |
| 286 CreateTableV2() && | |
| 287 CommitChanges(false, values) && | |
| 288 migration.Commit(); | |
| 289 } | |
| 290 | |
| 291 void DomStorageDatabase::Close() { | |
| 292 db_.reset(NULL); | |
| 293 } | |
| 294 | |
| 295 } // namespace dom_storage | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 22297005:
Move webkit/{browser,common}/dom_storage into content/ (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src