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

chrome/browser/devtools/device/tcp_device_provider.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/tcp_device_provider.h"
 
 #include <utility>
 
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 18 matching lines @@
   callback.Run(result, std::move(socket));
 }
 
 class ResolveHostAndOpenSocket final {
  public:
   ResolveHostAndOpenSocket(const net::HostPortPair& address,
                            const AdbClientSocket::SocketCallback& callback)
       : callback_(callback) {
     host_resolver_ = net::HostResolver::CreateDefaultResolver(nullptr);
     net::HostResolver::RequestInfo request_info(address);
+    std::unique_ptr<net::HostResolver::Request> request;

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

Not needed (Note that there's also a bug below - you're passing request_ to
Resolve instead of request, but getting rid of request will result in fixing it,
anyways)

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

Ops...

     int result = host_resolver_->Resolve(
         request_info, net::DEFAULT_PRIORITY, &address_list_,
         base::Bind(&ResolveHostAndOpenSocket::OnResolved,
                    base::Unretained(this)),
-        nullptr, net::BoundNetLog());
+        &request_, net::BoundNetLog());
     if (result != net::ERR_IO_PENDING)
       OnResolved(result);
+    else if (result == net::ERR_IO_PENDING)
+      request_ = std::move(request);
   }
 
  private:
   void OnResolved(int result) {
     if (result < 0) {
       RunSocketCallback(callback_, nullptr, result);
       delete this;
       return;
     }
     std::unique_ptr<net::StreamSocket> socket(new net::TCPClientSocket(
         address_list_, NULL, NULL, net::NetLog::Source()));
     socket->Connect(
         base::Bind(&RunSocketCallback, callback_, base::Passed(&socket)));
     delete this;
   }
 
   std::unique_ptr<net::HostResolver> host_resolver_;
+  std::unique_ptr<net::HostResolver::Request> request_;
   net::AddressList address_list_;
   AdbClientSocket::SocketCallback callback_;
 };
 
 }  // namespace
 
 scoped_refptr<TCPDeviceProvider> TCPDeviceProvider::CreateForLocalhost(
     uint16_t port) {
   TCPDeviceProvider::HostPortSet targets;
   targets.insert(net::HostPortPair("127.0.0.1", port));
@@ skipping 52 matching lines @@
     release_callback_.Run();
 }
 
 void TCPDeviceProvider::set_release_callback_for_test(
     const base::Closure& callback) {
   release_callback_ = callback;
 }
 
 TCPDeviceProvider::~TCPDeviceProvider() {
 }