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

net/dns/host_resolver_impl_unittest.cc

 // Copyright (c) 2012 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_impl.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include <tuple>
@@ skipping 206 matching lines @@
           RequestPriority priority,
           size_t index,
           HostResolverImpl* resolver,
           Handler* handler)
       : info_(info),
         priority_(priority),
         index_(index),
         resolver_(resolver),
         handler_(handler),
         quit_on_complete_(false),
-        result_(ERR_UNEXPECTED),
-        handle_(NULL) {}
+        result_(ERR_UNEXPECTED) {}
 
   int Resolve() {
     DCHECK(resolver_);
-    DCHECK(!handle_);
+    DCHECK(!request_);
     list_ = AddressList();
     result_ = resolver_->Resolve(
-        info_,
-        priority_,
-        &list_,
-        base::Bind(&Request::OnComplete, base::Unretained(this)),
-        &handle_,
+        info_, priority_, &list_,
+        base::Bind(&Request::OnComplete, base::Unretained(this)), &request_,
         BoundNetLog());
     if (!list_.empty())
       EXPECT_THAT(result_, IsOk());
     return result_;
   }
 
   int ResolveFromCache() {
     DCHECK(resolver_);
-    DCHECK(!handle_);
+    DCHECK(!request_);
     return resolver_->ResolveFromCache(info_, &list_, BoundNetLog());
   }
 
   int ResolveStaleFromCache() {
     DCHECK(resolver_);
-    DCHECK(!handle_);
+    DCHECK(!request_);
     return resolver_->ResolveStaleFromCache(info_, &list_, &staleness_,
                                             BoundNetLog());
   }
 
   void ChangePriority(RequestPriority priority) {
     DCHECK(resolver_);
-    DCHECK(handle_);
-    resolver_->ChangeRequestPriority(handle_, priority);
+    DCHECK(request_);
+    request_->ChangeRequestPriority(priority);
     priority_ = priority;
   }
 
   void Cancel() {
     DCHECK(resolver_);
-    DCHECK(handle_);
-    resolver_->CancelRequest(handle_);
-    handle_ = NULL;
+    DCHECK(request_);
+    request_.reset();
   }
 
   const HostResolver::RequestInfo& info() const { return info_; }
   size_t index() const { return index_; }
   const AddressList& list() const { return list_; }
   int result() const { return result_; }
   const HostCache::EntryStaleness staleness() const { return staleness_; }
   bool completed() const { return result_ != ERR_IO_PENDING; }
-  bool pending() const { return handle_ != NULL; }
+  bool pending() const { return request_ != nullptr; }
 
   bool HasAddress(const std::string& address, uint16_t port) const {
     return AddressListContains(list_, address, port);
   }
 
   // Returns the number of addresses in |list_|.
   unsigned NumberOfAddresses() const {
     return list_.size();
   }
 
@@ skipping 18 matching lines @@
     else
       return ERR_UNEXPECTED;
   }
 
  private:
   void OnComplete(int rv) {
     EXPECT_TRUE(pending());
     EXPECT_THAT(result_, IsError(ERR_IO_PENDING));
     EXPECT_NE(ERR_IO_PENDING, rv);
     result_ = rv;
-    handle_ = NULL;
+    request_.reset();
     if (!list_.empty()) {
       EXPECT_THAT(result_, IsOk());
       EXPECT_EQ(info_.port(), list_.front().port());
     }
     if (handler_)
       handler_->Handle(this);
     if (quit_on_complete_) {
       base::MessageLoop::current()->QuitWhenIdle();
       quit_on_complete_ = false;
     }
   }
 
   HostResolver::RequestInfo info_;
   RequestPriority priority_;
   size_t index_;
   HostResolverImpl* resolver_;
   Handler* handler_;
   bool quit_on_complete_;
 
   AddressList list_;
   int result_;
-  HostResolver::RequestHandle handle_;
+  std::unique_ptr<HostResolver::Request> request_;
   HostCache::EntryStaleness staleness_;
 
   DISALLOW_COPY_AND_ASSIGN(Request);
 };
 
 // Using LookupAttemptHostResolverProc simulate very long lookups, and control
 // which attempt resolves the host.
 class LookupAttemptHostResolverProc : public HostResolverProc {
  public:
   LookupAttemptHostResolverProc(HostResolverProc* previous,
@@ skipping 282 matching lines @@
 
 TEST_F(HostResolverImplTest, AsynchronousLookup) {
   proc_->AddRuleForAllFamilies("just.testing", "192.168.1.42");
   proc_->SignalMultiple(1u);
 
   Request* req = CreateRequest("just.testing", 80);
   EXPECT_THAT(req->Resolve(), IsError(ERR_IO_PENDING));
   EXPECT_THAT(req->WaitForResult(), IsOk());
 
   EXPECT_TRUE(req->HasOneAddress("192.168.1.42", 80));
-
   EXPECT_EQ("just.testing", proc_->GetCaptureList()[0].hostname);
 }
 
 // RFC 6761 localhost names should always resolve to loopback.
 TEST_F(HostResolverImplTest, LocalhostLookup) {
   // Add a rule resolving localhost names to a non-loopback IP and test
   // that they still resolves to loopback.
   proc_->AddRuleForAllFamilies("foo.localhost", "192.168.1.42");
   proc_->AddRuleForAllFamilies("localhost", "192.168.1.42");
   proc_->AddRuleForAllFamilies("localhost.", "192.168.1.42");
@@ skipping 1744 matching lines @@
   EXPECT_FALSE(ResolveLocalHostname("::1:1", kLocalhostLookupPort, &addresses));
   EXPECT_FALSE(ResolveLocalHostname("0:0:0:0:0:0:0:0:1", kLocalhostLookupPort,
                                     &addresses));
   EXPECT_FALSE(ResolveLocalHostname("foo.localhost.com", kLocalhostLookupPort,
                                     &addresses));
   EXPECT_FALSE(
       ResolveLocalHostname("foo.localhoste", kLocalhostLookupPort, &addresses));
 }
 
 }  // namespace net