Convert MdnsListenClient to new Mojo types

This CL converts MdnsListenClientPtr and Binding<MdnsListenClient>
in chrome and services to the new Mojo type, and
uses pending_remote<T> in host_resolver.mojom.

Bug: 955171
Change-Id: Ie1821bd2d5edbbbcfc14ce8380053ce9cfaa2be5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1860535
Commit-Queue: Miyoung Shin <myid.shin@igalia.com>
Reviewed-by: Matt Menke <mmenke@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Cr-Commit-Position: refs/heads/master@{#706412}

chrome/browser/net/dns_probe_test_util.cc

@@ -65,7 +65,7 @@ void FakeHostResolver::ResolveHost(
 void FakeHostResolver::MdnsListen(
     const net::HostPortPair& host,
     net::DnsQueryType query_type,
-    network::mojom::MdnsListenClientPtr response_client,
+    mojo::PendingRemote<network::mojom::MdnsListenClient> response_client,
     MdnsListenCallback callback) {
   NOTREACHED();
 }
@@ -89,7 +89,7 @@ void HangingHostResolver::ResolveHost(
 void HangingHostResolver::MdnsListen(
     const net::HostPortPair& host,
     net::DnsQueryType query_type,
-    network::mojom::MdnsListenClientPtr response_client,
+    mojo::PendingRemote<network::mojom::MdnsListenClient> response_client,
     MdnsListenCallback callback) {
   NOTREACHED();
 }

chrome/browser/net/dns_probe_test_util.h

@@ -50,10 +50,11 @@ class FakeHostResolver : public network::mojom::HostResolver {
                    mojo::PendingRemote<network::mojom::ResolveHostClient>
                        pending_response_client) override;
 
-  void MdnsListen(const net::HostPortPair& host,
-                  net::DnsQueryType query_type,
-                  network::mojom::MdnsListenClientPtr response_client,
-                  MdnsListenCallback callback) override;
+  void MdnsListen(
+      const net::HostPortPair& host,
+      net::DnsQueryType query_type,
+      mojo::PendingRemote<network::mojom::MdnsListenClient> response_client,
+      MdnsListenCallback callback) override;
 
  private:
   mojo::Receiver<network::mojom::HostResolver> receiver_;
@@ -72,10 +73,11 @@ class HangingHostResolver : public network::mojom::HostResolver {
                    mojo::PendingRemote<network::mojom::ResolveHostClient>
                        response_client) override;
 
-  void MdnsListen(const net::HostPortPair& host,
-                  net::DnsQueryType query_type,
-                  network::mojom::MdnsListenClientPtr response_client,
-                  MdnsListenCallback callback) override;
+  void MdnsListen(
+      const net::HostPortPair& host,
+      net::DnsQueryType query_type,
+      mojo::PendingRemote<network::mojom::MdnsListenClient> response_client,
+      MdnsListenCallback callback) override;
 
  private:
   mojo::Receiver<network::mojom::HostResolver> receiver_;

services/network/host_resolver.cc

@@ -107,10 +107,11 @@ void HostResolver::ResolveHost(
   DCHECK(insertion_result);
 }
 
-void HostResolver::MdnsListen(const net::HostPortPair& host,
-                              net::DnsQueryType query_type,
-                              mojom::MdnsListenClientPtr response_client,
-                              MdnsListenCallback callback) {
+void HostResolver::MdnsListen(
+    const net::HostPortPair& host,
+    net::DnsQueryType query_type,
+    mojo::PendingRemote<mojom::MdnsListenClient> response_client,
+    MdnsListenCallback callback) {
 #if !BUILDFLAG(ENABLE_MDNS)
   NOTREACHED();
 #endif  // !BUILDFLAG(ENABLE_MDNS)

services/network/host_resolver.h

@@ -55,7 +55,7 @@ class COMPONENT_EXPORT(NETWORK_SERVICE) HostResolver
       mojo::PendingRemote<mojom::ResolveHostClient> response_client) override;
   void MdnsListen(const net::HostPortPair& host,
                   net::DnsQueryType query_type,
-                  mojom::MdnsListenClientPtr response_client,
+                  mojo::PendingRemote<mojom::MdnsListenClient> response_client,
                   MdnsListenCallback callback) override;
 
   size_t GetNumOutstandingRequestsForTesting() const;

services/network/host_resolver_mdns_listener.cc

@@ -23,11 +23,12 @@ HostResolverMdnsListener::HostResolverMdnsListener(
 
 HostResolverMdnsListener::~HostResolverMdnsListener() {
   internal_listener_ = nullptr;
-  response_client_ = nullptr;
+  response_client_.reset();
 }
 
-int HostResolverMdnsListener::Start(mojom::MdnsListenClientPtr response_client,
-                                    base::OnceClosure cancellation_callback) {
+int HostResolverMdnsListener::Start(
+    mojo::PendingRemote<mojom::MdnsListenClient> response_client,
+    base::OnceClosure cancellation_callback) {
   DCHECK(internal_listener_);
   DCHECK(!response_client_.is_bound());
 
@@ -35,10 +36,10 @@ int HostResolverMdnsListener::Start(mojom::MdnsListenClientPtr response_client,
   if (rv != net::OK)
     return rv;
 
-  response_client_ = std::move(response_client);
+  response_client_.Bind(std::move(response_client));
   // Unretained |this| reference is safe because connection error cannot occur
   // if |response_client_| goes out of scope.
-  response_client_.set_connection_error_handler(base::BindOnce(
+  response_client_.set_disconnect_handler(base::BindOnce(
       &HostResolverMdnsListener::OnConnectionError, base::Unretained(this)));
 
   cancellation_callback_ = std::move(cancellation_callback);

services/network/host_resolver_mdns_listener.h

@@ -11,6 +11,8 @@
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/remote.h"
 #include "net/base/ip_endpoint.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/public/dns_query_type.h"
@@ -30,7 +32,7 @@ class HostResolverMdnsListener
                            net::DnsQueryType query_type);
   ~HostResolverMdnsListener() override;
 
-  int Start(mojom::MdnsListenClientPtr response_client,
+  int Start(mojo::PendingRemote<mojom::MdnsListenClient> response_client,
             base::OnceClosure cancellation_callback);
 
   // net::HostResolver::MdnsListenerDelegate implementation
@@ -54,7 +56,7 @@ class HostResolverMdnsListener
   void OnConnectionError();
 
   std::unique_ptr<net::HostResolver::MdnsListener> internal_listener_;
-  mojom::MdnsListenClientPtr response_client_;
+  mojo::Remote<mojom::MdnsListenClient> response_client_;
 
   base::OnceClosure cancellation_callback_;
 

services/network/host_resolver_unittest.cc

@@ -14,7 +14,6 @@
 #include "base/test/bind_test_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/test/task_environment.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"
@@ -124,8 +123,9 @@ class TestMdnsListenClient : public mojom::MdnsListenClient {
   using UpdateType = net::HostResolver::MdnsListener::Delegate::UpdateType;
   using UpdateKey = std::pair<UpdateType, net::DnsQueryType>;
 
-  explicit TestMdnsListenClient(mojom::MdnsListenClientPtr* interface_ptr)
-      : binding_(this, mojo::MakeRequest(interface_ptr)) {}
+  explicit TestMdnsListenClient(
+      mojo::PendingRemote<mojom::MdnsListenClient>* remote)
+      : receiver_(this, remote->InitWithNewPipeAndPassReceiver()) {}
 
   void OnAddressResult(UpdateType update_type,
                        net::DnsQueryType result_type,
@@ -177,7 +177,7 @@ class TestMdnsListenClient : public mojom::MdnsListenClient {
   }
 
  private:
-  mojo::Binding<mojom::MdnsListenClient> binding_;
+  mojo::Receiver<mojom::MdnsListenClient> receiver_;
 
   std::multimap<UpdateKey, net::IPEndPoint> address_results_;
   std::multimap<UpdateKey, std::string> text_results_;
@@ -1268,7 +1268,7 @@ TEST_F(HostResolverTest, MdnsListener_AddressResult) {
   auto inner_resolver = std::make_unique<net::MockHostResolver>();
   HostResolver resolver(inner_resolver.get(), &net_log);
 
-  mojom::MdnsListenClientPtr pending_response_client;
+  mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
   TestMdnsListenClient response_client(&pending_response_client);
 
   int error = net::ERR_FAILED;
@@ -1306,7 +1306,7 @@ TEST_F(HostResolverTest, MdnsListener_TextResult) {
   auto inner_resolver = std::make_unique<net::MockHostResolver>();
   HostResolver resolver(inner_resolver.get(), &net_log);
 
-  mojom::MdnsListenClientPtr pending_response_client;
+  mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
   TestMdnsListenClient response_client(&pending_response_client);
 
   int error = net::ERR_FAILED;
@@ -1348,7 +1348,7 @@ TEST_F(HostResolverTest, MdnsListener_HostnameResult) {
   auto inner_resolver = std::make_unique<net::MockHostResolver>();
   HostResolver resolver(inner_resolver.get(), &net_log);
 
-  mojom::MdnsListenClientPtr pending_response_client;
+  mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
   TestMdnsListenClient response_client(&pending_response_client);
 
   int error = net::ERR_FAILED;
@@ -1386,7 +1386,7 @@ TEST_F(HostResolverTest, MdnsListener_UnhandledResult) {
   auto inner_resolver = std::make_unique<net::MockHostResolver>();
   HostResolver resolver(inner_resolver.get(), &net_log);
 
-  mojom::MdnsListenClientPtr pending_response_client;
+  mojo::PendingRemote<mojom::MdnsListenClient> pending_response_client;
   TestMdnsListenClient response_client(&pending_response_client);
 
   int error = net::ERR_FAILED;

services/network/public/mojom/host_resolver.mojom

@@ -287,7 +287,8 @@ interface HostResolver {
   // notifications if the HostResolver or parent NetworkContext are destroyed.
   MdnsListen(HostPortPair host,
              DnsQueryType query_type,
-             MdnsListenClient response_client) => (int32 result);
+             pending_remote<MdnsListenClient> response_client)
+      => (int32 result);
 };
 
 // A client interface that subscribes to DNS config change events from