Pref service: Merge connectors and send a PrefRegistry in Connect().

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/threading/thread_restrictions.h"
 #include "base/values.h"
+#include "components/prefs/pref_registry.h"
 #include "mojo/public/cpp/bindings/sync_call_restrictions.h"
 
 namespace prefs {
+namespace {
+
+mojom::PrefRegistryPtr WrapPrefRegistry(PrefRegistry& pref_registry) {
+  auto registry = mojom::PrefRegistry::New();
+  for (auto& pref : pref_registry) {
+    auto registration = mojom::PrefRegistration::New();
+    registration->set_owning_registration(mojom::OwningPrefRegistration::New(
+        pref.second->CreateDeepCopy(),
+        pref_registry.GetRegistrationFlags(pref.first)));
+    registry->registrations[pref.first] = std::move(registration);
+  }
+  return registry;
+}
+
+}  // namespace
 
 PersistentPrefStoreClient::PersistentPrefStoreClient(
-    mojom::PersistentPrefStoreConnectorPtr connector)
-    : connector_(std::move(connector)) {}
+    mojom::PrefStoreConnectorPtr connector,
+    scoped_refptr<PrefRegistry> pref_registry)
+    : connector_(std::move(connector)),
+      pref_registry_(std::move(pref_registry)) {
+  DCHECK(connector_);
+}
+
+PersistentPrefStoreClient::PersistentPrefStoreClient(
+    mojom::PersistentPrefStoreConnectionPtr connection) {
+  OnCreateComplete(std::move(connection),
+                   std::unordered_map<PrefValueStore::PrefStoreType,
+                                      prefs::mojom::PrefStoreConnectionPtr>());
+}
 
 void PersistentPrefStoreClient::SetValue(const std::string& key,
                                          std::unique_ptr<base::Value> value,
                                          uint32_t flags) {
   base::Value* old_value = nullptr;
   GetMutableValues().Get(key, &old_value);
   if (!old_value || !value->Equals(old_value)) {
     GetMutableValues().Set(key, std::move(value));
     ReportValueChanged(key, flags);
   }
@@ skipping 32 matching lines @@
 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;
+  mojom::PersistentPrefStoreConnectionPtr connection;
+  std::unordered_map<PrefValueStore::PrefStoreType,
+                     prefs::mojom::PrefStoreConnectionPtr>
+      other_pref_stores;
   base::ThreadRestrictions::AssertWaitAllowed();
   mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_calls;
-  if (!connector_->Connect(&read_error, &read_only, &local_prefs, &pref_store,
-                           &observer_request)) {
+  if (!connector_->Connect(WrapPrefRegistry(*pref_registry_), &connection,
+                           &other_pref_stores)) {
     NOTREACHED();
   }
 
-  OnCreateComplete(read_error, read_only, std::move(local_prefs),
-                   std::move(pref_store), std::move(observer_request));
+  OnCreateComplete(std::move(connection), std::move(other_pref_stores));
   return read_error_;
 }
 
 void PersistentPrefStoreClient::ReadPrefsAsync(
     ReadErrorDelegate* error_delegate) {
   error_delegate_.reset(error_delegate);
-  connector_->Connect(base::Bind(&PersistentPrefStoreClient::OnCreateComplete,
+  connector_->Connect(WrapPrefRegistry(*pref_registry_),
+                      base::Bind(&PersistentPrefStoreClient::OnCreateComplete,
                                  base::Unretained(this)));
 }
 
 void PersistentPrefStoreClient::CommitPendingWrite() {
   DCHECK(pref_store_);
   pref_store_->CommitPendingWrite();
 }
 
 void PersistentPrefStoreClient::SchedulePendingLossyWrites() {
   DCHECK(pref_store_);
   return pref_store_->SchedulePendingLossyWrites();
 }
 
 void PersistentPrefStoreClient::ClearMutableValues() {
   DCHECK(pref_store_);
   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> cached_prefs,
-    mojom::PersistentPrefStorePtr pref_store,
-    mojom::PrefStoreObserverRequest observer_request) {
+    mojom::PersistentPrefStoreConnectionPtr connection,
+    std::unordered_map<PrefValueStore::PrefStoreType,
+                       prefs::mojom::PrefStoreConnectionPtr>
+        other_pref_stores) {
+  DCHECK(other_pref_stores.empty());
   connector_.reset();
-  read_error_ = read_error;
-  read_only_ = read_only;
-  pref_store_ = std::move(pref_store);
+  read_error_ = connection->read_error;
+  read_only_ = connection->read_only;
+  pref_store_ = std::move(connection->pref_store);
   if (error_delegate_ && read_error_ != PREF_READ_ERROR_NONE)
     error_delegate_->OnError(read_error_);
   error_delegate_.reset();
 
-  Init(std::move(cached_prefs), true, std::move(observer_request));
+  if (connection->pref_store_connection) {
+    Init(std::move(connection->pref_store_connection->initial_prefs), true,
+         std::move(connection->pref_store_connection->observer));
+  } else {
+    Init(nullptr, false, nullptr);
+  }
 }
 
 }  // namespace prefs