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

chrome/browser/devtools/device/port_forwarding_controller.cc

 // Copyright 2014 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 "chrome/browser/devtools/device/port_forwarding_controller.h"
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 48 matching lines @@
 
  private:
   SocketTunnel(std::unique_ptr<net::StreamSocket> socket,
                const std::string& host,
                int port)
       : remote_socket_(std::move(socket)),
         pending_writes_(0),
         pending_destruction_(false) {
     host_resolver_ = net::HostResolver::CreateDefaultResolver(nullptr);
     net::HostResolver::RequestInfo request_info(net::HostPortPair(host, port));
+    std::unique_ptr<net::HostResolver::Request> request;

[mmenke, 2016/07/21 16:00:40]

You don't need this - if result != ERR_IO_PENDING, then host_reolver_->Resolve
doesn't modify its request parameter, anyways.

[maksims (do not use this acc), 2016/07/22 10:16:00]

Done.

     int result = host_resolver_->Resolve(
-        request_info,
-        net::DEFAULT_PRIORITY,
-        &address_list_,
-        base::Bind(&SocketTunnel::OnResolved, base::Unretained(this)),
-        nullptr,
+        request_info, net::DEFAULT_PRIORITY, &address_list_,
+        base::Bind(&SocketTunnel::OnResolved, base::Unretained(this)), &request,
         net::BoundNetLog());
     if (result != net::ERR_IO_PENDING)
       OnResolved(result);
+    else if (result == net::ERR_IO_PENDING)
+      request_ = std::move(request);
   }
 
   void OnResolved(int result) {
     if (result < 0) {
       SelfDestruct();
       return;
     }
 
     host_socket_.reset(new net::TCPClientSocket(address_list_, nullptr, nullptr,
                                                 net::NetLog::Source()));
@@ skipping 91 matching lines @@
     if (pending_writes_ > 0) {
       pending_destruction_ = true;
       return;
     }
     delete this;
   }
 
   std::unique_ptr<net::StreamSocket> remote_socket_;
   std::unique_ptr<net::StreamSocket> host_socket_;
   std::unique_ptr<net::HostResolver> host_resolver_;
+  std::unique_ptr<net::HostResolver::Request> request_;
   net::AddressList address_list_;
   int pending_writes_;
   bool pending_destruction_;
 };
 
 }  // namespace
 
 class PortForwardingController::Connection
     : public AndroidDeviceManager::AndroidWebSocket::Delegate {
  public:
@@ skipping 293 matching lines @@
       registry_copy.push_back(it->second);
     }
     STLDeleteElements(&registry_copy);
   }
 }
 
 void PortForwardingController::UpdateConnections() {
   for (Registry::iterator it = registry_.begin(); it != registry_.end(); ++it)
     it->second->UpdateForwardingMap(forwarding_map_);
 }