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

net/dns/single_request_host_resolver_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/single_request_host_resolver.h"
 
 #include "base/macros.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/log/net_log.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::test::IsError;
 using net::test::IsOk;
 
 namespace net {
 
 namespace {
-
 // Helper class used by SingleRequestHostResolverTest.Cancel test.
 // It checks that only one request is outstanding at a time, and that
 // it is cancelled before the class is destroyed.
 class HangingHostResolver : public HostResolver {
  public:
   HangingHostResolver() : outstanding_request_(NULL) {}
 
   ~HangingHostResolver() override { EXPECT_TRUE(!has_outstanding_request()); }
 
   bool has_outstanding_request() const {
     return 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 {
     EXPECT_FALSE(has_outstanding_request());
-    outstanding_request_ = reinterpret_cast<RequestHandle>(0x1234);
-    *out_req = outstanding_request_;
+    outstanding_request_ = new RequestImpl(this);
+    (*out_req).reset(outstanding_request_);
 
     // Never complete this request! Caller is expected to cancel it
     // before destroying the resolver.
     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(has_outstanding_request());
-    EXPECT_EQ(req, outstanding_request_);
-    outstanding_request_ = NULL;
-  }
+ private:
+  class RequestImpl : public HostResolver::Request {
+   public:
+    RequestImpl(HangingHostResolver* resolver) : resolver_(resolver) {}
 
- private:
-  RequestHandle outstanding_request_;
+    ~RequestImpl() override {
+      if (resolver_) {
+        EXPECT_TRUE(resolver_->has_outstanding_request());
+        EXPECT_EQ(resolver_->outstanding_request_, this);
+        resolver_->outstanding_request_ = nullptr;
+      }
+    }
+
+    void ChangeRequestPriority(RequestPriority priority) override {}
+
+    void RemoveResolver() { resolver_ = nullptr; }
+
+   private:
+    HangingHostResolver* resolver_;
+
+    DISALLOW_COPY_AND_ASSIGN(RequestImpl);
+  };
+
+  friend RequestImpl;
+
+  RequestImpl* outstanding_request_;
 
   DISALLOW_COPY_AND_ASSIGN(HangingHostResolver);
 };
 
 // Test that a regular end-to-end lookup returns the expected result.
 TEST(SingleRequestHostResolverTest, NormalResolve) {
   // Create a host resolver dependency that returns address "199.188.1.166"
   // for resolutions of "watsup".
   MockHostResolver resolver;
   resolver.rules()->AddIPLiteralRule("watsup", "199.188.1.166", std::string());
@@ skipping 46 matching lines @@
   SingleRequestHostResolver single_request_resolver(&resolver);
   single_request_resolver.Cancel();
 
   // To pass, HangingHostResolver should not have received a cancellation
   // request (since there is nothing to cancel). If it does, it will crash.
 }
 
 } // namespace
 
 }  // namespace net