Change HostResolver::Resolve() to take an std::unique_ptr<Request>* rather than a RequestHandle*

net/dns/host_resolver_mojo_unittest.cc

Index: net/dns/host_resolver_mojo_unittest.cc
diff --git a/net/dns/host_resolver_mojo_unittest.cc b/net/dns/host_resolver_mojo_unittest.cc
index 57bdb5e8de481ac4cb1eae28e489e96b113fcc96..1c14a24e2d8df3bdb05adea5f5b32bd6bf58a71e 100644
--- a/net/dns/host_resolver_mojo_unittest.cc
+++ b/net/dns/host_resolver_mojo_unittest.cc
@@ -166,17 +166,18 @@ class HostResolverMojoTest : public testing::Test {
 
   int Resolve(const HostResolver::RequestInfo& request_info,
               AddressList* result) {
-    HostResolver::RequestHandle request_handle = nullptr;
     TestCompletionCallback callback;
-    return callback.GetResult(resolver_->Resolve(
-        request_info, DEFAULT_PRIORITY, result, callback.callback(),
-        &request_handle, BoundNetLog()));
+    return callback.GetResult(resolver_->Resolve(request_info, DEFAULT_PRIORITY,
+                                                 result, callback.callback(),
+                                                 &request_, BoundNetLog()));
   }
 
   std::unique_ptr<MockMojoHostResolver> mock_resolver_;
 
   std::unique_ptr<HostResolverMojo> resolver_;
 
+  std::unique_ptr<HostResolver::Request> request_;
+
   Waiter waiter_;
 };
 
@@ -254,18 +255,16 @@ TEST_F(HostResolverMojoTest, Multiple) {
   request_info2.set_address_family(ADDRESS_FAMILY_IPV6);
   AddressList result1;
   AddressList result2;
-  HostResolver::RequestHandle request_handle1 = nullptr;
-  HostResolver::RequestHandle request_handle2 = nullptr;
+  std::unique_ptr<HostResolver::Request> request1;
+  std::unique_ptr<HostResolver::Request> request2;
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
   ASSERT_EQ(ERR_IO_PENDING,
             resolver_->Resolve(request_info1, DEFAULT_PRIORITY, &result1,
-                               callback1.callback(), &request_handle1,
-                               BoundNetLog()));
+                               callback1.callback(), &request1, BoundNetLog()));
   ASSERT_EQ(ERR_IO_PENDING,
             resolver_->Resolve(request_info2, DEFAULT_PRIORITY, &result2,
-                               callback2.callback(), &request_handle2,
-                               BoundNetLog()));
+                               callback2.callback(), &request2, BoundNetLog()));
   EXPECT_THAT(callback1.GetResult(ERR_IO_PENDING), IsOk());
   EXPECT_THAT(callback2.GetResult(ERR_IO_PENDING),
               IsError(ERR_NAME_NOT_RESOLVED));
@@ -274,18 +273,16 @@ TEST_F(HostResolverMojoTest, Multiple) {
   ASSERT_EQ(0u, result2.size());
 
   ASSERT_EQ(2u, mock_resolver_->requests().size());
-  interfaces::HostResolverRequestInfo& request1 =
-      *mock_resolver_->requests()[0];
-  EXPECT_EQ("example.com", request1.host.To<std::string>());
-  EXPECT_EQ(12345, request1.port);
-  EXPECT_EQ(interfaces::AddressFamily::IPV4, request1.address_family);
-  EXPECT_TRUE(request1.is_my_ip_address);
-  interfaces::HostResolverRequestInfo& request2 =
-      *mock_resolver_->requests()[1];
-  EXPECT_EQ("example.org", request2.host.To<std::string>());
-  EXPECT_EQ(80, request2.port);
-  EXPECT_EQ(interfaces::AddressFamily::IPV6, request2.address_family);
-  EXPECT_FALSE(request2.is_my_ip_address);
+  interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0];
+  EXPECT_EQ("example.com", info1.host.To<std::string>());
+  EXPECT_EQ(12345, info1.port);
+  EXPECT_EQ(interfaces::AddressFamily::IPV4, info1.address_family);
+  EXPECT_TRUE(info1.is_my_ip_address);
+  interfaces::HostResolverRequestInfo& info2 = *mock_resolver_->requests()[1];
+  EXPECT_EQ("example.org", info2.host.To<std::string>());
+  EXPECT_EQ(80, info2.port);
+  EXPECT_EQ(interfaces::AddressFamily::IPV6, info2.address_family);
+  EXPECT_FALSE(info2.is_my_ip_address);
 }
 
 TEST_F(HostResolverMojoTest, Error) {
@@ -323,19 +320,19 @@ TEST_F(HostResolverMojoTest, Cancel) {
       HostPortPair::FromString("example.com:80"));
   request_info.set_address_family(ADDRESS_FAMILY_IPV6);
   AddressList result;
-  HostResolver::RequestHandle request_handle = nullptr;
+  std::unique_ptr<HostResolver::Request> request;
   resolver_->Resolve(request_info, DEFAULT_PRIORITY, &result, base::Bind(&Fail),
-                     &request_handle, BoundNetLog());
-  resolver_->CancelRequest(request_handle);
+                     &request, BoundNetLog());
+  request.reset();
   waiter_.WaitForEvent(ConnectionErrorSource::REQUEST);
   EXPECT_TRUE(result.empty());
 
   ASSERT_EQ(1u, mock_resolver_->requests().size());
-  interfaces::HostResolverRequestInfo& request = *mock_resolver_->requests()[0];
-  EXPECT_EQ("example.com", request.host.To<std::string>());
-  EXPECT_EQ(80, request.port);
-  EXPECT_EQ(interfaces::AddressFamily::IPV6, request.address_family);
-  EXPECT_FALSE(request.is_my_ip_address);
+  interfaces::HostResolverRequestInfo& info1 = *mock_resolver_->requests()[0];
+  EXPECT_EQ("example.com", info1.host.To<std::string>());
+  EXPECT_EQ(80, info1.port);
+  EXPECT_EQ(interfaces::AddressFamily::IPV6, info1.address_family);
+  EXPECT_FALSE(info1.is_my_ip_address);
 }
 
 TEST_F(HostResolverMojoTest, ImplDropsClientConnection) {
@@ -347,11 +344,11 @@ TEST_F(HostResolverMojoTest, ImplDropsClientConnection) {
   EXPECT_TRUE(result.empty());
 
   ASSERT_EQ(1u, mock_resolver_->requests().size());
-  interfaces::HostResolverRequestInfo& request = *mock_resolver_->requests()[0];
-  EXPECT_EQ("example.com", request.host.To<std::string>());
-  EXPECT_EQ(1, request.port);
-  EXPECT_EQ(interfaces::AddressFamily::UNSPECIFIED, request.address_family);
-  EXPECT_FALSE(request.is_my_ip_address);
+  interfaces::HostResolverRequestInfo& info2 = *mock_resolver_->requests()[0];
+  EXPECT_EQ("example.com", info2.host.To<std::string>());
+  EXPECT_EQ(1, info2.port);
+  EXPECT_EQ(interfaces::AddressFamily::UNSPECIFIED, info2.address_family);
+  EXPECT_FALSE(info2.is_my_ip_address);
 }
 
 TEST_F(HostResolverMojoTest, ResolveFromCache_Miss) {