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

net/dns/host_resolver_mojo_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/dns/host_resolver_mojo.h"
 
 #include <string>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 148 matching lines @@
 
   void SetUp() override {
     mock_resolver_.reset(new MockMojoHostResolver(
         base::Bind(&Waiter::NotifyEvent, base::Unretained(&waiter_),
                    ConnectionErrorSource::REQUEST)));
     resolver_.reset(new HostResolverMojo(mock_resolver_.get()));
   }
 
   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_;
 };
 
 TEST_F(HostResolverMojoTest, Basic) {
   AddressList address_list;
   IPAddress address(1, 2, 3, 4);
   address_list.push_back(IPEndPoint(address, 12345));
   address_list.push_back(
       IPEndPoint(ConvertIPv4ToIPv4MappedIPv6(address), 12345));
   mock_resolver_->AddAction(HostResolverAction::ReturnResult(address_list));
@@ skipping 57 matching lines @@
       HostResolverAction::ReturnError(ERR_NAME_NOT_RESOLVED));
   HostResolver::RequestInfo request_info1(
       HostPortPair::FromString("example.com:12345"));
   request_info1.set_address_family(ADDRESS_FAMILY_IPV4);
   request_info1.set_is_my_ip_address(true);
   HostResolver::RequestInfo request_info2(
       HostPortPair::FromString("example.org:80"));
   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> req1;
+  std::unique_ptr<HostResolver::Request> req2;
   TestCompletionCallback callback1;
   TestCompletionCallback callback2;
   ASSERT_EQ(ERR_IO_PENDING,
             resolver_->Resolve(request_info1, DEFAULT_PRIORITY, &result1,
-                               callback1.callback(), &request_handle1,
-                               BoundNetLog()));
+                               callback1.callback(), &req1, BoundNetLog()));
   ASSERT_EQ(ERR_IO_PENDING,
             resolver_->Resolve(request_info2, DEFAULT_PRIORITY, &result2,
-                               callback2.callback(), &request_handle2,
-                               BoundNetLog()));
+                               callback2.callback(), &req2, BoundNetLog()));
   EXPECT_THAT(callback1.GetResult(ERR_IO_PENDING), IsOk());
   EXPECT_THAT(callback2.GetResult(ERR_IO_PENDING),
               IsError(ERR_NAME_NOT_RESOLVED));
   ASSERT_EQ(1u, result1.size());
   EXPECT_EQ(address_list[0], result1[0]);
   ASSERT_EQ(0u, result2.size());
 
   ASSERT_EQ(2u, mock_resolver_->requests().size());
   interfaces::HostResolverRequestInfo& request1 =
       *mock_resolver_->requests()[0];
@@ skipping 37 matching lines @@
 
   ASSERT_EQ(1u, mock_resolver_->requests().size());
 }
 
 TEST_F(HostResolverMojoTest, Cancel) {
   mock_resolver_->AddAction(HostResolverAction::RetainRequest());
   HostResolver::RequestInfo request_info(
       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_handle;
   resolver_->Resolve(request_info, DEFAULT_PRIORITY, &result, base::Bind(&Fail),
                      &request_handle, BoundNetLog());
-  resolver_->CancelRequest(request_handle);
+  request_handle.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);
 }
@@ skipping 63 matching lines @@
   EXPECT_EQ(ERR_DNS_CACHE_MISS,
             resolver_->ResolveFromCache(request_info, &result, BoundNetLog()));
   EXPECT_TRUE(result.empty());
 }
 
 TEST_F(HostResolverMojoTest, GetHostCache) {
   EXPECT_TRUE(resolver_->GetHostCache());
 }
 
 }  // namespace net