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() : no_dir(true), 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 bool contains_value = prefs_.GetValue(key, &new_value); 380 DCHECK(contains_value); 381 std::string value_string = Serialize(new_value); 382 MarkForInsertion(key, value_string); 383 NotifyObservers(key); 384 } 385 386 void LevelDBPrefStore::NotifyObservers(const std::string& key) { 387 FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key)); 388 } 389 390 void LevelDBPrefStore::OnStorageRead( 391 scoped_ptr<LevelDBPrefStore::ReadingResults> reading_results) { 392 UMA_HISTOGRAM_SPARSE_SLOWLY("LevelDBPrefStore.ReadErrors", 393 reading_results->error); 394 read_error_ = IntToPrefReadError(reading_results->error); 395 396 if (reading_results->no_dir) { 397 FOR_EACH_OBSERVER( 398 PrefStore::Observer, observers_, OnInitializationCompleted(false)); 399 return; 400 } 401 402 initialized_ = true; 403 404 if (reading_results->db) { 405 DCHECK(reading_results->value_map); 406 serializer_.reset(new FileThreadSerializer(reading_results->db.Pass())); 407 prefs_.Swap(reading_results->value_map.get()); 408 } else { 409 read_only_ = true; 410 } 411 412 // TODO(dgrogan): Call pref_filter_->FilterOnLoad 413 414 if (error_delegate_.get() && read_error_ != PREF_READ_ERROR_NONE) 415 error_delegate_->OnError(read_error_); 416 417 FOR_EACH_OBSERVER( 418 PrefStore::Observer, observers_, OnInitializationCompleted(true)); 419 } 420