WIP: Pref service user prefs.

services/preferences/public/cpp/persistent_pref_store_client.cc

+// Copyright 2017 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 "services/preferences/public/cpp/persistent_pref_store_client.h"
+
+#include <utility>
+
+#include "base/values.h"
+
+namespace prefs {
+
+PersistentPrefStoreClient::PersistentPrefStoreClient(
+    mojom::PersistentPrefStoreConnectorPtr connector)
+    : connector_(std::move(connector)),
+      pref_store_request_(mojo::MakeRequest(&pref_store_)),
+      observer_binding_(this) {}
+
+bool PersistentPrefStoreClient::GetValue(const std::string& key,
+                                         const base::Value** value) const {
+  return cached_prefs_->Get(key, value);
+}
+
+std::unique_ptr<base::DictionaryValue> PersistentPrefStoreClient::GetValues()
+    const {
+  return cached_prefs_->CreateDeepCopy();
+}
+
+void PersistentPrefStoreClient::AddObserver(PrefStore::Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void PersistentPrefStoreClient::RemoveObserver(PrefStore::Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+bool PersistentPrefStoreClient::HasObservers() const {
+  return observers_.might_have_observers();
+}
+
+bool PersistentPrefStoreClient::IsInitializationComplete() const {
+  return static_cast<bool>(cached_prefs_);
+}
+
+void PersistentPrefStoreClient::SetValue(const std::string& key,
+                                         std::unique_ptr<base::Value> value,
+                                         uint32_t flags) {
+  base::Value* old_value = nullptr;
+  cached_prefs_->Get(key, &old_value);
+  if (!old_value || !value->Equals(old_value)) {
+    cached_prefs_->Set(key, std::move(value));
+    ReportValueChanged(key, flags);
+  }
+}
+
+void PersistentPrefStoreClient::RemoveValue(const std::string& key,
+                                            uint32_t flags) {
+  if (cached_prefs_->RemovePath(key, nullptr))
+    ReportValueChanged(key, flags);
+}
+
+bool PersistentPrefStoreClient::GetMutableValue(const std::string& key,
+                                                base::Value** result) {
+  return cached_prefs_->Get(key, result);
+}
+
+void PersistentPrefStoreClient::ReportValueChanged(const std::string& key,
+                                                   uint32_t flags) {
+  const base::Value* local_value = nullptr;
+  cached_prefs_->Get(key, &local_value);
+  pref_store_->SetValue(
+      key, local_value ? local_value->CreateDeepCopy() : nullptr, flags);
+  for (PrefStore::Observer& observer : observers_)
+    observer.OnPrefValueChanged(key);
+}
+
+void PersistentPrefStoreClient::SetValueSilently(
+    const std::string& key,
+    std::unique_ptr<base::Value> value,
+    uint32_t flags) {
+  pref_store_->SetValue(key, value->CreateDeepCopy(), flags);
+  cached_prefs_->Set(key, std::move(value));
+}
+
+bool PersistentPrefStoreClient::ReadOnly() const {
+  return read_only_;
+}
+
+PersistentPrefStore::PrefReadError PersistentPrefStoreClient::GetReadError()
+    const {
+  return read_error_;
+}
+
+PersistentPrefStore::PrefReadError PersistentPrefStoreClient::ReadPrefs() {
+  PrefReadError read_error = PrefReadError::PREF_READ_ERROR_NONE;
+  bool read_only = false;
+  std::unique_ptr<base::DictionaryValue> local_prefs;
+  mojom::PersistentPrefStorePtr pref_store;
+  mojom::PrefStoreObserverRequest observer_request;
+  if (!connector_->Connect(&read_error, &read_only, &local_prefs, &pref_store,
+                           &observer_request)) {
+    NOTREACHED();
+  }
+
+  OnCreateComplete(read_error, read_only, std::move(local_prefs),
+                   std::move(pref_store), std::move(observer_request));
+  return read_error_;
+}
+
+void PersistentPrefStoreClient::ReadPrefsAsync(
+    ReadErrorDelegate* error_delegate) {
+  error_delegate_.reset(error_delegate);
+  connector_->Connect(base::Bind(&PersistentPrefStoreClient::OnCreateComplete,
+                                 base::Unretained(this)));
+}
+
+void PersistentPrefStoreClient::CommitPendingWrite() {
+  pref_store_->CommitPendingWrite();
+}
+
+void PersistentPrefStoreClient::SchedulePendingLossyWrites() {
+  return pref_store_->SchedulePendingLossyWrites();
+}
+
+void PersistentPrefStoreClient::ClearMutableValues() {
+  return pref_store_->ClearMutableValues();
+}
+
+PersistentPrefStoreClient::~PersistentPrefStoreClient() {
+  if (!pref_store_)
+    return;
+
+  pref_store_->CommitPendingWrite();
+}
+
+void PersistentPrefStoreClient::OnCreateComplete(
+    PrefReadError read_error,
+    bool read_only,
+    std::unique_ptr<base::DictionaryValue> local_prefs,
+    mojom::PersistentPrefStorePtr pref_store,
+    mojom::PrefStoreObserverRequest observer_request) {
+  connector_.reset();
+  read_error_ = read_error;
+  read_only_ = read_only;
+  cached_prefs_ = std::move(local_prefs);
+  observer_binding_.Bind(std::move(observer_request));
+  mojo::FuseInterface(std::move(pref_store_request_),
+                      pref_store.PassInterface());
+  if (error_delegate_ && read_error_ != PREF_READ_ERROR_NONE)
+    error_delegate_->OnError(read_error_);
+  error_delegate_.reset();
+
+  for (PrefStore::Observer& observer : observers_) {
+    observer.OnInitializationCompleted(static_cast<bool>(cached_prefs_));
+  }
+}
+
+void PersistentPrefStoreClient::OnInitializationCompleted(bool success) {
+  NOTREACHED();
+}
+
+void PersistentPrefStoreClient::OnPrefChanged(
+    const std::string& key,
+    std::unique_ptr<base::Value> value) {
+  bool changed = false;
+  if (!value) {  // Delete
+    if (cached_prefs_->RemovePath(key, nullptr))
+      changed = true;
+  } else {
+    const base::Value* prev;
+    if (cached_prefs_->Get(key, &prev)) {
+      if (!prev->Equals(value.get())) {
+        cached_prefs_->Set(key, std::move(value));
+        changed = true;
+      }
+    } else {
+      cached_prefs_->Set(key, std::move(value));
+      changed = true;
+    }
+  }
+  if (changed) {
+    for (Observer& observer : observers_)
+      observer.OnPrefValueChanged(key);
+  }
+}
+
+}  // namespace prefs