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

net/proxy/proxy_resolver_v8_tracing_wrapper_unittest.cc

 // Copyright (c) 2013 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/proxy/proxy_resolver_v8_tracing_wrapper.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
@@ skipping 753 matching lines @@
 // has been received. The resolve requests it receives will never be completed.
 class BlockableHostResolver : public HostResolver {
  public:
   BlockableHostResolver()
       : num_cancelled_requests_(0), waiting_for_resolve_(false) {}
 
   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(callback.is_null());
     EXPECT_TRUE(out_req);
 
     if (!action_.is_null())
       action_.Run();
 
     // Indicate to the caller that a request was received.
     EXPECT_TRUE(waiting_for_resolve_);
     base::MessageLoop::current()->QuitWhenIdle();
 
     // This line is intentionally after action_.Run(), since one of the
     // tests does a cancellation inside of Resolve(), and it is more
     // interesting if *out_req hasn't been written yet at that point.
-    *out_req = reinterpret_cast<RequestHandle*>(1);  // Magic value.
+    (*out_req).reset(new RequestImpl(this));

[mmenke, 2016/07/19 19:03:56]

out_req->reset

 
     // Return ERR_IO_PENDING as this request will NEVER be completed.
     // Expectation is for the caller to later cancel the request.
     return ERR_IO_PENDING;
   }
 
   int ResolveFromCache(const RequestInfo& info,
                        AddressList* addresses,
                        const BoundNetLog& net_log) override {
     NOTREACHED();
     return ERR_DNS_CACHE_MISS;
   }
 
-  void CancelRequest(RequestHandle req) override {
-    EXPECT_EQ(reinterpret_cast<RequestHandle*>(1), req);
-    num_cancelled_requests_++;
-  }
+  void IncreaseNumOfCancelledRequests() { num_cancelled_requests_++; }
 
   void SetAction(const base::Callback<void(void)>& action) { action_ = action; }
 
   // Waits until Resolve() has been called.
   void WaitUntilRequestIsReceived() {
     waiting_for_resolve_ = true;
     base::RunLoop().Run();
     DCHECK(waiting_for_resolve_);
     waiting_for_resolve_ = false;
   }
 
   int num_cancelled_requests() const { return num_cancelled_requests_; }
 
  private:
+  class RequestImpl : public HostResolver::Request {
+   public:
+    RequestImpl(BlockableHostResolver* resolver) : resolver_(resolver) {}
+
+    ~RequestImpl() override {
+      if (resolver_)
+        resolver_->IncreaseNumOfCancelledRequests();
+    }
+
+    void ChangeRequestPriority(RequestPriority priority) override {}
+
+   private:
+    BlockableHostResolver* resolver_;
+
+    DISALLOW_COPY_AND_ASSIGN(RequestImpl);
+  };
+
   int num_cancelled_requests_;
   bool waiting_for_resolve_;
   base::Callback<void(void)> action_;
 };
 
 // This cancellation test exercises a more predictable cancellation codepath --
 // when the request has an outstanding DNS request in flight.
 TEST_F(ProxyResolverV8TracingWrapperTest,
        CancelWhileOutstandingNonBlockingDns) {
   BlockableHostResolver host_resolver;
@@ skipping 301 matching lines @@
                 proxy_uri.substr(0, proxy_uri.find(':') + 1));
     } else {
       NOTREACHED();
     }
   }
 }
 
 }  // namespace
 
 }  // namespace net