Index: services/preferences/public/cpp/user_prefs_impl.cc |
diff --git a/services/preferences/public/cpp/user_prefs_impl.cc b/services/preferences/public/cpp/user_prefs_impl.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..9b8f512e50f61bf653d848984cdeeb2afa542101 |
--- /dev/null |
+++ b/services/preferences/public/cpp/user_prefs_impl.cc |
@@ -0,0 +1,314 @@ |
+// 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/user_prefs_impl.h" |
+ |
+#include <memory> |
+#include <set> |
+#include <utility> |
+ |
+#include "base/macros.h" |
+#include "base/values.h" |
+#include "components/prefs/json_pref_store.h" |
+#include "components/user_prefs/tracked/pref_hash_store_impl.h" |
+#include "components/user_prefs/tracked/segregated_pref_store.h" |
+#include "components/user_prefs/tracked/tracked_preferences_migration.h" |
+#include "mojo/public/cpp/bindings/strong_binding.h" |
+ |
+#if defined(OS_WIN) |
+#include "components/user_prefs/tracked/registry_hash_store_contents_win.h" |
+#endif |
+ |
+namespace prefs { |
+namespace { |
+ |
+class ValidationDelegatePtrHolder |
tibell
2017/03/08 03:39:54
Document what each class does. I'm guess this is:
|
+ : public base::RefCounted<ValidationDelegatePtrHolder> { |
+ public: |
+ ValidationDelegatePtrHolder(mojom::TrackedPreferenceValidationDelegatePtr ptr) |
+ : ptr_(std::move(ptr)) {} |
+ |
+ mojom::TrackedPreferenceValidationDelegate* get() { return ptr_.get(); } |
+ |
+ private: |
+ friend class base::RefCounted<ValidationDelegatePtrHolder>; |
+ ~ValidationDelegatePtrHolder() = default; |
+ |
+ mojom::TrackedPreferenceValidationDelegatePtr ptr_; |
+}; |
+ |
+class PersistentPrefStoreImpl : public mojom::PersistentPrefStore { |
+ public: |
+ explicit PersistentPrefStoreImpl( |
+ scoped_refptr<::PersistentPrefStore> pref_store); |
+ |
+ ~PersistentPrefStoreImpl() override; |
+ |
+ // mojom::PersistentPrefStore: |
+ void SetValue(const std::string& key, |
+ std::unique_ptr<base::Value> value, |
+ uint32_t flags) override; |
+ |
+ void CommitPendingWrite() override; |
+ void SchedulePendingLossyWrites() override; |
+ void ClearMutableValues() override; |
+ |
+ private: |
+ scoped_refptr<ValidationDelegatePtrHolder> validation_delegate_ref_; |
+ scoped_refptr<::PersistentPrefStore> backing_pref_store_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(PersistentPrefStoreImpl); |
+}; |
+ |
+PersistentPrefStoreImpl::PersistentPrefStoreImpl( |
+ scoped_refptr<::PersistentPrefStore> pref_store) |
+ : backing_pref_store_(std::move(pref_store)) {} |
+ |
+PersistentPrefStoreImpl::~PersistentPrefStoreImpl() = default; |
+ |
+// mojomJsonPrefStore: |
+void PersistentPrefStoreImpl::SetValue(const std::string& key, |
+ std::unique_ptr<base::Value> value, |
+ uint32_t flags) { |
+ if (value) |
+ backing_pref_store_->SetValue(key, std::move(value), flags); |
+ else |
+ backing_pref_store_->RemoveValue(key, flags); |
+} |
+ |
+void PersistentPrefStoreImpl::CommitPendingWrite() { |
+ backing_pref_store_->CommitPendingWrite(); |
+} |
+ |
+void PersistentPrefStoreImpl::SchedulePendingLossyWrites() { |
+ backing_pref_store_->SchedulePendingLossyWrites(); |
+} |
+ |
+void PersistentPrefStoreImpl::ClearMutableValues() { |
+ backing_pref_store_->ClearMutableValues(); |
+} |
+ |
+void CallConnectCallback( |
+ PersistentPrefStore* pref_store, |
tibell
2017/03/08 03:39:54
Should be a scoped_refptr I think.
|
+ const mojom::PersistentPrefStoreConnector::ConnectCallback& callback) { |
+ mojom::PersistentPrefStorePtr pref_store_ptr; |
+ mojo::MakeStrongBinding( |
+ base::MakeUnique<PersistentPrefStoreImpl>(std::move(pref_store)), |
+ mojo::MakeRequest(&pref_store_ptr)); |
+ callback.Run(pref_store->GetReadError(), pref_store->ReadOnly(), |
+ pref_store->IsInitializationComplete() ? pref_store->GetValues() |
+ : nullptr, |
+ std::move(pref_store_ptr)); |
+} |
+ |
+void RemoveValueSilently(const base::WeakPtr<JsonPrefStore> pref_store, |
+ const std::string& key) { |
+ if (pref_store) { |
+ pref_store->RemoveValueSilently( |
+ key, WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS); |
+ } |
+} |
+ |
+std::unique_ptr<PrefHashStore> CreatePrefHashStore( |
+ const std::string& seed, |
+ const std::string& legacy_device_id, |
+ bool use_super_mac) { |
+ return std::unique_ptr<PrefHashStore>( |
tibell
2017/03/08 03:39:54
Would MakeUnique work since the function has a ret
|
+ new PrefHashStoreImpl(seed, legacy_device_id, use_super_mac)); |
+} |
+ |
+std::pair<std::unique_ptr<PrefHashStore>, std::unique_ptr<HashStoreContents>> |
+GetExternalVerificationPrefHashStorePair(const std::string& seed, |
+ const std::string& legacy_device_id, |
+ const base::string16& registry_path, |
+ const base::FilePath& prefs_path) { |
+#if defined(OS_WIN) |
+ return std::make_pair( |
+ base::MakeUnique<PrefHashStoreImpl>(seed, legacy_device_id, |
+ false /* use_super_mac */), |
+ base::MakeUnique<RegistryHashStoreContentsWin>( |
+ registry_path, prefs_path.DirName().BaseName().LossyDisplayName())); |
+#else |
+ return std::make_pair(nullptr, nullptr); |
+#endif |
+} |
+ |
+class PersistentPrefStoreConnectorImpl |
+ : public mojom::PersistentPrefStoreConnector, |
+ public PrefStore::Observer { |
+ public: |
+ PersistentPrefStoreConnectorImpl( |
+ scoped_refptr<PersistentPrefStore> backing_pref_store, |
+ scoped_refptr<ValidationDelegatePtrHolder> validation_delegate) |
+ : backing_pref_store_(backing_pref_store), |
+ validation_delegate_holder_(std::move(validation_delegate)) {} |
+ |
+ ~PersistentPrefStoreConnectorImpl() override = default; |
+ |
+ // mojom::PersistentPrefStoreConnector override: |
+ void Connect(const ConnectCallback& callback) override { |
+ if (backing_pref_store_->IsInitializationComplete()) { |
+ CallConnectCallback(backing_pref_store_.get(), callback); |
+ return; |
+ } |
+ connect_callbacks_.push_back(callback); |
+ if (loading_) |
+ return; |
+ |
+ backing_pref_store_->AddObserver(this); |
+ loading_ = true; |
+ backing_pref_store_->ReadPrefsAsync(nullptr); |
+ } |
+ |
+ static void CreateUserPrefs( |
+ const base::FilePath& pref_filename, |
+ const scoped_refptr<base::SequencedTaskRunner>& io_task_runner, |
+ mojom::PersistentPrefStoreConnectorRequest request) { |
+ mojo::MakeStrongBinding( |
+ base::MakeUnique<PersistentPrefStoreConnectorImpl>( |
+ new JsonPrefStore(pref_filename, io_task_runner, nullptr), nullptr), |
+ std::move(request)); |
+ } |
+ |
+ static void CreateSegregatedUserPrefs( |
+ const base::FilePath& unprotected_pref_filename, |
+ const base::FilePath& protected_pref_filename, |
+ const std::vector<PrefHashFilter::TrackedPreferenceMetadata>& |
+ tracking_configuration, |
+ size_t reporting_ids_count, |
+ const std::string& seed, |
+ const std::string& legacy_device_id, |
+ const base::string16& registry_path, |
+ mojom::TrackedPreferenceValidationDelegatePtrInfo |
+ validation_delegate_info, |
+ const base::Closure& on_reset_on_load, |
+ const scoped_refptr<base::SequencedTaskRunner>& io_task_runner, |
+ mojom::PersistentPrefStoreConnectorRequest request) { |
+ scoped_refptr<ValidationDelegatePtrHolder> validation_delegate_holder( |
tibell
2017/03/08 03:39:54
There's lots of setup going on here. Is this code
|
+ new ValidationDelegatePtrHolder( |
+ mojo::MakeProxy(std::move(validation_delegate_info)))); |
+ std::vector<PrefHashFilter::TrackedPreferenceMetadata> |
+ unprotected_configuration; |
+ std::vector<PrefHashFilter::TrackedPreferenceMetadata> |
+ protected_configuration; |
+ std::set<std::string> protected_pref_names; |
+ std::set<std::string> unprotected_pref_names; |
+ for (const auto& metadata : tracking_configuration) { |
+ if (metadata.enforcement_level > PrefHashFilter::NO_ENFORCEMENT) { |
+ protected_configuration.push_back(metadata); |
+ protected_pref_names.insert(metadata.name); |
+ } else { |
+ unprotected_configuration.push_back(metadata); |
+ unprotected_pref_names.insert(metadata.name); |
+ } |
+ } |
+ |
+ std::unique_ptr<PrefHashFilter> unprotected_pref_hash_filter( |
+ new PrefHashFilter(CreatePrefHashStore(seed, legacy_device_id, false), |
+ GetExternalVerificationPrefHashStorePair( |
+ seed, legacy_device_id, registry_path, |
+ unprotected_pref_filename), |
+ unprotected_configuration, base::Closure(), |
+ validation_delegate_holder->get(), |
+ reporting_ids_count, false)); |
+ std::unique_ptr<PrefHashFilter> protected_pref_hash_filter( |
+ new PrefHashFilter(CreatePrefHashStore(seed, legacy_device_id, true), |
+ GetExternalVerificationPrefHashStorePair( |
+ seed, legacy_device_id, registry_path, |
+ unprotected_pref_filename), |
+ protected_configuration, on_reset_on_load, |
+ validation_delegate_holder->get(), |
+ reporting_ids_count, true)); |
+ |
+ PrefHashFilter* raw_unprotected_pref_hash_filter = |
+ unprotected_pref_hash_filter.get(); |
+ PrefHashFilter* raw_protected_pref_hash_filter = |
+ protected_pref_hash_filter.get(); |
+ |
+ scoped_refptr<JsonPrefStore> unprotected_pref_store( |
+ new JsonPrefStore(unprotected_pref_filename, io_task_runner.get(), |
+ std::move(unprotected_pref_hash_filter))); |
+ scoped_refptr<JsonPrefStore> protected_pref_store( |
+ new JsonPrefStore(protected_pref_filename, io_task_runner.get(), |
+ std::move(protected_pref_hash_filter))); |
+ |
+ SetupTrackedPreferencesMigration( |
+ unprotected_pref_names, protected_pref_names, |
+ base::Bind(&RemoveValueSilently, unprotected_pref_store->AsWeakPtr()), |
+ base::Bind(&RemoveValueSilently, protected_pref_store->AsWeakPtr()), |
+ base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteReply, |
+ unprotected_pref_store->AsWeakPtr()), |
+ base::Bind(&JsonPrefStore::RegisterOnNextSuccessfulWriteReply, |
+ protected_pref_store->AsWeakPtr()), |
+ CreatePrefHashStore(seed, legacy_device_id, false), |
+ CreatePrefHashStore(seed, legacy_device_id, true), |
+ raw_unprotected_pref_hash_filter, raw_protected_pref_hash_filter); |
+ |
+ mojo::MakeStrongBinding( |
+ base::MakeUnique<PersistentPrefStoreConnectorImpl>( |
+ new SegregatedPrefStore(unprotected_pref_store, |
+ protected_pref_store, protected_pref_names), |
+ std::move(validation_delegate_holder)), |
+ std::move(request)); |
+ } |
+ |
+ private: |
+ void OnPrefValueChanged(const std::string& key) override {} |
tibell
2017/03/08 03:39:54
Add a comment why it's OK to ignore this.
|
+ |
+ void OnInitializationCompleted(bool succeeded) override { |
+ loading_ = false; |
+ backing_pref_store_->RemoveObserver(this); |
+ for (const auto& callback : connect_callbacks_) { |
+ CallConnectCallback(backing_pref_store_.get(), callback); |
+ } |
+ connect_callbacks_.clear(); |
+ } |
+ |
+ scoped_refptr<PersistentPrefStore> backing_pref_store_; |
+ scoped_refptr<ValidationDelegatePtrHolder> validation_delegate_holder_; |
+ |
+ bool loading_ = false; |
+ std::vector<ConnectCallback> connect_callbacks_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(PersistentPrefStoreConnectorImpl); |
+}; |
+ |
+} // namespace |
+ |
+void CreateUserPrefs( |
+ const base::FilePath& pref_filename, |
+ const scoped_refptr<base::SingleThreadTaskRunner>& connection_task_runner, |
+ const scoped_refptr<base::SequencedTaskRunner>& io_task_runner, |
+ mojom::PersistentPrefStoreConnectorRequest request) { |
+ connection_task_runner->PostTask( |
+ FROM_HERE, |
+ base::Bind(&PersistentPrefStoreConnectorImpl::CreateUserPrefs, |
+ pref_filename, io_task_runner, base::Passed(&request))); |
+} |
+ |
+void CreateSegregatedUserPrefs( |
+ const base::FilePath& unprotected_pref_filename, |
+ const base::FilePath& protected_pref_filename, |
+ const std::vector<PrefHashFilter::TrackedPreferenceMetadata>& |
+ tracking_configuration, |
+ size_t reporting_ids_count, |
+ const std::string& seed, |
+ const std::string& legacy_device_id, |
+ const base::string16& registry_path, |
+ mojom::TrackedPreferenceValidationDelegatePtr validation_delegate, |
+ const base::Closure& on_reset_on_load, |
+ const scoped_refptr<base::SingleThreadTaskRunner>& connection_task_runner, |
+ const scoped_refptr<base::SequencedTaskRunner>& io_task_runner, |
+ mojom::PersistentPrefStoreConnectorRequest request) { |
+ connection_task_runner->PostTask( |
+ FROM_HERE, |
+ base::Bind(&PersistentPrefStoreConnectorImpl::CreateSegregatedUserPrefs, |
+ unprotected_pref_filename, protected_pref_filename, |
+ tracking_configuration, reporting_ids_count, seed, |
+ legacy_device_id, registry_path, |
+ base::Passed(validation_delegate.PassInterface()), |
+ on_reset_on_load, io_task_runner, base::Passed(&request))); |
+} |
+ |
+} // namespace prefs |