Convert ResolveHostHandle to new Mojo types

This CL converts ResolveHostHandle{Ptr, Request} in services to
the new Mojo type, and uses pending_receiver<ResolveHostHandle> in
host_resolver.mojom.

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

services/network/host_resolver.cc

@@ -9,6 +9,7 @@
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/optional.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/dns/host_resolver.h"
@@ -89,12 +90,12 @@ void HostResolver::ResolveHost(
       internal_resolver_, host, ConvertOptionalParameters(optional_parameters),
       net_log_);
 
-  mojom::ResolveHostHandleRequest control_handle_request;
+  mojo::PendingReceiver<mojom::ResolveHostHandle> control_handle_receiver;
   if (optional_parameters)
-    control_handle_request = std::move(optional_parameters->control_handle);
+    control_handle_receiver = std::move(optional_parameters->control_handle);
 
   int rv = request->Start(
-      std::move(control_handle_request), std::move(response_client),
+      std::move(control_handle_receiver), std::move(response_client),
       base::BindOnce(&HostResolver::OnResolveHostComplete,
                      base::Unretained(this), request.get()));
   if (rv != net::ERR_IO_PENDING)

services/network/public/mojom/host_resolver.mojom

@@ -205,7 +205,7 @@ struct ResolveHostParameters {
 
   // If set, the outstanding request can be controlled, eg cancelled, via the
   // handle.
-  ResolveHostHandle&? control_handle;
+  pending_receiver<ResolveHostHandle>? control_handle;
 
   // If |true|, requests that the resolver include AddressList::canonical_name
   // in the results. If the resolver can do so without significant performance

services/network/resolve_host_request.cc

@@ -31,8 +31,7 @@ ResolveHostRequest::ResolveHostRequest(
 }
 
 ResolveHostRequest::~ResolveHostRequest() {
-  if (control_handle_binding_.is_bound())
-    control_handle_binding_.Close();
+  control_handle_receiver_.reset();
 
   if (response_client_.is_bound()) {
     response_client_->OnComplete(net::ERR_FAILED, base::nullopt);
@@ -41,11 +40,11 @@ ResolveHostRequest::~ResolveHostRequest() {
 }
 
 int ResolveHostRequest::Start(
-    mojom::ResolveHostHandleRequest control_handle_request,
+    mojo::PendingReceiver<mojom::ResolveHostHandle> control_handle_receiver,
     mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client,
     net::CompletionOnceCallback callback) {
   DCHECK(internal_request_);
-  DCHECK(!control_handle_binding_.is_bound());
+  DCHECK(!control_handle_receiver_.is_bound());
   DCHECK(!response_client_.is_bound());
 
   // Unretained |this| reference is safe because if |internal_request_| goes out
@@ -60,8 +59,8 @@ int ResolveHostRequest::Start(
     return rv;
   }
 
-  if (control_handle_request)
-    control_handle_binding_.Bind(std::move(control_handle_request));
+  if (control_handle_receiver)
+    control_handle_receiver_.Bind(std::move(control_handle_receiver));
 
   response_client_ = std::move(response_client);
   // Unretained |this| reference is safe because connection error cannot occur
@@ -89,7 +88,7 @@ void ResolveHostRequest::OnComplete(int error) {
   DCHECK(response_client_.is_bound());
   DCHECK(callback_);
 
-  control_handle_binding_.Close();
+  control_handle_receiver_.reset();
   SignalNonAddressResults();
   response_client_->OnComplete(error, GetAddressResults());
   response_client_.reset();

services/network/resolve_host_request.h

@@ -9,8 +9,9 @@
 
 #include "base/macros.h"
 #include "base/optional.h"
-#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "net/base/completion_once_callback.h"
 #include "net/dns/host_resolver.h"
@@ -37,7 +38,7 @@ class ResolveHostRequest : public mojom::ResolveHostHandle {
   ~ResolveHostRequest() override;
 
   int Start(
-      mojom::ResolveHostHandleRequest control_handle_request,
+      mojo::PendingReceiver<mojom::ResolveHostHandle> control_handle_request,
       mojo::PendingRemote<mojom::ResolveHostClient> pending_response_client,
       net::CompletionOnceCallback callback);
 
@@ -51,7 +52,7 @@ class ResolveHostRequest : public mojom::ResolveHostHandle {
 
   std::unique_ptr<net::HostResolver::ResolveHostRequest> internal_request_;
 
-  mojo::Binding<mojom::ResolveHostHandle> control_handle_binding_{this};
+  mojo::Receiver<mojom::ResolveHostHandle> control_handle_receiver_{this};
   mojo::Remote<mojom::ResolveHostClient> response_client_;
   net::CompletionOnceCallback callback_;
   bool cancelled_ = false;