Migrate device_sync.mojom to the new Mojo types

Convert the implementation and all users of the
chromeos::device_sync::mojom::DeviceSyncObserver and DeviceSync
interfaces.

Bug: 955171
Change-Id: Ic5550b1e42d977c35c082f35eb86e3e024e62327
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1856970
Commit-Queue: Henrique Ferreiro <hferreiro@igalia.com>
Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Emily Stark <estark@chromium.org>
Reviewed-by: Ryan Hansberry <hansberry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#709004}

chrome/browser/chromeos/device_sync/device_sync_client_factory.cc

@@ -57,9 +57,9 @@ class DeviceSyncClientHolder : public KeyedService {
             Profile::FromBrowserContext(context))),
         device_sync_client_(
             DeviceSyncClientImpl::Factory::Get()->BuildInstance()) {
-    // Connect the client's mojo interface pointer to the implementation.
-    device_sync_->BindRequest(
-        mojo::MakeRequest(device_sync_client_->GetDeviceSyncPtr()));
+    // Connect the client's mojo remote to the implementation.
+    device_sync_->BindReceiver(device_sync_client_->GetDeviceSyncRemote()
+                                   ->BindNewPipeAndPassReceiver());
     // Finish client initialization.
     device_sync_client_->Initialize(base::ThreadTaskRunnerHandle::Get());
   }
@@ -70,7 +70,7 @@ class DeviceSyncClientHolder : public KeyedService {
   // KeyedService:
   void Shutdown() override {
     device_sync_client_.reset();
-    device_sync_->CloseAllBindings();
+    device_sync_->CloseAllReceivers();
     device_sync_.reset();
   }
 

chromeos/services/device_sync/device_sync_base.cc

@@ -14,38 +14,41 @@ namespace chromeos {
 namespace device_sync {
 
 DeviceSyncBase::DeviceSyncBase() {
-  bindings_.set_connection_error_handler(base::BindRepeating(
+  receivers_.set_disconnect_handler(base::BindRepeating(
       &DeviceSyncBase::OnDisconnection, base::Unretained(this)));
 }
 
 DeviceSyncBase::~DeviceSyncBase() = default;
 
-void DeviceSyncBase::AddObserver(mojom::DeviceSyncObserverPtr observer,
-                                 AddObserverCallback callback) {
-  observers_.AddPtr(std::move(observer));
+void DeviceSyncBase::AddObserver(
+    mojo::PendingRemote<mojom::DeviceSyncObserver> observer,
+    AddObserverCallback callback) {
+  observers_.Add(std::move(observer));
   std::move(callback).Run();
 }
 
-void DeviceSyncBase::BindRequest(mojom::DeviceSyncRequest request) {
-  bindings_.AddBinding(this, std::move(request));
+void DeviceSyncBase::BindReceiver(
+    mojo::PendingReceiver<mojom::DeviceSync> receiver) {
+  receivers_.Add(this, std::move(receiver));
 }
 
-void DeviceSyncBase::CloseAllBindings() {
-  bindings_.CloseAllBindings();
+void DeviceSyncBase::CloseAllReceivers() {
+  receivers_.Clear();
 }
 
 void DeviceSyncBase::NotifyOnEnrollmentFinished() {
-  observers_.ForAllPtrs(
-      [](auto* observer) { observer->OnEnrollmentFinished(); });
+  for (auto& observer : observers_)
+    observer->OnEnrollmentFinished();
 }
 
 void DeviceSyncBase::NotifyOnNewDevicesSynced() {
-  observers_.ForAllPtrs([](auto* observer) { observer->OnNewDevicesSynced(); });
+  for (auto& observer : observers_)
+    observer->OnNewDevicesSynced();
 }
 
 void DeviceSyncBase::OnDisconnection() {
   // If all clients have disconnected, shut down.
-  if (bindings_.empty())
+  if (receivers_.empty())
     Shutdown();
 }
 

chromeos/services/device_sync/device_sync_base.h

@@ -9,8 +9,10 @@
 
 #include "base/macros.h"
 #include "chromeos/services/device_sync/public/mojom/device_sync.mojom.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
-#include "mojo/public/cpp/bindings/interface_ptr_set.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
+#include "mojo/public/cpp/bindings/remote_set.h"
 
 namespace chromeos {
 
@@ -22,14 +24,14 @@ class DeviceSyncBase : public mojom::DeviceSync {
   ~DeviceSyncBase() override;
 
   // mojom::DeviceSync:
-  void AddObserver(mojom::DeviceSyncObserverPtr observer,
+  void AddObserver(mojo::PendingRemote<mojom::DeviceSyncObserver> observer,
                    AddObserverCallback callback) override;
 
-  // Binds a request to this implementation. Should be called each time that the
-  // service receives a request.
-  void BindRequest(mojom::DeviceSyncRequest request);
+  // Binds a receiver to this implementation. Should be called each time that
+  // the service receives a receiver.
+  void BindReceiver(mojo::PendingReceiver<mojom::DeviceSync> receiver);
 
-  void CloseAllBindings();
+  void CloseAllReceivers();
 
  protected:
   DeviceSyncBase();
@@ -44,8 +46,8 @@ class DeviceSyncBase : public mojom::DeviceSync {
  private:
   void OnDisconnection();
 
-  mojo::InterfacePtrSet<mojom::DeviceSyncObserver> observers_;
-  mojo::BindingSet<mojom::DeviceSync> bindings_;
+  mojo::RemoteSet<mojom::DeviceSyncObserver> observers_;
+  mojo::ReceiverSet<mojom::DeviceSync> receivers_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceSyncBase);
 };

chromeos/services/device_sync/device_sync_service_unittest.cc

@@ -861,7 +861,7 @@ class DeviceSyncServiceTest : public ::testing::TestWithParam<bool> {
   void CallAddObserver() {
     base::RunLoop run_loop;
     device_sync_->AddObserver(
-        fake_device_sync_observer_->GenerateInterfacePtr(),
+        fake_device_sync_observer_->GenerateRemote(),
         base::BindOnce(&DeviceSyncServiceTest::OnAddObserverCompleted,
                        base::Unretained(this), run_loop.QuitClosure()));
     run_loop.Run();

chromeos/services/device_sync/fake_device_sync_observer.cc

@@ -12,10 +12,11 @@ FakeDeviceSyncObserver::FakeDeviceSyncObserver() = default;
 
 FakeDeviceSyncObserver::~FakeDeviceSyncObserver() = default;
 
-mojom::DeviceSyncObserverPtr FakeDeviceSyncObserver::GenerateInterfacePtr() {
-  mojom::DeviceSyncObserverPtr interface_ptr;
-  bindings_.AddBinding(this, mojo::MakeRequest(&interface_ptr));
-  return interface_ptr;
+mojo::PendingRemote<mojom::DeviceSyncObserver>
+FakeDeviceSyncObserver::GenerateRemote() {
+  mojo::PendingRemote<mojom::DeviceSyncObserver> remote;
+  receivers_.Add(this, remote.InitWithNewPipeAndPassReceiver());
+  return remote;
 }
 
 void FakeDeviceSyncObserver::OnEnrollmentFinished() {

chromeos/services/device_sync/fake_device_sync_observer.h

@@ -7,7 +7,8 @@
 
 #include "base/macros.h"
 #include "chromeos/services/device_sync/public/mojom/device_sync.mojom.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
 
 namespace chromeos {
 
@@ -19,7 +20,7 @@ class FakeDeviceSyncObserver : public mojom::DeviceSyncObserver {
   FakeDeviceSyncObserver();
   ~FakeDeviceSyncObserver() override;
 
-  mojom::DeviceSyncObserverPtr GenerateInterfacePtr();
+  mojo::PendingRemote<mojom::DeviceSyncObserver> GenerateRemote();
 
   size_t num_enrollment_events() { return num_enrollment_events_; }
   size_t num_sync_events() { return num_sync_events_; }
@@ -32,7 +33,7 @@ class FakeDeviceSyncObserver : public mojom::DeviceSyncObserver {
   size_t num_enrollment_events_ = 0u;
   size_t num_sync_events_ = 0u;
 
-  mojo::BindingSet<mojom::DeviceSyncObserver> bindings_;
+  mojo::ReceiverSet<mojom::DeviceSyncObserver> receivers_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeDeviceSyncObserver);
 };

chromeos/services/device_sync/public/cpp/device_sync_client.cc

@@ -12,7 +12,7 @@ DeviceSyncClient::DeviceSyncClient() = default;
 
 DeviceSyncClient::~DeviceSyncClient() = default;
 
-mojom::DeviceSyncPtr* DeviceSyncClient::GetDeviceSyncPtr() {
+mojo::Remote<mojom::DeviceSync>* DeviceSyncClient::GetDeviceSyncRemote() {
   return nullptr;
 }
 

chromeos/services/device_sync/public/cpp/device_sync_client.h

@@ -16,6 +16,7 @@
 #include "chromeos/components/multidevice/remote_device_ref.h"
 #include "chromeos/components/multidevice/software_feature.h"
 #include "chromeos/services/device_sync/public/mojom/device_sync.mojom.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace base {
 class TaskRunner;
@@ -53,11 +54,11 @@ class DeviceSyncClient {
   virtual ~DeviceSyncClient();
 
   // Completes initialization. Must be called after connecting the DeviceSync
-  // mojo interface pointer to the implementation.
+  // mojo remote to the implementation.
   virtual void Initialize(scoped_refptr<base::TaskRunner> task_runner) {}
 
-  // Returns the DeviceSync mojo interface pointer.
-  virtual mojom::DeviceSyncPtr* GetDeviceSyncPtr();
+  // Returns the DeviceSync mojo remote.
+  virtual mojo::Remote<mojom::DeviceSync>* GetDeviceSyncRemote();
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);

chromeos/services/device_sync/public/cpp/device_sync_client_impl.cc

@@ -46,15 +46,14 @@ DeviceSyncClientImpl::Factory::BuildInstance() {
 }
 
 DeviceSyncClientImpl::DeviceSyncClientImpl()
-    : observer_binding_(this),
-      expiring_device_cache_(
+    : expiring_device_cache_(
           std::make_unique<multidevice::ExpiringRemoteDeviceCache>()) {}
 
 DeviceSyncClientImpl::~DeviceSyncClientImpl() = default;
 
 void DeviceSyncClientImpl::Initialize(
     scoped_refptr<base::TaskRunner> task_runner) {
-  device_sync_ptr_->AddObserver(GenerateInterfacePtr(), base::OnceClosure());
+  device_sync_->AddObserver(GenerateRemote(), base::OnceClosure());
 
   // Delay calling these until after initialization finishes.
   task_runner->PostTask(
@@ -65,8 +64,8 @@ void DeviceSyncClientImpl::Initialize(
                                        weak_ptr_factory_.GetWeakPtr()));
 }
 
-mojom::DeviceSyncPtr* DeviceSyncClientImpl::GetDeviceSyncPtr() {
-  return &device_sync_ptr_;
+mojo::Remote<mojom::DeviceSync>* DeviceSyncClientImpl::GetDeviceSyncRemote() {
+  return &device_sync_;
 }
 
 void DeviceSyncClientImpl::OnEnrollmentFinished() {
@@ -86,12 +85,12 @@ void DeviceSyncClientImpl::OnNewDevicesSynced() {
 
 void DeviceSyncClientImpl::ForceEnrollmentNow(
     mojom::DeviceSync::ForceEnrollmentNowCallback callback) {
-  device_sync_ptr_->ForceEnrollmentNow(std::move(callback));
+  device_sync_->ForceEnrollmentNow(std::move(callback));
 }
 
 void DeviceSyncClientImpl::ForceSyncNow(
     mojom::DeviceSync::ForceSyncNowCallback callback) {
-  device_sync_ptr_->ForceSyncNow(std::move(callback));
+  device_sync_->ForceSyncNow(std::move(callback));
 }
 
 multidevice::RemoteDeviceRefList DeviceSyncClientImpl::GetSyncedDevices() {
@@ -113,14 +112,14 @@ void DeviceSyncClientImpl::SetSoftwareFeatureState(
     bool enabled,
     bool is_exclusive,
     mojom::DeviceSync::SetSoftwareFeatureStateCallback callback) {
-  device_sync_ptr_->SetSoftwareFeatureState(
-      public_key, software_feature, enabled, is_exclusive, std::move(callback));
+  device_sync_->SetSoftwareFeatureState(public_key, software_feature, enabled,
+                                        is_exclusive, std::move(callback));
 }
 
 void DeviceSyncClientImpl::FindEligibleDevices(
     multidevice::SoftwareFeature software_feature,
     FindEligibleDevicesCallback callback) {
-  device_sync_ptr_->FindEligibleDevices(
+  device_sync_->FindEligibleDevices(
       software_feature,
       base::BindOnce(&DeviceSyncClientImpl::OnFindEligibleDevicesCompleted,
                      weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
@@ -128,12 +127,12 @@ void DeviceSyncClientImpl::FindEligibleDevices(
 
 void DeviceSyncClientImpl::GetDevicesActivityStatus(
     mojom::DeviceSync::GetDevicesActivityStatusCallback callback) {
-  device_sync_ptr_->GetDevicesActivityStatus(std::move(callback));
+  device_sync_->GetDevicesActivityStatus(std::move(callback));
 }
 
 void DeviceSyncClientImpl::GetDebugInfo(
     mojom::DeviceSync::GetDebugInfoCallback callback) {
-  device_sync_ptr_->GetDebugInfo(std::move(callback));
+  device_sync_->GetDebugInfo(std::move(callback));
 }
 
 void DeviceSyncClientImpl::AttemptToBecomeReady() {
@@ -156,13 +155,13 @@ void DeviceSyncClientImpl::AttemptToBecomeReady() {
 }
 
 void DeviceSyncClientImpl::LoadSyncedDevices() {
-  device_sync_ptr_->GetSyncedDevices(
+  device_sync_->GetSyncedDevices(
       base::BindOnce(&DeviceSyncClientImpl::OnGetSyncedDevicesCompleted,
                      weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DeviceSyncClientImpl::LoadLocalDeviceMetadata() {
-  device_sync_ptr_->GetLocalDeviceMetadata(
+  device_sync_->GetLocalDeviceMetadata(
       base::BindOnce(&DeviceSyncClientImpl::OnGetLocalDeviceMetadataCompleted,
                      weak_ptr_factory_.GetWeakPtr()));
 }
@@ -243,14 +242,13 @@ void DeviceSyncClientImpl::OnFindEligibleDevicesCompleted(
   std::move(callback).Run(result_code, eligible_devices, ineligible_devices);
 }
 
-mojom::DeviceSyncObserverPtr DeviceSyncClientImpl::GenerateInterfacePtr() {
-  mojom::DeviceSyncObserverPtr interface_ptr;
-  observer_binding_.Bind(mojo::MakeRequest(&interface_ptr));
-  return interface_ptr;
+mojo::PendingRemote<mojom::DeviceSyncObserver>
+DeviceSyncClientImpl::GenerateRemote() {
+  return observer_receiver_.BindNewPipeAndPassRemote();
 }
 
 void DeviceSyncClientImpl::FlushForTesting() {
-  device_sync_ptr_.FlushForTesting();
+  device_sync_.FlushForTesting();
 }
 
 }  // namespace device_sync

chromeos/services/device_sync/public/cpp/device_sync_client_impl.h

@@ -18,7 +18,9 @@
 #include "chromeos/components/multidevice/software_feature.h"
 #include "chromeos/services/device_sync/public/cpp/device_sync_client.h"
 #include "chromeos/services/device_sync/public/mojom/device_sync.mojom.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
+#include "mojo/public/cpp/bindings/remote.h"
 
 namespace base {
 class TaskRunner;
@@ -51,7 +53,7 @@ class DeviceSyncClientImpl : public DeviceSyncClient,
   ~DeviceSyncClientImpl() override;
 
   void Initialize(scoped_refptr<base::TaskRunner> task_runner) override;
-  mojom::DeviceSyncPtr* GetDeviceSyncPtr() override;
+  mojo::Remote<mojom::DeviceSync>* GetDeviceSyncRemote() override;
 
   // DeviceSyncClient:
   void ForceEnrollmentNow(
@@ -94,12 +96,12 @@ class DeviceSyncClientImpl : public DeviceSyncClient,
       mojom::NetworkRequestResult result_code,
       mojom::FindEligibleDevicesResponsePtr response);
 
-  mojom::DeviceSyncObserverPtr GenerateInterfacePtr();
+  mojo::PendingRemote<mojom::DeviceSyncObserver> GenerateRemote();
 
   void FlushForTesting();
 
-  mojom::DeviceSyncPtr device_sync_ptr_;
-  mojo::Binding<mojom::DeviceSyncObserver> observer_binding_;
+  mojo::Remote<mojom::DeviceSync> device_sync_;
+  mojo::Receiver<mojom::DeviceSyncObserver> observer_receiver_{this};
   std::unique_ptr<multidevice::ExpiringRemoteDeviceCache>
       expiring_device_cache_;
 

chromeos/services/device_sync/public/cpp/device_sync_client_impl_unittest.cc

@@ -183,7 +183,8 @@ class DeviceSyncClientImplTest : public testing::Test {
     // the TaskRunner so that the tasks can be run via a RunLoop later on.
     auto test_task_runner = base::MakeRefCounted<base::TestSimpleTaskRunner>();
     client_ = std::make_unique<DeviceSyncClientImpl>();
-    device_sync_->BindRequest(mojo::MakeRequest(client_->GetDeviceSyncPtr()));
+    device_sync_->BindReceiver(
+        client_->GetDeviceSyncRemote()->BindNewPipeAndPassReceiver());
     client_->Initialize(test_task_runner);
     test_task_runner->RunUntilIdle();
   }

chromeos/services/device_sync/public/mojom/device_sync.mojom

@@ -89,7 +89,7 @@ interface DeviceSyncObserver {
 // Calls to this API run in the browser process.
 interface DeviceSync {
   // Adds an Observer of this API.
-  AddObserver(DeviceSyncObserver observer) => ();
+  AddObserver(pending_remote<DeviceSyncObserver> observer) => ();
 
   // Triggers an enrollment; result is relayed via the OnEnrollmentFinished()
   // observer function. Returns whether the call could be completed