Implementation of leveldb-backed PrefStore

base/prefs/leveldb_pref_store.cc

Index: base/prefs/leveldb_pref_store.cc
diff --git a/base/prefs/leveldb_pref_store.cc b/base/prefs/leveldb_pref_store.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fdeba38a52021cefe8c2d6b7ced5f525a632f826
--- /dev/null
+++ b/base/prefs/leveldb_pref_store.cc
@@ -0,0 +1,264 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/prefs/leveldb_pref_store.h"
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/file_util.h"
+#include "base/json/json_string_value_serializer.h"
+#include "base/sequenced_task_runner.h"
+#include "base/values.h"
+#include "third_party/leveldatabase/env_chromium.h"
+#include "third_party/leveldatabase/src/include/leveldb/db.h"
+
+LevelDBPrefStore::LevelDBPrefStore(
+    const base::FilePath& filename,
+    base::SequencedTaskRunner* sequenced_task_runner)
+    : path_(filename),
+      sequenced_task_runner_(sequenced_task_runner),
+      original_task_runner_(base::MessageLoopProxy::current()),
+      read_only_(false),
+      initialized_(false),
+      read_error_(PREF_READ_ERROR_OTHER) {}
+
+bool LevelDBPrefStore::GetValue(const std::string& key,
+                                const base::Value** result) const {
+  DCHECK(initialized_);
+  const base::Value* tmp = NULL;
+  if (!prefs_.GetValue(key, &tmp)) {
+    return false;
+  }
+
+  if (result)
+    *result = tmp;
+  return true;
+}
+
+// Callers of GetMutableValue have to also call ReportValueChanged.
+bool LevelDBPrefStore::GetMutableValue(const std::string& key,
+                                       base::Value** result) {
+  DCHECK(initialized_);
+  return prefs_.GetValue(key, result);
+}
+
+void LevelDBPrefStore::AddObserver(PrefStore::Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void LevelDBPrefStore::RemoveObserver(PrefStore::Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+bool LevelDBPrefStore::HasObservers() const {
+  return observers_.might_have_observers();
+}
+
+bool LevelDBPrefStore::IsInitializationComplete() const { return initialized_; }
+
+void LevelDBPrefStore::PersistOnFileThread(const std::string& key,
+                                           const std::string& value) {
+  DCHECK(sequenced_task_runner_->RunsTasksOnCurrentThread());
+
+  leveldb::Status status = db_->Put(leveldb::WriteOptions(), key, value);
+  // DCHECK is fine; the corresponding error is ignored in json_pref_store.

[Mattias Nissler (ping if slow), 2014/02/25 10:51:44]

nit: JsonPrefStore

[dgrogan, 2014/03/05 03:06:58]

Done.

+  // There's also no API available to surface the error back up to the caller.

[Mattias Nissler (ping if slow), 2014/02/25 10:51:44]

Can you add a sentence explaining the consequences? One difference between
LevelDBPrefStore and JsonPrefStore is that latter as all-or-nothing semantics,
whereas this code could run into an error for a single pref and then happily
continue writing afterwards. So from the point of view of consuming code, the
next Chrome restart will just time-warp to a point in the past with
JsonPrefStore, whereas LevelDBPrefStore as it is now gives you a totally
unpredictable result. Have you assessed whether that's OK?

If not, another option might be to flip to read_only_ on the first error we see,
which would match JsonPrefStore semantics more closely.

Also, do we want UMA for this?

[dgrogan, 2014/03/20 00:25:37]

I think this is not ok, thanks for bringing it up. Existing clients might rely
on the fact that preference values set in the same turn of the event loop will
be persisted together; JsonPrefStore implicitly supports transaction-like
semantics. To make LevelDBPrefStore support the same I'll need to do the
batching and writing every 10 seconds like we talked about in another comment.

+  DCHECK(status.ok()) << status.ToString();
+}
+
+void LevelDBPrefStore::RemoveOnFileThread(const std::string& key) {
+  DCHECK(sequenced_task_runner_->RunsTasksOnCurrentThread());
+
+  leveldb::Status status = db_->Delete(leveldb::WriteOptions(), key);
+  // DCHECK is fine; the corresponding error is ignored in json_pref_store.

[Mattias Nissler (ping if slow), 2014/02/25 10:51:44]

nit: JsonPrefStore

[dgrogan, 2014/03/05 03:06:58]

Done.

+  DCHECK(status.ok()) << status.ToString();
+}
+
+void LevelDBPrefStore::RemoveFromUIThread(const std::string& key) {
+  if (read_only_)
+    return;
+  sequenced_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &LevelDBPrefStore::RemoveOnFileThread,
+          make_scoped_refptr(this),
+          key));
+}
+
+void LevelDBPrefStore::PersistFromUIThread(const std::string& key,
+                                           base::Value* value) {
+  if (read_only_)
+    return;
+  std::string value_string;
+  JSONStringValueSerializer serializer(&value_string);
+  bool serialized_ok = serializer.Serialize(*value);
+  DCHECK(serialized_ok);
+
+  sequenced_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &LevelDBPrefStore::PersistOnFileThread, this, key, value_string));
+}
+
+void LevelDBPrefStore::SetValue(const std::string& key, base::Value* value) {
+  DCHECK(initialized_);
+  DCHECK(value);
+  scoped_ptr<base::Value> new_value(value);
+  base::Value* old_value = NULL;
+  bool found = prefs_.GetValue(key, &old_value);
+  if (!found || !value->Equals(old_value)) {
+    PersistFromUIThread(key, new_value.get());
+    prefs_.SetValue(key, new_value.release());
+    NotifyObservers(key);
+  }
+}
+
+void LevelDBPrefStore::SetValueSilently(const std::string& key,
+                                        base::Value* value) {
+  DCHECK(initialized_);
+  DCHECK(value);
+  scoped_ptr<base::Value> new_value(value);
+  base::Value* old_value = NULL;
+  prefs_.GetValue(key, &old_value);
+  if (!old_value || !value->Equals(old_value)) {
+    PersistFromUIThread(key, new_value.get());
+    prefs_.SetValue(key, new_value.release());
+  }
+}
+
+void LevelDBPrefStore::RemoveValue(const std::string& key) {
+  DCHECK(initialized_);
+  if (prefs_.RemoveValue(key)) {
+    RemoveFromUIThread(key);
+    NotifyObservers(key);
+  }
+}
+
+bool LevelDBPrefStore::ReadOnly() const { return read_only_; }
+
+PersistentPrefStore::PrefReadError LevelDBPrefStore::GetReadError() const {
+  return read_error_;
+}
+
+PersistentPrefStore::PrefReadError LevelDBPrefStore::ReadPrefs() {
+  DCHECK(!initialized_);
+  DCHECK(!db_);
+  if (path_.empty()) {
+    OnStorageRead(PREF_READ_ERROR_FILE_NOT_SPECIFIED, false);
+    return PREF_READ_ERROR_FILE_NOT_SPECIFIED;
+  }
+
+  bool no_dir = !base::PathExists(path_.DirName());
+
+  leveldb::DB* db;
+  leveldb::Options options;
+  options.create_if_missing = true;
+  leveldb::Status status =
+      leveldb::DB::Open(options, path_.AsUTF8Unsafe(), &db);
+  if (!status.ok()) {
+    PrefReadError error = PREF_READ_ERROR_FILE_OTHER;
+    if (leveldb_env::IsCorruption(status)) {
+      error = PREF_READ_ERROR_LEVELDB_CORRUPTION;
+      // TODO(dgrogan): Call RepairDB.
+    } else if (leveldb_env::IsIOError(status)) {
+      error = PREF_READ_ERROR_LEVELDB_IO_ERROR;
+    }
+    // TODO(dgrogan): Add UMA histogram?

[Mattias Nissler (ping if slow), 2014/02/25 10:51:44]

I think the PREF_READ_ERROR values are already histogrammed in some outer code
layer, but it may make sense to add another one here for raw leveldb status.

+    OnStorageRead(error, no_dir);
+    return error;
+  }
+  db_.reset(db);
+
+  scoped_ptr<leveldb::Iterator> it(db->NewIterator(leveldb::ReadOptions()));
+  for (it->SeekToFirst(); it->Valid(); it->Next()) {
+    const std::string value_string = it->value().ToString();
+    JSONStringValueSerializer deserializer(value_string);
+    std::string error_message;
+    int error_code;
+    base::Value* json_value =
+        deserializer.Deserialize(&error_code, &error_message);
+    if (json_value)
+      prefs_.SetValue(it->key().ToString(), json_value);
+    else
+      NOTREACHED() << error_message;
+  }
+
+  PersistentPrefStore::PrefReadError error = PREF_READ_ERROR_NONE;
+  if (!it->status().ok()) {
+    // TODO(dgrogan): Add error histogram.

[Mattias Nissler (ping if slow), 2014/02/25 10:51:44]

see comment above

+    error = PREF_READ_ERROR_FILE_OTHER;
+  }
+  OnStorageRead(error, no_dir);
+  return error;
+}
+
+void LevelDBPrefStore::ReadPrefsAsync(ReadErrorDelegate* error_delegate) {
+  DCHECK_EQ(false, initialized_);
+  error_delegate_.reset(error_delegate);
+  if (path_.empty()) {
+    OnStorageRead(PREF_READ_ERROR_FILE_NOT_SPECIFIED, false);
+    return;
+  }
+
+  sequenced_task_runner_->PostTask(FROM_HERE, base::Bind(
+      base::IgnoreResult(&LevelDBPrefStore::ReadPrefs), this));
+}
+
+void LevelDBPrefStore::CommitPendingWrite() {
+  // No-op, key-value pairs are committed as they are set.
+  // TODO(dgrogan): If this doesn't perform well because, for example, the
+  // extensions prefs are changed frequently then we'll have to track a set of
+  // keys that have changed and write them to disk every k seconds.
+}
+
+void LevelDBPrefStore::ReportValueChanged(const std::string& key) {
+  base::Value* new_value = NULL;
+  DCHECK(prefs_.GetValue(key, &new_value));
+  PersistFromUIThread(key, new_value);
+  NotifyObservers(key);
+}
+
+void LevelDBPrefStore::NotifyObservers(const std::string& key) {
+  FOR_EACH_OBSERVER(PrefStore::Observer, observers_, OnPrefValueChanged(key));
+}
+
+void LevelDBPrefStore::OnStorageRead(PersistentPrefStore::PrefReadError error,
+                                     bool no_dir) {
+  if (!original_task_runner_->RunsTasksOnCurrentThread()) {
+    // When db is opened async, this function needs to be called on original
+    // thread.
+    original_task_runner_->PostTask(FROM_HERE,
+        base::Bind(&LevelDBPrefStore::OnStorageRead, this, error, no_dir));
+  }
+  read_error_ = error;
+
+  if (no_dir) {
+    FOR_EACH_OBSERVER(
+        PrefStore::Observer, observers_, OnInitializationCompleted(false));
+    return;
+  }
+
+  initialized_ = true;
+
+  switch (error) {
+    case PREF_READ_ERROR_FILE_OTHER:
+    case PREF_READ_ERROR_LEVELDB_IO_ERROR:
+      read_only_ = true;
+      break;
+    case PREF_READ_ERROR_NONE:
+      break;
+    default:
+      NOTREACHED() << "Unknown error: " << error;
+  }
+
+  // TODO(dgrogan): Call pref_filter_->FilterOnLoad
+
+  if (error_delegate_.get() && error != PREF_READ_ERROR_NONE)
+    error_delegate_->OnError(error);
+
+  FOR_EACH_OBSERVER(
+      PrefStore::Observer, observers_, OnInitializationCompleted(true));
+}
+
+LevelDBPrefStore::~LevelDBPrefStore() {}