Convert PrefStoreConnector to new Mojo types

This CL converts PrefStoreConnectorPtr and
PrefStoreConnectorRequest to new Mojo types.

It also updates RefCountedInterfacePtr to
RefCountedRemote to use mojo::Remote.

Bug: 955171
Change-Id: Ib9cdf05a731bae104fd096133e98b426d00f1064
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1808964Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Sam McNally <sammc@chromium.org>
Reviewed-by: Xiyuan Xia <xiyuan@chromium.org>
Commit-Queue: Julie Kim <jkim@igalia.com>
Cr-Commit-Position: refs/heads/master@{#698754}

chromeos/services/assistant/pref_connection_delegate.cc

@@ -15,8 +15,7 @@ void PrefConnectionDelegate::ConnectToPrefService(
     mojo::PendingRemote<prefs::mojom::PrefStoreConnector> connector,
     scoped_refptr<PrefRegistrySimple> pref_registry,
     prefs::ConnectCallback callback) {
-  prefs::mojom::PrefStoreConnectorPtr ptr(std::move(connector));
-  ::prefs::ConnectToPrefService(std::move(ptr), std::move(pref_registry),
+  ::prefs::ConnectToPrefService(std::move(connector), std::move(pref_registry),
                                 base::Token::CreateRandom(), callback);
 }
 

chromeos/services/device_sync/device_sync_impl.cc

@@ -242,10 +242,9 @@ void DeviceSyncImpl::PrefConnectionDelegate::ConnectToPrefService(
     mojo::PendingRemote<prefs::mojom::PrefStoreConnector> pref_store_connector,
     scoped_refptr<PrefRegistrySimple> pref_registry,
     prefs::ConnectCallback callback) {
-  prefs::ConnectToPrefService(
-      prefs::mojom::PrefStoreConnectorPtr(std::move(pref_store_connector)),
-      std::move(pref_registry), base::Token::CreateRandom(),
-      std::move(callback));
+  prefs::ConnectToPrefService(std::move(pref_store_connector),
+                              std::move(pref_registry),
+                              base::Token::CreateRandom(), std::move(callback));
 }
 
 DeviceSyncImpl::PendingSetSoftwareFeatureRequest::

services/preferences/pref_store_manager_impl.cc

@@ -79,7 +79,7 @@ PrefStoreManagerImpl::PrefStoreManagerImpl(
           base::WrapRefCounted(pref_registry))) {
   // This store is done in-process so it's already "registered":
   registry_.AddInterface<prefs::mojom::PrefStoreConnector>(
-      base::Bind(&PrefStoreManagerImpl::BindPrefStoreConnectorRequest,
+      base::Bind(&PrefStoreManagerImpl::BindPrefStoreConnectorReceiver,
                  base::Unretained(this)));
   persistent_pref_store_ = std::make_unique<PersistentPrefStoreImpl>(
       base::WrapRefCounted(user_prefs),
@@ -111,12 +111,12 @@ base::OnceClosure PrefStoreManagerImpl::ShutDownClosure() {
                         weak_factory_.GetWeakPtr());
 }
 
-void PrefStoreManagerImpl::BindPrefStoreConnectorRequest(
-    prefs::mojom::PrefStoreConnectorRequest request,
+void PrefStoreManagerImpl::BindPrefStoreConnectorReceiver(
+    mojo::PendingReceiver<prefs::mojom::PrefStoreConnector> receiver,
     const service_manager::BindSourceInfo& source_info) {
-  connector_bindings_.AddBinding(
+  connector_receivers_.Add(
       std::make_unique<ConnectorConnection>(this, source_info),
-      std::move(request));
+      std::move(receiver));
 }
 
 void PrefStoreManagerImpl::OnBindInterface(

services/preferences/pref_store_manager_impl.h

@@ -14,8 +14,8 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "components/prefs/pref_value_store.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
-#include "mojo/public/cpp/bindings/strong_binding_set.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/unique_receiver_set.h"
 #include "services/preferences/public/mojom/preferences.mojom.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/service.h"
@@ -57,8 +57,8 @@ class PrefStoreManagerImpl : public service_manager::Service {
  private:
   class ConnectorConnection;
 
-  void BindPrefStoreConnectorRequest(
-      prefs::mojom::PrefStoreConnectorRequest request,
+  void BindPrefStoreConnectorReceiver(
+      mojo::PendingReceiver<prefs::mojom::PrefStoreConnector> receiver,
       const service_manager::BindSourceInfo& source_info);
 
   // service_manager::Service:
@@ -79,7 +79,7 @@ class PrefStoreManagerImpl : public service_manager::Service {
   base::flat_map<PrefValueStore::PrefStoreType, std::unique_ptr<PrefStoreImpl>>
       read_only_pref_stores_;
 
-  mojo::StrongBindingSet<mojom::PrefStoreConnector> connector_bindings_;
+  mojo::UniqueReceiverSet<mojom::PrefStoreConnector> connector_receivers_;
   std::unique_ptr<PersistentPrefStoreImpl> persistent_pref_store_;
   std::unique_ptr<PersistentPrefStoreImpl>
       incognito_persistent_pref_store_underlay_;

services/preferences/public/cpp/pref_service_factory.cc

@@ -16,6 +16,7 @@
 #include "components/prefs/pref_registry.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/pref_value_store.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "services/preferences/public/cpp/persistent_pref_store_client.h"
 #include "services/preferences/public/cpp/pref_registry_serializer.h"
 #include "services/preferences/public/cpp/pref_store_client.h"
@@ -27,19 +28,18 @@ namespace {
 
 // Used to implement a "fire and forget" pattern where we call an interface
 // method, with an attached error handler, but don't care to hold on to the
-// InterfacePtr after.
+// Remote after.
 template <typename Interface>
-class RefCountedInterfacePtr
-    : public base::RefCounted<RefCountedInterfacePtr<Interface>> {
+class RefCountedRemote : public base::RefCounted<RefCountedRemote<Interface>> {
  public:
-  mojo::InterfacePtr<Interface>& get() { return ptr_; }
-  void reset() { ptr_.reset(); }
+  mojo::Remote<Interface>& get() { return remote_; }
+  void reset() { remote_.reset(); }
 
  private:
-  friend class base::RefCounted<RefCountedInterfacePtr<Interface>>;
-  ~RefCountedInterfacePtr() = default;
+  friend class base::RefCounted<RefCountedRemote<Interface>>;
+  ~RefCountedRemote() = default;
 
-  mojo::InterfacePtr<Interface> ptr_;
+  mojo::Remote<Interface> remote_;
 };
 
 scoped_refptr<PrefStore> CreatePrefStoreClient(
@@ -74,8 +74,7 @@ void RegisterRemoteDefaults(PrefRegistry* pref_registry,
 }
 
 void OnConnect(
-    scoped_refptr<RefCountedInterfacePtr<mojom::PrefStoreConnector>>
-        connector_ptr,
+    scoped_refptr<RefCountedRemote<mojom::PrefStoreConnector>> connector_remote,
     scoped_refptr<PrefRegistry> pref_registry,
     ConnectCallback callback,
     mojom::PersistentPrefStoreConnectionPtr persistent_pref_store_connection,
@@ -135,32 +134,33 @@ void OnConnect(
       callback.Run(nullptr);
       break;
   }
-  connector_ptr->reset();
+  connector_remote->reset();
 }
 
-void OnConnectError(
-    scoped_refptr<RefCountedInterfacePtr<mojom::PrefStoreConnector>>
-        connector_ptr,
+void OnMojoDisconnect(
+    scoped_refptr<RefCountedRemote<mojom::PrefStoreConnector>> connector_remote,
     ConnectCallback callback) {
   callback.Run(nullptr);
-  connector_ptr->reset();
+  connector_remote->reset();
 }
 
 }  // namespace
 
-void ConnectToPrefService(mojom::PrefStoreConnectorPtr connector,
-                          scoped_refptr<PrefRegistry> pref_registry,
-                          base::Optional<base::Token> client_token,
-                          ConnectCallback callback) {
-  auto connector_ptr =
-      base::MakeRefCounted<RefCountedInterfacePtr<mojom::PrefStoreConnector>>();
-  connector_ptr->get() = std::move(connector);
-  connector_ptr->get().set_connection_error_handler(base::Bind(
-      &OnConnectError, connector_ptr, base::Passed(ConnectCallback{callback})));
+void ConnectToPrefService(
+    mojo::PendingRemote<mojom::PrefStoreConnector> connector,
+    scoped_refptr<PrefRegistry> pref_registry,
+    base::Optional<base::Token> client_token,
+    ConnectCallback callback) {
+  auto connector_remote =
+      base::MakeRefCounted<RefCountedRemote<mojom::PrefStoreConnector>>();
+  connector_remote->get().Bind(std::move(connector));
+  connector_remote->get().set_disconnect_handler(
+      base::Bind(&OnMojoDisconnect, connector_remote,
+                 base::Passed(ConnectCallback{callback})));
   auto serialized_pref_registry = SerializePrefRegistry(*pref_registry);
-  connector_ptr->get()->Connect(
+  connector_remote->get()->Connect(
       std::move(serialized_pref_registry), client_token,
-      base::BindOnce(&OnConnect, connector_ptr, std::move(pref_registry),
+      base::BindOnce(&OnConnect, connector_remote, std::move(pref_registry),
                      std::move(callback)));
 }
 
@@ -168,8 +168,9 @@ void ConnectToPrefService(service_manager::Connector* connector,
                           scoped_refptr<PrefRegistry> pref_registry,
                           ConnectCallback callback,
                           base::StringPiece service_name) {
-  mojom::PrefStoreConnectorPtr pref_connector;
-  connector->BindInterface(service_name.as_string(), &pref_connector);
+  mojo::PendingRemote<mojom::PrefStoreConnector> pref_connector;
+  connector->Connect(service_name.as_string(),
+                     pref_connector.InitWithNewPipeAndPassReceiver());
   ConnectToPrefService(std::move(pref_connector), std::move(pref_registry),
                        base::nullopt, std::move(callback));
 }

services/preferences/public/cpp/pref_service_factory.h

@@ -17,6 +17,7 @@
 #include "base/optional.h"
 #include "base/token.h"
 #include "components/prefs/pref_value_store.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "services/preferences/public/mojom/preferences.mojom.h"
 
 class PrefRegistry;
@@ -40,10 +41,11 @@ using ConnectCallback = base::Callback<void(std::unique_ptr<::PrefService>)>;
 // |client_token| uniquely identifies the client, fixing it to a specific set of
 // observed prefs; if not provided, the Service Manager Identity used to acquire
 // |connector| will be used for that purpose instead.
-void ConnectToPrefService(mojom::PrefStoreConnectorPtr connector,
-                          scoped_refptr<PrefRegistry> pref_registry,
-                          base::Optional<base::Token> client_token,
-                          ConnectCallback callback);
+void ConnectToPrefService(
+    mojo::PendingRemote<mojom::PrefStoreConnector> connector,
+    scoped_refptr<PrefRegistry> pref_registry,
+    base::Optional<base::Token> client_token,
+    ConnectCallback callback);
 
 // Create a |PrefService| object acting as a client library for the pref
 // service, by connecting to the service using |connector|. Connecting is