| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 "chrome/browser/prefs/leveldb_pref_store.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/callback.h" | |
| 9 #include "base/file_util.h" | |
| 10 #include "base/json/json_string_value_serializer.h" | |
| 11 #include "base/location.h" | |
| 12 #include "base/metrics/sparse_histogram.h" | |
| 13 #include "base/sequenced_task_runner.h" | |
| 14 #include "base/task_runner_util.h" | |
| 15 #include "base/threading/thread_restrictions.h" | |
| 16 #include "base/time/time.h" | |
| 17 #include "base/values.h" | |
| 18 #include "third_party/leveldatabase/env_chromium.h" | |
| 19 #include "third_party/leveldatabase/src/include/leveldb/db.h" | |
| 20 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h" | |
| 21 | |
| 22 namespace { | |
| 23 | |
| 24 enum ErrorMasks { | |
| 25 OPENED = 1 << 0, | |
| 26 DESTROYED = 1 << 1, | |
| 27 REPAIRED = 1 << 2, | |
| 28 DESTROY_FAILED = 1 << 3, | |
| 29 REPAIR_FAILED = 1 << 4, | |
| 30 IO_ERROR = 1 << 5, | |
| 31 DATA_LOST = 1 << 6, | |
| 32 ITER_NOT_OK = 1 << 7, | |
| 33 FILE_NOT_SPECIFIED = 1 << 8, | |
| 34 }; | |
| 35 | |
| 36 PersistentPrefStore::PrefReadError IntToPrefReadError(int error) { | |
| 37 DCHECK(error); | |
| 38 if (error == FILE_NOT_SPECIFIED) | |
| 39 return PersistentPrefStore::PREF_READ_ERROR_FILE_NOT_SPECIFIED; | |
| 40 if (error == OPENED) | |
| 41 return PersistentPrefStore::PREF_READ_ERROR_NONE; | |
| 42 if (error & IO_ERROR) | |
| 43 return PersistentPrefStore::PREF_READ_ERROR_LEVELDB_IO; | |
| 44 if (error & OPENED) | |
| 45 return PersistentPrefStore::PREF_READ_ERROR_LEVELDB_CORRUPTION; | |
| 46 return PersistentPrefStore::PREF_READ_ERROR_LEVELDB_CORRUPTION_READ_ONLY; | |
| 47 } | |
| 48 | |
| 49 } // namespace | |
| 50 | |
| 51 struct LevelDBPrefStore::ReadingResults { | |
| 52 ReadingResults() : error(0) {} | |
| 53 bool no_dir; | |
| 54 scoped_ptr<leveldb::DB> db; | |
| 55 scoped_ptr<PrefValueMap> value_map; | |
| 56 int error; | |
| 57 }; | |
| 58 | |
| 59 // An instance of this class is created on the UI thread but is used | |
| 60 // exclusively on the FILE thread. | |
| 61 class LevelDBPrefStore::FileThreadSerializer { | |
| 62 public: | |
| 63 explicit FileThreadSerializer(scoped_ptr<leveldb::DB> db) : db_(db.Pass()) {} | |
| 64 void WriteToDatabase( | |
| 65 std::map<std::string, std::string>* keys_to_set, | |
| 66 std::set<std::string>* keys_to_delete) { | |
| 67 DCHECK(keys_to_set->size() > 0 || keys_to_delete->size() > 0); | |
| 68 leveldb::WriteBatch batch; | |
| 69 for (std::map<std::string, std::string>::iterator iter = | |
| 70 keys_to_set->begin(); | |
| 71 iter != keys_to_set->end(); | |
| 72 iter++) { | |
| 73 batch.Put(iter->first, iter->second); | |
| 74 } | |
| 75 | |
| 76 for (std::set<std::string>::iterator iter = keys_to_delete->begin(); | |
| 77 iter != keys_to_delete->end(); | |
| 78 iter++) { | |
| 79 batch.Delete(*iter); | |
| 80 } | |
| 81 | |
| 82 leveldb::Status status = db_->Write(leveldb::WriteOptions(), &batch); | |
| 83 | |
| 84 // DCHECK is fine; the corresponding error is ignored in JsonPrefStore. | |
| 85 // There's also no API available to surface the error back up to the caller. | |
| 86 // TODO(dgrogan): UMA? | |
| 87 DCHECK(status.ok()) << status.ToString(); | |
| 88 } | |
| 89 | |
| 90 private: | |
| 91 scoped_ptr<leveldb::DB> db_; | |
| 92 DISALLOW_COPY_AND_ASSIGN(FileThreadSerializer); | |
| 93 }; | |
| 94 | |
| 95 bool MoveDirectoryAside(const base::FilePath& path) { | |
| 96 base::FilePath bad_path = path.AppendASCII(".bad"); | |
| 97 if (!base::Move(path, bad_path)) { | |
| 98 base::DeleteFile(bad_path, true); | |
| 99 return false; | |
| 100 } | |
| 101 return true; | |
| 102 } | |
| 103 | |
| 104 /* static */ | |
| 105 void LevelDBPrefStore::OpenDB(const base::FilePath& path, | |
| 106 ReadingResults* reading_results) { | |
| 107 DCHECK_EQ(0, reading_results->error); | |
| 108 leveldb::Options options; | |
| 109 options.create_if_missing = true; | |
| 110 leveldb::DB* db; | |
| 111 while (1) { | |
| 112 leveldb::Status status = | |
| 113 leveldb::DB::Open(options, path.AsUTF8Unsafe(), &db); | |
| 114 if (status.ok()) { | |
| 115 reading_results->db.reset(db); | |
| 116 reading_results->error |= OPENED; | |
| 117 break; | |
| 118 } | |
| 119 if (leveldb_env::IsIOError(status)) { | |
| 120 reading_results->error |= IO_ERROR; | |
| 121 break; | |
| 122 } | |
| 123 if (reading_results->error & DESTROYED) | |
| 124 break; | |
| 125 | |
| 126 DCHECK(!(reading_results->error & REPAIR_FAILED)); | |
| 127 if (!(reading_results->error & REPAIRED)) { | |
| 128 status = leveldb::RepairDB(path.AsUTF8Unsafe(), options); | |
| 129 if (status.ok()) { | |
| 130 reading_results->error |= REPAIRED; | |
| 131 continue; | |
| 132 } | |
| 133 reading_results->error |= REPAIR_FAILED; | |
| 134 } | |
| 135 if (!MoveDirectoryAside(path)) { | |
| 136 status = leveldb::DestroyDB(path.AsUTF8Unsafe(), options); | |
| 137 if (!status.ok()) { | |
| 138 reading_results->error |= DESTROY_FAILED; | |
| 139 break; | |
| 140 } | |
| 141 } | |
| 142 reading_results->error |= DESTROYED; | |
| 143 } | |
| 144 DCHECK(reading_results->error); | |
| 145 DCHECK(!((reading_results->error & OPENED) && | |
| 146 (reading_results->error & DESTROY_FAILED))); | |
| 147 DCHECK(reading_results->error != (REPAIR_FAILED | OPENED)); | |
| 148 } | |
| 149 | |
| 150 /* static */ | |
| 151 scoped_ptr<LevelDBPrefStore::ReadingResults> LevelDBPrefStore::DoReading( | |
| 152 const base::FilePath& path) { | |
| 153 base::ThreadRestrictions::AssertIOAllowed(); | |
| 154 | |
| 155 scoped_ptr<ReadingResults> reading_results(new ReadingResults); | |
| 156 | |
| 157 reading_results->no_dir = !base::PathExists(path.DirName()); | |
| 158 OpenDB(path, reading_results.get()); | |
| 159 if (!reading_results->db) { | |
| 160 DCHECK(!(reading_results->error & OPENED)); | |
| 161 return reading_results.Pass(); | |
| 162 } | |
| 163 | |
| 164 DCHECK(reading_results->error & OPENED); | |
| 165 reading_results->value_map.reset(new PrefValueMap); | |
| 166 scoped_ptr<leveldb::Iterator> it( | |
| 167 reading_results->db->NewIterator(leveldb::ReadOptions())); | |
| 168 // TODO(dgrogan): Is it really necessary to check it->status() each iteration? | |
| 169 for (it->SeekToFirst(); it->Valid() && it->status().ok(); it->Next()) { | |
| 170 const std::string value_string = it->value().ToString(); | |
| 171 JSONStringValueSerializer deserializer(value_string); | |
| 172 std::string error_message; | |
| 173 int error_code; | |
| 174 base::Value* json_value = | |
| 175 deserializer.Deserialize(&error_code, &error_message); | |
| 176 if (json_value) { | |
| 177 reading_results->value_map->SetValue(it->key().ToString(), json_value); | |
| 178 } else { | |
| 179 DLOG(ERROR) << "Invalid json for key " << it->key().ToString() | |
| 180 << ": " << error_message; | |
| 181 reading_results->error |= DATA_LOST; | |
| 182 } | |
| 183 } | |
| 184 | |
| 185 if (!it->status().ok()) | |
| 186 reading_results->error |= ITER_NOT_OK; | |
| 187 | |
| 188 return reading_results.Pass(); | |
| 189 } | |
| 190 | |
| 191 LevelDBPrefStore::LevelDBPrefStore( | |
| 192 const base::FilePath& filename, | |
| 193 base::SequencedTaskRunner* sequenced_task_runner) | |
| 194 : path_(filename), | |
| 195 sequenced_task_runner_(sequenced_task_runner), | |
| 196 original_task_runner_(base::MessageLoopProxy::current()), | |
| 197 read_only_(false), | |
| 198 initialized_(false), | |
| 199 read_error_(PREF_READ_ERROR_NONE), | |
| 200 weak_ptr_factory_(this) {} | |
| 201 | |
| 202 LevelDBPrefStore::~LevelDBPrefStore() { | |
| 203 CommitPendingWrite(); | |
| 204 sequenced_task_runner_->DeleteSoon(FROM_HERE, serializer_.release()); | |
| 205 } | |
| 206 | |
| 207 bool LevelDBPrefStore::GetValue(const std::string& key, | |
| 208 const base::Value** result) const { | |
| 209 DCHECK(initialized_); | |
| 210 const base::Value* tmp = NULL; | |
| 211 if (!prefs_.GetValue(key, &tmp)) { | |
| 212 return false; | |
| 213 } | |
| 214 | |
| 215 if (result) | |
| 216 *result = tmp; | |
| 217 return true; | |
| 218 } | |
| 219 | |
| 220 // Callers of GetMutableValue have to also call ReportValueChanged. | |
| 221 bool LevelDBPrefStore::GetMutableValue(const std::string& key, | |
| 222 base::Value** result) { | |
| 223 DCHECK(initialized_); | |
| 224 return prefs_.GetValue(key, result); | |
| 225 } | |
| 226 | |
| 227 void LevelDBPrefStore::AddObserver(PrefStore::Observer* observer) { | |
| 228 observers_.AddObserver(observer); | |
| 229 } | |
| 230 | |
| 231 void LevelDBPrefStore::RemoveObserver(PrefStore::Observer* observer) { | |
| 232 observers_.RemoveObserver(observer); | |
| 233 } | |
| 234 | |
| 235 bool LevelDBPrefStore::HasObservers() const { | |
| 236 return observers_.might_have_observers(); | |
| 237 } | |
| 238 | |
| 239 bool LevelDBPrefStore::IsInitializationComplete() const { return initialized_; } | |
| 240 | |
| 241 void LevelDBPrefStore::PersistFromUIThread() { | |
| 242 if (read_only_) | |
| 243 return; | |
| 244 DCHECK(serializer_); | |
| 245 | |
| 246 scoped_ptr<std::set<std::string> > keys_to_delete(new std::set<std::string>); | |
| 247 keys_to_delete->swap(keys_to_delete_); | |
| 248 | |
| 249 scoped_ptr<std::map<std::string, std::string> > keys_to_set( | |
| 250 new std::map<std::string, std::string>); | |
| 251 keys_to_set->swap(keys_to_set_); | |
| 252 | |
| 253 sequenced_task_runner_->PostTask( | |
| 254 FROM_HERE, | |
| 255 base::Bind(&LevelDBPrefStore::FileThreadSerializer::WriteToDatabase, | |
| 256 base::Unretained(serializer_.get()), | |
| 257 base::Owned(keys_to_set.release()), | |
| 258 base::Owned(keys_to_delete.release()))); | |
| 259 } | |
| 260 | |
| 261 void LevelDBPrefStore::ScheduleWrite() { | |
| 262 if (!timer_.IsRunning()) { | |
| 263 timer_.Start(FROM_HERE, | |
| 264 base::TimeDelta::FromSeconds(10), | |
| 265 this, | |
| 266 &LevelDBPrefStore::PersistFromUIThread); | |
| 267 } | |
| 268 } | |
| 269 | |
| 270 void LevelDBPrefStore::SetValue(const std::string& key, base::Value* value) { | |
| 271 SetValueInternal(key, value, true /*notify*/); | |
| 272 } | |
| 273 | |
| 274 void LevelDBPrefStore::SetValueSilently(const std::string& key, | |
| 275 base::Value* value) { | |
| 276 SetValueInternal(key, value, false /*notify*/); | |
| 277 } | |
| 278 | |
| 279 static std::string Serialize(base::Value* value) { | |
| 280 std::string value_string; | |
| 281 JSONStringValueSerializer serializer(&value_string); | |
| 282 bool serialized_ok = serializer.Serialize(*value); | |
| 283 DCHECK(serialized_ok); | |
| 284 return value_string; | |
| 285 } | |
| 286 | |
| 287 void LevelDBPrefStore::SetValueInternal(const std::string& key, | |
| 288 base::Value* value, | |
| 289 bool notify) { | |
| 290 DCHECK(initialized_); | |
| 291 DCHECK(value); | |
| 292 scoped_ptr<base::Value> new_value(value); | |
| 293 base::Value* old_value = NULL; | |
| 294 prefs_.GetValue(key, &old_value); | |
| 295 if (!old_value || !value->Equals(old_value)) { | |
| 296 std::string value_string = Serialize(value); | |
| 297 prefs_.SetValue(key, new_value.release()); | |
| 298 MarkForInsertion(key, value_string); | |
| 299 if (notify) | |
| 300 NotifyObservers(key); | |
| 301 } | |
| 302 } | |
| 303 | |
| 304 void LevelDBPrefStore::RemoveValue(const std::string& key) { | |
| 305 DCHECK(initialized_); | |
| 306 if (prefs_.RemoveValue(key)) { | |
| 307 MarkForDeletion(key); | |
| 308 NotifyObservers(key); | |
| 309 } | |
| 310 } | |
| 311 | |
| 312 bool LevelDBPrefStore::ReadOnly() const { return read_only_; } | |
| 313 | |
| 314 PersistentPrefStore::PrefReadError LevelDBPrefStore::GetReadError() const { | |
| 315 return read_error_; | |
| 316 } | |
| 317 | |
| 318 PersistentPrefStore::PrefReadError LevelDBPrefStore::ReadPrefs() { | |
| 319 DCHECK(!initialized_); | |
| 320 scoped_ptr<ReadingResults> reading_results; | |
| 321 if (path_.empty()) { | |
| 322 reading_results.reset(new ReadingResults); | |
| 323 reading_results->error = FILE_NOT_SPECIFIED; | |
| 324 } else { | |
| 325 reading_results = DoReading(path_); | |
| 326 } | |
| 327 | |
| 328 PrefReadError error = IntToPrefReadError(reading_results->error); | |
| 329 OnStorageRead(reading_results.Pass()); | |
| 330 return error; | |
| 331 } | |
| 332 | |
| 333 void LevelDBPrefStore::ReadPrefsAsync(ReadErrorDelegate* error_delegate) { | |
| 334 DCHECK_EQ(false, initialized_); | |
| 335 error_delegate_.reset(error_delegate); | |
| 336 if (path_.empty()) { | |
| 337 scoped_ptr<ReadingResults> reading_results(new ReadingResults); | |
| 338 reading_results->error = FILE_NOT_SPECIFIED; | |
| 339 OnStorageRead(reading_results.Pass()); | |
| 340 return; | |
| 341 } | |
| 342 PostTaskAndReplyWithResult(sequenced_task_runner_, | |
| 343 FROM_HERE, | |
| 344 base::Bind(&LevelDBPrefStore::DoReading, path_), | |
| 345 base::Bind(&LevelDBPrefStore::OnStorageRead, | |
| 346 weak_ptr_factory_.GetWeakPtr())); | |
| 347 } | |
| 348 | |
| 349 void LevelDBPrefStore::CommitPendingWrite() { | |
| 350 if (timer_.IsRunning()) { | |
| 351 timer_.Stop(); | |
| 352 PersistFromUIThread(); | |
| 353 } | |
| 354 } | |
| 355 | |
| 356 void LevelDBPrefStore::MarkForDeletion(const std::string& key) { | |
| 357 if (read_only_) | |
| 358 return; | |
| 359 keys_to_delete_.insert(key); | |
| 360 // Need to erase in case there's a set operation in the same batch that would | |
| 361 // clobber this delete. | |
| 362 keys_to_set_.erase(key); | |
| 363 ScheduleWrite(); | |
| 364 } | |
| 365 | |
| 366 void LevelDBPrefStore::MarkForInsertion(const std::string& key, | |
| 367 const std::string& value) { | |
| 368 if (read_only_) | |
| 369 return; | |
| 370 keys_to_set_[key] = value; | |
| 371 // Need to erase in case there's a delete operation in the same batch that | |
| 372 // would clobber this set. | |
| 373 keys_to_delete_.erase(key); | |
| 374 ScheduleWrite(); | |
| 375 } | |
| 376 | |
| 377 void LevelDBPrefStore::ReportValueChanged(const std::string& key) { | |
| 378 base::Value* new_value = NULL; | |
| 379 DCHECK(prefs_.GetValue(key, &new_value)); | |
| 380 std::string value_string = Serialize(new_value); | |
| 381 MarkForInsertion(key, value_string); | |
| 382 NotifyObservers(key); | |
| 383 } | |
| 384 | |
| 385 void LevelDBPrefStore::NotifyObservers(const std::string& key) { | |
| 386 FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key)); | |
| 387 } | |
| 388 | |
| 389 void LevelDBPrefStore::OnStorageRead( | |
| 390 scoped_ptr<LevelDBPrefStore::ReadingResults> reading_results) { | |
| 391 UMA_HISTOGRAM_SPARSE_SLOWLY("LevelDBPrefStore.ReadErrors", | |
| 392 reading_results->error); | |
| 393 read_error_ = IntToPrefReadError(reading_results->error); | |
| 394 | |
| 395 if (reading_results->no_dir) { | |
| 396 FOR_EACH_OBSERVER( | |
| 397 PrefStore::Observer, observers_, OnInitializationCompleted(false)); | |
| 398 return; | |
| 399 } | |
| 400 | |
| 401 initialized_ = true; | |
| 402 | |
| 403 if (reading_results->db) { | |
| 404 DCHECK(reading_results->value_map); | |
| 405 serializer_.reset(new FileThreadSerializer(reading_results->db.Pass())); | |
| 406 prefs_.Swap(reading_results->value_map.get()); | |
| 407 } else { | |
| 408 read_only_ = true; | |
| 409 } | |
| 410 | |
| 411 // TODO(dgrogan): Call pref_filter_->FilterOnLoad | |
| 412 | |
| 413 if (error_delegate_.get() && read_error_ != PREF_READ_ERROR_NONE) | |
| 414 error_delegate_->OnError(read_error_); | |
| 415 | |
| 416 FOR_EACH_OBSERVER( | |
| 417 PrefStore::Observer, observers_, OnInitializationCompleted(true)); | |
| 418 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 290633013:
Revert 271602 "Implementation of leveldb-backed PrefStore." (Closed)
Base URL: svn://svn.chromium.org/chrome/