Index: services/preferences/public/cpp/persistent_pref_store_mojo.cc |
diff --git a/services/preferences/public/cpp/persistent_pref_store_mojo.cc b/services/preferences/public/cpp/persistent_pref_store_mojo.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..838cf633ccbfc1395ff63503ffcfe9f00fb78435 |
--- /dev/null |
+++ b/services/preferences/public/cpp/persistent_pref_store_mojo.cc |
@@ -0,0 +1,152 @@ |
+// 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_mojo.h" |
+ |
+#include <utility> |
+ |
+#include "base/values.h" |
+ |
+namespace prefs { |
+ |
+PersistentPrefStoreMojo::PersistentPrefStoreMojo( |
+ mojom::PersistentPrefStoreConnectorPtr connector) |
+ : connector_(std::move(connector)), |
+ pref_store_request_(mojo::MakeRequest(&pref_store_)) {} |
+ |
+bool PersistentPrefStoreMojo::GetValue(const std::string& key, |
+ const base::Value** value) const { |
+ return local_prefs_->Get(key, value); |
+} |
+ |
+std::unique_ptr<base::DictionaryValue> PersistentPrefStoreMojo::GetValues() |
+ const { |
+ return local_prefs_->CreateDeepCopy(); |
+} |
+ |
+void PersistentPrefStoreMojo::AddObserver(PrefStore::Observer* observer) { |
+ observers_.AddObserver(observer); |
+} |
+ |
+void PersistentPrefStoreMojo::RemoveObserver(PrefStore::Observer* observer) { |
+ observers_.RemoveObserver(observer); |
+} |
+ |
+bool PersistentPrefStoreMojo::HasObservers() const { |
+ return observers_.might_have_observers(); |
+} |
+ |
+bool PersistentPrefStoreMojo::IsInitializationComplete() const { |
+ return static_cast<bool>(local_prefs_); |
+} |
+ |
+void PersistentPrefStoreMojo::SetValue(const std::string& key, |
+ std::unique_ptr<base::Value> value, |
+ uint32_t flags) { |
+ base::Value* old_value = nullptr; |
+ local_prefs_->Get(key, &old_value); |
+ if (!old_value || !value->Equals(old_value)) { |
+ local_prefs_->Set(key, std::move(value)); |
+ ReportValueChanged(key, flags); |
+ } |
+} |
+ |
+void PersistentPrefStoreMojo::RemoveValue(const std::string& key, |
+ uint32_t flags) { |
+ if (local_prefs_->RemovePath(key, nullptr)) |
+ ReportValueChanged(key, flags); |
+} |
+ |
+bool PersistentPrefStoreMojo::GetMutableValue(const std::string& key, |
+ base::Value** result) { |
+ return local_prefs_->Get(key, result); |
+} |
+ |
+void PersistentPrefStoreMojo::ReportValueChanged(const std::string& key, |
+ uint32_t flags) { |
+ const base::Value* local_value = nullptr; |
+ local_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 PersistentPrefStoreMojo::SetValueSilently( |
+ const std::string& key, |
+ std::unique_ptr<base::Value> value, |
+ uint32_t flags) { |
+ pref_store_->SetValue(key, value->CreateDeepCopy(), flags); |
+ local_prefs_->Set(key, std::move(value)); |
+} |
+ |
+bool PersistentPrefStoreMojo::ReadOnly() const { |
+ return read_only_; |
+} |
+ |
+PersistentPrefStore::PrefReadError PersistentPrefStoreMojo::GetReadError() |
+ const { |
+ return read_error_; |
+} |
+ |
+PersistentPrefStore::PrefReadError PersistentPrefStoreMojo::ReadPrefs() { |
+ PrefReadError read_error = PrefReadError::PREF_READ_ERROR_NONE; |
+ bool read_only = false; |
+ std::unique_ptr<base::DictionaryValue> local_prefs; |
+ mojom::PersistentPrefStorePtr pref_store; |
+ if (!connector_->Connect(&read_error, &read_only, &local_prefs, &pref_store)) |
+ NOTREACHED(); |
+ |
+ OnCreateComplete(read_error, read_only, std::move(local_prefs), |
+ std::move(pref_store)); |
+ return read_error_; |
+} |
+ |
+void PersistentPrefStoreMojo::ReadPrefsAsync( |
+ ReadErrorDelegate* error_delegate) { |
+ error_delegate_.reset(error_delegate); |
+ connector_->Connect(base::Bind(&PersistentPrefStoreMojo::OnCreateComplete, |
+ base::Unretained(this))); |
+} |
+ |
+void PersistentPrefStoreMojo::CommitPendingWrite() { |
+ pref_store_->CommitPendingWrite(); |
+} |
+ |
+void PersistentPrefStoreMojo::SchedulePendingLossyWrites() { |
+ return pref_store_->SchedulePendingLossyWrites(); |
+} |
+ |
+void PersistentPrefStoreMojo::ClearMutableValues() { |
+ return pref_store_->ClearMutableValues(); |
+} |
+ |
+PersistentPrefStoreMojo::~PersistentPrefStoreMojo() { |
+ if (!pref_store_) |
+ return; |
+ |
+ pref_store_->CommitPendingWrite(); |
+} |
+ |
+void PersistentPrefStoreMojo::OnCreateComplete( |
+ PrefReadError read_error, |
+ bool read_only, |
+ std::unique_ptr<base::DictionaryValue> local_prefs, |
+ mojom::PersistentPrefStorePtr pref_store) { |
+ connector_.reset(); |
+ read_error_ = read_error; |
+ read_only_ = read_only; |
+ local_prefs_ = std::move(local_prefs); |
+ 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>(local_prefs_)); |
+ } |
+} |
+ |
+} // namespace prefs |