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

services/preferences/public/cpp/persistent_pref_store_client.cc

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
index 74c9b116fbd7d9bae66fe0bc950077ad0f9e36bc..ccd1e9f2c1361efa46c7d03d7074a96245d474dc 100644
--- a/services/preferences/public/cpp/persistent_pref_store_client.cc
+++ b/services/preferences/public/cpp/persistent_pref_store_client.cc
@@ -8,13 +8,40 @@
 
 #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::PrefStoreConnectorPtr connector,
+    scoped_refptr<PrefRegistry> pref_registry)
+    : connector_(std::move(connector)),
+      pref_registry_(std::move(pref_registry)) {
+  DCHECK(connector_);
+}
 
 PersistentPrefStoreClient::PersistentPrefStoreClient(
-    mojom::PersistentPrefStoreConnectorPtr connector)
-    : connector_(std::move(connector)) {}
+    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,
@@ -67,27 +94,26 @@ PersistentPrefStore::PrefReadError PersistentPrefStoreClient::GetReadError()
 }
 
 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)));
 }
 
@@ -114,20 +140,25 @@ PersistentPrefStoreClient::~PersistentPrefStoreClient() {
 }
 
 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