Reland "Change ProxyResolver::GetProxyForURL() to take a unique_ptr<Request>* "

net/proxy/proxy_service.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/proxy/proxy_service.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 
@@ skipping 169 matching lines @@
 
 // Proxy resolver that fails every time.
 class ProxyResolverNull : public ProxyResolver {
  public:
   ProxyResolverNull() {}
 
   // ProxyResolver implementation.
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     RequestHandle* request,
+                     std::unique_ptr<Request>* request,
                      const NetLogWithSource& net_log) override {
     return ERR_NOT_IMPLEMENTED;
   }
 
-  void CancelRequest(RequestHandle request) override { NOTREACHED(); }
-
-  LoadState GetLoadState(RequestHandle request) const override {
-    NOTREACHED();
-    return LOAD_STATE_IDLE;
-  }
-
 };
 
 // ProxyResolver that simulates a PAC script which returns
 // |pac_string| for every single URL.
 class ProxyResolverFromPacString : public ProxyResolver {
  public:
   explicit ProxyResolverFromPacString(const std::string& pac_string)
       : pac_string_(pac_string) {}
 
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const CompletionCallback& callback,
-                     RequestHandle* request,
+                     std::unique_ptr<Request>* request,
                      const NetLogWithSource& net_log) override {
     results->UsePacString(pac_string_);
     return OK;
   }
 
-  void CancelRequest(RequestHandle request) override { NOTREACHED(); }
-
-  LoadState GetLoadState(RequestHandle request) const override {
-    NOTREACHED();
-    return LOAD_STATE_IDLE;
-  }
-
  private:
   const std::string pac_string_;
 };
 
 // Creates ProxyResolvers using a platform-specific implementation.
 class ProxyResolverFactoryForSystem : public MultiThreadedProxyResolverFactory {
  public:
   explicit ProxyResolverFactoryForSystem(size_t max_num_threads)
       : MultiThreadedProxyResolverFactory(max_num_threads,
                                           false /*expects_pac_bytes*/) {}
@@ skipping 556 matching lines @@
              ProxyDelegate* proxy_delegate,
              ProxyInfo* results,
              const CompletionCallback& user_callback,
              const NetLogWithSource& net_log)
       : service_(service),
         user_callback_(user_callback),
         results_(results),
         url_(url),
         method_(method),
         proxy_delegate_(proxy_delegate),
-        resolve_job_(NULL),
+        resolve_job_(nullptr),
         config_id_(ProxyConfig::kInvalidConfigID),
         config_source_(PROXY_CONFIG_SOURCE_UNKNOWN),
         net_log_(net_log),
         creation_time_(TimeTicks::Now()) {
     DCHECK(!user_callback.is_null());
   }
 
   // Starts the resolve proxy request.
   int Start() {
     DCHECK(!was_cancelled());
     DCHECK(!is_started());
 
     DCHECK(service_->config_.is_valid());
 
     config_id_ = service_->config_.id();
     config_source_ = service_->config_.source();
 
     return resolver()->GetProxyForURL(
         url_, results_,
         base::Bind(&PacRequest::QueryComplete, base::Unretained(this)),
         &resolve_job_, net_log_);
   }
 
   bool is_started() const {
     // Note that !! casts to bool. (VS gives a warning otherwise).
-    return !!resolve_job_;
+    return !!resolve_job_.get();
   }
 
   void StartAndCompleteCheckingForSynchronous() {
     int rv =
         service_->TryToCompleteSynchronously(url_, proxy_delegate_, results_);
     if (rv == ERR_IO_PENDING)
       rv = Start();
     if (rv != ERR_IO_PENDING)
       QueryComplete(rv);
   }
 
   void CancelResolveJob() {
     DCHECK(is_started());
     // The request may already be running in the resolver.
-    resolver()->CancelRequest(resolve_job_);
-    resolve_job_ = NULL;
+    resolve_job_.reset();
     DCHECK(!is_started());
   }
 
   void Cancel() {
     net_log_.AddEvent(NetLogEventType::CANCELLED);
 
     if (is_started())
       CancelResolveJob();
 
     // Mark as cancelled, to prevent accessing this again later.
     service_ = NULL;
     user_callback_.Reset();
     results_ = NULL;
 
     net_log_.EndEvent(NetLogEventType::PROXY_SERVICE);
   }
 
   // Returns true if Cancel() has been called.
   bool was_cancelled() const {
     return user_callback_.is_null();
   }
 
   // Helper to call after ProxyResolver completion (both synchronous and
   // asynchronous). Fixes up the result that is to be returned to user.
   int QueryDidComplete(int result_code) {
     DCHECK(!was_cancelled());
 
-    // This state is cleared when resolve_job_ is set to nullptr below.
+    // This state is cleared when resolve_job_ is reset below.
     bool script_executed = is_started();
 
     // Clear |resolve_job_| so is_started() returns false while
     // DidFinishResolvingProxy() runs.
-    resolve_job_ = nullptr;
+    resolve_job_.reset();
 
     // Note that DidFinishResolvingProxy might modify |results_|.
     int rv = service_->DidFinishResolvingProxy(url_, method_, proxy_delegate_,
                                                results_, result_code, net_log_,
                                                creation_time_, script_executed);
 
     // Make a note in the results which configuration was in use at the
     // time of the resolve.
     results_->config_id_ = config_id_;
     results_->config_source_ = config_source_;
     results_->did_use_pac_script_ = true;
     results_->proxy_resolve_start_time_ = creation_time_;
     results_->proxy_resolve_end_time_ = TimeTicks::Now();
 
     // Reset the state associated with in-progress-resolve.
     config_id_ = ProxyConfig::kInvalidConfigID;
     config_source_ = PROXY_CONFIG_SOURCE_UNKNOWN;
 
     return rv;
   }
 
   NetLogWithSource* net_log() { return &net_log_; }
 
   LoadState GetLoadState() const {
     if (is_started())
-      return resolver()->GetLoadState(resolve_job_);
+      return resolve_job_->GetLoadState();
     return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
   }
 
  private:
   friend class base::RefCounted<ProxyService::PacRequest>;
 
   ~PacRequest() {}
 
   // Callback for when the ProxyResolver request has completed.
   void QueryComplete(int result_code) {
@@ skipping 12 matching lines @@
 
   // Note that we don't hold a reference to the ProxyService. Outstanding
   // requests are cancelled during ~ProxyService, so this is guaranteed
   // to be valid throughout our lifetime.
   ProxyService* service_;
   CompletionCallback user_callback_;
   ProxyInfo* results_;
   GURL url_;
   std::string method_;
   ProxyDelegate* proxy_delegate_;
-  ProxyResolver::RequestHandle resolve_job_;
+  std::unique_ptr<ProxyResolver::Request> resolve_job_;
   ProxyConfig::ID config_id_;  // The config id when the resolve was started.
   ProxyConfigSource config_source_;  // The source of proxy settings.
   NetLogWithSource net_log_;
   // Time when the request was created.  Stored here rather than in |results_|
   // because the time in |results_| will be cleared.
   TimeTicks creation_time_;
 };
 
 // ProxyService ---------------------------------------------------------------
 
@@ skipping 723 matching lines @@
   State previous_state = ResetProxyConfig(false);
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 void ProxyService::OnDNSChanged() {
   OnIPAddressChanged();
 }
 
 }  // namespace net