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

net/socket/socks_client_socket_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/socket/socks_client_socket.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 93 matching lines @@
 // We use this in the test "DisconnectWhileHostResolveInProgress" to make
 // sure that the outstanding resolve request gets cancelled.
 class HangingHostResolverWithCancel : public HostResolver {
  public:
   HangingHostResolverWithCancel() : outstanding_request_(NULL) {}
 
   int Resolve(const RequestInfo& info,
               RequestPriority priority,
               AddressList* addresses,
               const CompletionCallback& callback,
-              RequestHandle* out_req,
+              std::unique_ptr<Request>* out_req,
               const BoundNetLog& net_log) override {
     DCHECK(addresses);
     DCHECK_EQ(false, callback.is_null());
     EXPECT_FALSE(HasOutstandingRequest());
-    outstanding_request_ = reinterpret_cast<RequestHandle>(1);
-    *out_req = outstanding_request_;
+    outstanding_request_ = new RequestImpl(this);
+    (*out_req).reset(outstanding_request_);
+
     return ERR_IO_PENDING;
   }
 
   int ResolveFromCache(const RequestInfo& info,
                        AddressList* addresses,
                        const BoundNetLog& net_log) override {
     NOTIMPLEMENTED();
     return ERR_UNEXPECTED;
   }
 
-  void CancelRequest(RequestHandle req) override {
-    EXPECT_TRUE(HasOutstandingRequest());
-    EXPECT_EQ(outstanding_request_, req);
-    outstanding_request_ = NULL;
-  }
-
   bool HasOutstandingRequest() {
     return outstanding_request_ != NULL;
   }
 
  private:
-  RequestHandle outstanding_request_;
+  class RequestImpl : public HostResolver::Request {
+   public:
+    explicit RequestImpl(HangingHostResolverWithCancel* resolver)
+        : resolver_(resolver) {}
+
+    ~RequestImpl() override {
+      if (resolver_) {
+        EXPECT_TRUE(resolver_->HasOutstandingRequest());
+        EXPECT_EQ(resolver_->outstanding_request_, this);
+        resolver_->outstanding_request_ = nullptr;
+      }
+    }
+
+    void ChangeRequestPriority(RequestPriority priority) override {}
+
+    void RemoveResolver() { resolver_ = nullptr; }
+
+   private:
+    HangingHostResolverWithCancel* resolver_;
+
+    DISALLOW_COPY_AND_ASSIGN(RequestImpl);
+  };
+
+  friend RequestImpl;
+
+  RequestImpl* outstanding_request_;
 
   DISALLOW_COPY_AND_ASSIGN(HangingHostResolverWithCancel);
 };
 
 // Tests a complete handshake and the disconnection.
 TEST_F(SOCKSClientSocketTest, CompleteHandshake) {
   const std::string payload_write = "random data";
   const std::string payload_read = "moar random data";
 
   MockWrite data_writes[] = {
@@ skipping 299 matching lines @@
                                NULL, 0,
                                host_resolver.get(),
                                kHostName, 80,
                                NULL);
 
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED,
             callback_.GetResult(user_sock_->Connect(callback_.callback())));
 }
 
 }  // namespace net