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

net/dns/mock_host_resolver.cc

Index: net/dns/mock_host_resolver.cc
diff --git a/net/dns/mock_host_resolver.cc b/net/dns/mock_host_resolver.cc
index 01030aa353740634a8401d7f072e2a1991365f32..f919914a909af71d07cb6980f1a1480df23cdb7b 100644
--- a/net/dns/mock_host_resolver.cc
+++ b/net/dns/mock_host_resolver.cc
@@ -55,17 +55,42 @@ int ParseAddressList(const std::string& host_list,
   return OK;
 }
 
-struct MockHostResolverBase::Request {
-  Request(const RequestInfo& req_info,
-          AddressList* addr,
-          const CompletionCallback& cb)
-      : info(req_info), addresses(addr), callback(cb) {}
-  RequestInfo info;
-  AddressList* addresses;
-  CompletionCallback callback;
+class MockHostResolverBase::RequestImpl : public HostResolver::Request {
+ public:
+  RequestImpl(const RequestInfo& req_info,
+              AddressList* addr,
+              const CompletionCallback& cb,
+              size_t id,
+              MockHostResolverBase* resolver)
+      : info_(req_info),
+        addresses_(addr),
+        callback_(cb),
+        id_(id),
+        resolver_(resolver) {}
+
+  ~RequestImpl() override {
+    if (resolver_)
+      resolver_->RemoveRequest(id_);
+  }
+
+  void ChangeRequestPriority(RequestPriority priority) override {}
+
+ private:
+  friend MockHostResolverBase;
+
+  RequestInfo info_;
+  AddressList* addresses_;
+  CompletionCallback callback_;
+  size_t id_;
+  MockHostResolverBase* resolver_;
+
+  DISALLOW_COPY_AND_ASSIGN(RequestImpl);
 };
 
 MockHostResolverBase::~MockHostResolverBase() {
+  for (auto map_it : requests_) {
+    map_it.second->resolver_ = nullptr;
+  }
   STLDeleteValues(&requests_);
 }
 
@@ -73,7 +98,7 @@ int MockHostResolverBase::Resolve(const RequestInfo& info,
                                   RequestPriority priority,
                                   AddressList* addresses,
                                   const CompletionCallback& callback,
-                                  RequestHandle* handle,
+                                  std::unique_ptr<Request>* handle,
                                   const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   last_request_priority_ = priority;
@@ -86,11 +111,12 @@ int MockHostResolverBase::Resolve(const RequestInfo& info,
   if (synchronous_mode_) {
     return ResolveProc(id, info, addresses);
   }
+
   // Store the request for asynchronous resolution
-  Request* req = new Request(info, addresses, callback);
-  requests_[id] = req;
-  if (handle)
-    *handle = reinterpret_cast<RequestHandle>(id);
+  std::unique_ptr<RequestImpl> req(
+      new RequestImpl(info, addresses, callback, id, this));
+  requests_[id] = req.get();
+  *handle = std::move(req);
 
   if (!ondemand_mode_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ -111,17 +137,13 @@ int MockHostResolverBase::ResolveFromCache(const RequestInfo& info,
   return rv;
 }
 
-void MockHostResolverBase::CancelRequest(RequestHandle handle) {
-  DCHECK(CalledOnValidThread());
-  size_t id = reinterpret_cast<size_t>(handle);
-  RequestMap::iterator it = requests_.find(id);
-  if (it != requests_.end()) {
-    std::unique_ptr<Request> req(it->second);
+void MockHostResolverBase::RemoveRequest(size_t id) {
+  if (requests_.empty())
+    return;
+
+  auto it = requests_.find(id);
+  if (it != requests_.end())
     requests_.erase(it);
-  } else {
-    NOTREACHED() << "CancelRequest must NOT be called after request is "
-        "complete or canceled.";
-  }
 }
 
 HostCache* MockHostResolverBase::GetHostCache() {
@@ -132,6 +154,7 @@ void MockHostResolverBase::ResolveAllPending() {
   DCHECK(CalledOnValidThread());
   DCHECK(ondemand_mode_);
   for (RequestMap::iterator i = requests_.begin(); i != requests_.end(); ++i) {
+    DLOG(ERROR) << "1";
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&MockHostResolverBase::ResolveNow, AsWeakPtr(), i->first));
@@ -187,11 +210,8 @@ int MockHostResolverBase::ResolveProc(size_t id,
                                       const RequestInfo& info,
                                       AddressList* addresses) {
   AddressList addr;
-  int rv = rules_->Resolve(info.hostname(),
-                           info.address_family(),
-                           info.host_resolver_flags(),
-                           &addr,
-                           NULL);
+  int rv = rules_->Resolve(info.hostname(), info.address_family(),
+                           info.host_resolver_flags(), &addr, nullptr);
   if (cache_.get()) {
     HostCache::Key key(info.hostname(),
                        info.address_family(),
@@ -212,11 +232,13 @@ void MockHostResolverBase::ResolveNow(size_t id) {
   if (it == requests_.end())
     return;  // was canceled
 
-  std::unique_ptr<Request> req(it->second);
-  requests_.erase(it);
-  int rv = ResolveProc(id, req->info, req->addresses);
-  if (!req->callback.is_null())
-    req->callback.Run(rv);
+  RequestImpl* req = it->second;
+  it->second->resolver_ = nullptr;
+  requests_.erase(id);
+
+  int rv = ResolveProc(id, req->info_, req->addresses_);
+  if (!req->callback_.is_null())
+    req->callback_.Run(rv);
 }
 
 //-----------------------------------------------------------------------------
@@ -425,7 +447,7 @@ int HangingHostResolver::Resolve(const RequestInfo& info,
                                  RequestPriority priority,
                                  AddressList* addresses,
                                  const CompletionCallback& callback,
-                                 RequestHandle* out_req,
+                                 std::unique_ptr<Request>* out_req,
                                  const BoundNetLog& net_log) {
   return ERR_IO_PENDING;
 }