Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1349)

Unified Diff: services/preferences/public/cpp/persistent_pref_store_client.cc

Issue 2743463002: WIP: Pref service user prefs. (Closed)
Patch Set: Created 3 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: services/preferences/public/cpp/persistent_pref_store_client.cc
diff --git a/services/preferences/public/cpp/persistent_pref_store_client.cc b/services/preferences/public/cpp/persistent_pref_store_client.cc
new file mode 100644
index 0000000000000000000000000000000000000000..9ee39669bf9ce3b9d762361ca86da14b8862d354
--- /dev/null
+++ b/services/preferences/public/cpp/persistent_pref_store_client.cc
@@ -0,0 +1,187 @@
+// 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

Powered by Google App Engine
This is Rietveld 408576698