Use new mojo types for service_manager.mojom

This CL converts ServiceManagerListener{Ptr, Request} and
ServiceManagerPtr and port depending files to adapt to new
mojo types.

Bug: 955171, 978694
Change-Id: Ic3cda1b527d3f164caf717c982dbb04b09595c48
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1865218
Commit-Queue: Abhijeet Kandalkar <abhijeet@igalia.com>
Reviewed-by: Ken Rockot <rockot@google.com>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#707782}

chrome/test/base/test_service_manager_listener.cc

@@ -7,22 +7,25 @@
 #include "base/run_loop.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/system_connector.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "services/service_manager/public/cpp/connector.h"
 
-TestServiceManagerListener::TestServiceManagerListener() : binding_(this) {}
+TestServiceManagerListener::TestServiceManagerListener() : receiver_(this) {}
 
 TestServiceManagerListener::~TestServiceManagerListener() {}
 
 void TestServiceManagerListener::Init() {
-  DCHECK(!binding_.is_bound());
+  DCHECK(!receiver_.is_bound());
   // Register a listener on the ServiceManager to track when services are
   // started.
-  mojo::InterfacePtr<service_manager::mojom::ServiceManager> service_manager;
-  content::GetSystemConnector()->BindInterface(
-      service_manager::mojom::kServiceName, &service_manager);
-  service_manager::mojom::ServiceManagerListenerPtr listener_ptr;
-  binding_.Bind(mojo::MakeRequest(&listener_ptr));
-  service_manager->AddListener(std::move(listener_ptr));
+  mojo::Remote<service_manager::mojom::ServiceManager> service_manager;
+  content::GetSystemConnector()->Connect(
+      service_manager::mojom::kServiceName,
+      service_manager.BindNewPipeAndPassReceiver());
+  mojo::PendingRemote<service_manager::mojom::ServiceManagerListener>
+      listener_remote;
+  receiver_.Bind(listener_remote.InitWithNewPipeAndPassReceiver());
+  service_manager->AddListener(std::move(listener_remote));
 }
 
 void TestServiceManagerListener::WaitUntilServiceStarted(

chrome/test/base/test_service_manager_listener.h

@@ -12,7 +12,7 @@
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "services/service_manager/public/mojom/service_manager.mojom.h"
 
 namespace service_manager {
@@ -51,7 +51,7 @@ class TestServiceManagerListener
   std::string service_name_;
   std::map<std::string, uint32_t> service_start_counters_;
 
-  mojo::Binding<service_manager::mojom::ServiceManagerListener> binding_;
+  mojo::Receiver<service_manager::mojom::ServiceManagerListener> receiver_;
 
   DISALLOW_COPY_AND_ASSIGN(TestServiceManagerListener);
 };

content/browser/renderer_host/media/audio_service_listener.cc

@@ -88,21 +88,20 @@ void AudioServiceListener::Metrics::LogServiceStartStatus(
 
 AudioServiceListener::AudioServiceListener(
     std::unique_ptr<service_manager::Connector> connector)
-    : binding_(this),
-      connector_(std::move(connector)),
+    : connector_(std::move(connector)),
       metrics_(base::DefaultTickClock::GetInstance()) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(owning_sequence_);
   if (!connector_)
     return;  // Happens in unittests.
 
-  service_manager::mojom::ServiceManagerPtr service_manager;
-  connector_->BindInterface(service_manager::mojom::kServiceName,
-                            &service_manager);
-  service_manager::mojom::ServiceManagerListenerPtr listener;
-  service_manager::mojom::ServiceManagerListenerRequest request(
-      mojo::MakeRequest(&listener));
+  mojo::Remote<service_manager::mojom::ServiceManager> service_manager;
+  connector_->Connect(service_manager::mojom::kServiceName,
+                      service_manager.BindNewPipeAndPassReceiver());
+  mojo::PendingRemote<service_manager::mojom::ServiceManagerListener> listener;
+  mojo::PendingReceiver<service_manager::mojom::ServiceManagerListener> request(
+      listener.InitWithNewPipeAndPassReceiver());
   service_manager->AddListener(std::move(listener));
-  binding_.Bind(std::move(request));
+  receiver_.Bind(std::move(request));
 }
 
 AudioServiceListener::~AudioServiceListener() {

content/browser/renderer_host/media/audio_service_listener.h

@@ -13,7 +13,7 @@
 #include "base/process/process_handle.h"
 #include "base/time/time.h"
 #include "content/common/content_export.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/identity.h"
 #include "services/service_manager/public/mojom/service_manager.mojom.h"
@@ -90,7 +90,8 @@ class CONTENT_EXPORT AudioServiceListener
 
   void MaybeSetLogFactory();
 
-  mojo::Binding<service_manager::mojom::ServiceManagerListener> binding_;
+  mojo::Receiver<service_manager::mojom::ServiceManagerListener> receiver_{
+      this};
   std::unique_ptr<service_manager::Connector> connector_;
   base::Optional<service_manager::Identity> current_instance_identity_;
   base::Optional<service_manager::mojom::InstanceState> current_instance_state_;

content/browser/service_manager/service_manager_context_browsertest.cc

@@ -83,17 +83,19 @@ using ServiceManagerContextBrowserTest = ContentBrowserTest;
 
 IN_PROC_BROWSER_TEST_F(ServiceManagerContextBrowserTest,
                        ServiceProcessReportsPID) {
-  service_manager::mojom::ServiceManagerListenerPtr listener_proxy;
-  ServiceInstanceListener listener(mojo::MakeRequest(&listener_proxy));
+  mojo::Remote<service_manager::mojom::ServiceManager> service_manager;
+  GetSystemConnector()->Connect(service_manager::mojom::kServiceName,
+                                service_manager.BindNewPipeAndPassReceiver());
+
+  mojo::PendingRemote<service_manager::mojom::ServiceManagerListener>
+      listener_proxy;
+  ServiceInstanceListener listener(
+      listener_proxy.InitWithNewPipeAndPassReceiver());
 
-  auto* connector = GetSystemConnector();
-  service_manager::mojom::ServiceManagerPtr service_manager;
-  connector->BindInterface(service_manager::mojom::kServiceName,
-                           &service_manager);
   service_manager->AddListener(std::move(listener_proxy));
   listener.WaitForInit();
 
-  connector->WarmService(service_manager::ServiceFilter::ByName(
+  GetSystemConnector()->WarmService(service_manager::ServiceFilter::ByName(
       data_decoder::mojom::kServiceName));
 
   // PID should be non-zero, confirming that it was indeed properly reported to

services/audio/test/service_lifetime_test_template.h

@@ -32,9 +32,10 @@ class ServiceLifetimeTestTemplate : public TestBase {
         service_manager::mojom::kServiceName,
         service_manager.BindNewPipeAndPassReceiver());
 
-    service_manager::mojom::ServiceManagerListenerPtr listener;
+    mojo::PendingRemote<service_manager::mojom::ServiceManagerListener>
+        listener;
     service_observer_ = std::make_unique<ServiceObserverMock>(
-        mojom::kServiceName, mojo::MakeRequest(&listener));
+        mojom::kServiceName, listener.InitWithNewPipeAndPassReceiver());
 
     base::RunLoop wait_loop;
     EXPECT_CALL(*service_observer_, Initialized())

services/service_manager/public/mojom/service_manager.mojom

@@ -81,5 +81,5 @@ interface ServiceManagerListener {
 
 interface ServiceManager {
   // The listener is removed when the |listener| pipe is closed.
-  AddListener(ServiceManagerListener listener);
+  AddListener(pending_remote<ServiceManagerListener> listener);
 };

services/service_manager/service_instance.cc

@@ -588,7 +588,8 @@ void ServiceInstance::RequestQuit() {
   OnServiceDisconnected();
 }
 
-void ServiceInstance::AddListener(mojom::ServiceManagerListenerPtr listener) {
+void ServiceInstance::AddListener(
+    mojo::PendingRemote<mojom::ServiceManagerListener> listener) {
   service_manager_->AddListener(std::move(listener));
 }
 

services/service_manager/service_instance.h

@@ -152,7 +152,8 @@ class ServiceInstance : public mojom::Connector,
   void RequestQuit() override;
 
   // mojom::ServiceManager:
-  void AddListener(mojom::ServiceManagerListenerPtr listener) override;
+  void AddListener(
+      mojo::PendingRemote<mojom::ServiceManagerListener> listener) override;
 
   // Always owns |this|.
   service_manager::ServiceManager* const service_manager_;

services/service_manager/service_manager.cc

@@ -401,9 +401,10 @@ void ServiceManager::DestroyInstance(ServiceInstance* instance) {
 }
 
 void ServiceManager::OnInstanceStopped(const Identity& identity) {
-  listeners_.ForAllPtrs([&identity](mojom::ServiceManagerListener* listener) {
+  for (auto& listener : listeners_) {
     listener->OnServiceStopped(identity);
-  });
+  }
+
   if (!instance_quit_callback_.is_null())
     std::move(instance_quit_callback_).Run(identity);
 }
@@ -416,31 +417,29 @@ ServiceInstance* ServiceManager::GetExistingInstance(
 
 void ServiceManager::NotifyServiceCreated(const ServiceInstance& instance) {
   mojom::RunningServiceInfoPtr info = instance.CreateRunningServiceInfo();
-  listeners_.ForAllPtrs([&info](mojom::ServiceManagerListener* listener) {
+  for (auto& listener : listeners_) {
     listener->OnServiceCreated(info.Clone());
-  });
+  }
 }
 
 void ServiceManager::NotifyServiceStarted(const Identity& identity,
                                           base::ProcessId pid) {
-  listeners_.ForAllPtrs(
-      [&identity, pid](mojom::ServiceManagerListener* listener) {
-        listener->OnServiceStarted(identity, pid);
-      });
+  for (auto& listener : listeners_) {
+    listener->OnServiceStarted(identity, pid);
+  }
 }
 
 void ServiceManager::NotifyServiceFailedToStart(const Identity& identity) {
-  listeners_.ForAllPtrs([&identity](mojom::ServiceManagerListener* listener) {
+  for (auto& listener : listeners_) {
     listener->OnServiceFailedToStart(identity);
-  });
+  }
 }
 
 void ServiceManager::NotifyServicePIDReceived(const Identity& identity,
                                               base::ProcessId pid) {
-  listeners_.ForAllPtrs(
-      [&identity, pid](mojom::ServiceManagerListener* listener) {
-        listener->OnServicePIDReceived(identity, pid);
-      });
+  for (auto& listener : listeners_) {
+    listener->OnServicePIDReceived(identity, pid);
+  }
 }
 
 ServiceInstance* ServiceManager::CreateServiceInstance(
@@ -461,13 +460,16 @@ ServiceInstance* ServiceManager::CreateServiceInstance(
   return raw_instance;
 }
 
-void ServiceManager::AddListener(mojom::ServiceManagerListenerPtr listener) {
+void ServiceManager::AddListener(
+    mojo::PendingRemote<mojom::ServiceManagerListener> listener) {
   std::vector<mojom::RunningServiceInfoPtr> infos;
   for (auto& instance : instances_)
     infos.push_back(instance->CreateRunningServiceInfo());
 
-  listener->OnInit(std::move(infos));
-  listeners_.AddPtr(std::move(listener));
+  mojo::Remote<mojom::ServiceManagerListener> listener_remote;
+  listener_remote.Bind(std::move(listener));
+  listener_remote->OnInit(std::move(infos));
+  listeners_.Add(std::move(listener_remote));
 }
 
 void ServiceManager::OnBindInterface(

services/service_manager/service_manager.h

@@ -18,6 +18,7 @@
 #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/remote_set.h"
 #include "services/service_manager/catalog.h"
 #include "services/service_manager/public/cpp/identity.h"
 #include "services/service_manager/public/cpp/manifest.h"
@@ -184,7 +185,7 @@ class ServiceManager : public Service {
                                          const Manifest& manifest);
 
   // Called from the instance implementing mojom::ServiceManager.
-  void AddListener(mojom::ServiceManagerListenerPtr listener);
+  void AddListener(mojo::PendingRemote<mojom::ServiceManagerListener> listener);
 
   // Service:
   void OnBindInterface(const BindSourceInfo& source_info,
@@ -210,7 +211,7 @@ class ServiceManager : public Service {
   // ServiceInstance still has an entry in |instances_|.
   ServiceInstance* service_manager_instance_;
 
-  mojo::InterfacePtrSet<mojom::ServiceManagerListener> listeners_;
+  mojo::RemoteSet<mojom::ServiceManagerListener> listeners_;
   base::OnceCallback<void(const Identity&)> instance_quit_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceManager);

services/service_manager/tests/lifecycle/lifecycle_unittest.cc

@@ -246,10 +246,10 @@ class LifecycleTest : public testing::Test {
     mojom::ServiceManagerPtr service_manager;
     connector()->BindInterface(service_manager::mojom::kServiceName,
                                &service_manager);
-    mojom::ServiceManagerListenerPtr listener;
+    mojo::PendingRemote<mojom::ServiceManagerListener> listener;
     base::RunLoop loop;
-    InstanceState* state =
-        new InstanceState(MakeRequest(&listener), loop.QuitClosure());
+    InstanceState* state = new InstanceState(
+        listener.InitWithNewPipeAndPassReceiver(), loop.QuitClosure());
     service_manager->AddListener(std::move(listener));
     loop.Run();
     return base::WrapUnique(state);

services/service_manager/tests/service_manager/service_manager_listener_unittest.cc

@@ -117,9 +117,9 @@ class ServiceManagerListenerTest : public testing::Test, public Service {
     mojom::ServiceManagerPtr service_manager;
     connector()->BindInterface(mojom::kServiceName, &service_manager);
 
-    mojom::ServiceManagerListenerPtr listener_proxy;
-    listener_ =
-        std::make_unique<TestListener>(mojo::MakeRequest(&listener_proxy));
+    mojo::PendingRemote<mojom::ServiceManagerListener> listener_proxy;
+    listener_ = std::make_unique<TestListener>(
+        listener_proxy.InitWithNewPipeAndPassReceiver());
     service_manager->AddListener(std::move(listener_proxy));
     listener_->WaitForInit();
   }

services/service_manager/tests/service_manager/service_manager_unittest.cc

@@ -173,8 +173,8 @@ class ServiceManagerTest : public testing::Test,
     connector()->BindInterface(service_manager::mojom::kServiceName,
                                &service_manager);
 
-    mojom::ServiceManagerListenerPtr listener;
-    binding_.Bind(mojo::MakeRequest(&listener));
+    mojo::PendingRemote<mojom::ServiceManagerListener> listener;
+    binding_.Bind(listener.InitWithNewPipeAndPassReceiver());
     service_manager->AddListener(std::move(listener));
 
     wait_for_instances_loop_ = std::make_unique<base::RunLoop>();

services/tracing/tracing_service.cc

@@ -11,7 +11,7 @@
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/timer/timer.h"
-#include "mojo/public/cpp/bindings/remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "services/service_manager/public/mojom/service_manager.mojom.h"
 #include "services/tracing/agent_registry.h"
 #include "services/tracing/coordinator.h"
@@ -34,14 +34,15 @@ class ServiceListener : public service_manager::mojom::ServiceManagerListener {
       : connector_(connector),
         agent_registry_(agent_registry),
         coordinator_(coordinator) {
-    service_manager::mojom::ServiceManagerPtr service_manager;
-    connector_->BindInterface(service_manager::mojom::kServiceName,
-                              &service_manager);
-    service_manager::mojom::ServiceManagerListenerPtr listener;
-    service_manager::mojom::ServiceManagerListenerRequest request(
-        mojo::MakeRequest(&listener));
+    mojo::Remote<service_manager::mojom::ServiceManager> service_manager;
+    connector_->Connect(service_manager::mojom::kServiceName,
+                        service_manager.BindNewPipeAndPassReceiver());
+    mojo::PendingRemote<service_manager::mojom::ServiceManagerListener>
+        listener;
+    mojo::PendingReceiver<service_manager::mojom::ServiceManagerListener>
+        request(listener.InitWithNewPipeAndPassReceiver());
     service_manager->AddListener(std::move(listener));
-    binding_.Bind(std::move(request));
+    receiver_.Bind(std::move(request));
   }
 
   size_t CountServicesWithPID(uint32_t pid) {
@@ -158,7 +159,8 @@ class ServiceListener : public service_manager::mojom::ServiceManagerListener {
     agent_registry_->BindAgentRegistryReceiver(std::move(registry_receiver));
   }
 
-  mojo::Binding<service_manager::mojom::ServiceManagerListener> binding_{this};
+  mojo::Receiver<service_manager::mojom::ServiceManagerListener> receiver_{
+      this};
   service_manager::Connector* const connector_;
   AgentRegistry* const agent_registry_;
   Coordinator* const coordinator_;