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 |