Change ProxyResolver::GetProxyForURL() to take a scoped_ptr<Request>* rather than a RequestHandle*

net/proxy/proxy_resolver_factory_mojo.cc

 // Copyright 2015 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_factory_mojo.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 100 matching lines @@
       HostResolver* host_resolver,
       scoped_ptr<base::ScopedClosureRunner> on_delete_callback_runner,
       scoped_ptr<ProxyResolverErrorObserver> error_observer,
       NetLog* net_log);
   ~ProxyResolverMojo() override;
 
   // ProxyResolver implementation:
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const net::CompletionCallback& callback,
-                     RequestHandle* request,
+                     scoped_ptr<Request>* request,
                      const BoundNetLog& net_log) override;
-  void CancelRequest(RequestHandle request) override;
-  LoadState GetLoadState(RequestHandle request) const override;
 
  private:
   class Job;
+  class RequestImpl;
+
+  base::ThreadChecker thread_checker_;
 
   // Mojo error handler.
   void OnConnectionError();
 
   void RemoveJob(Job* job);
 
   // Connection to the Mojo proxy resolver.
   interfaces::ProxyResolverPtr mojo_proxy_resolver_ptr_;
 
   HostResolver* host_resolver_;
 
   scoped_ptr<ProxyResolverErrorObserver> error_observer_;
 
   NetLog* net_log_;
 
   std::set<Job*> pending_jobs_;
 
-  base::ThreadChecker thread_checker_;
 
   scoped_ptr<base::ScopedClosureRunner> on_delete_callback_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverMojo);
 };
 
+class ProxyResolverMojo::RequestImpl : public ProxyResolver::Request {
+ public:
+  RequestImpl(base::WeakPtr<Job> job);
+
+  ~RequestImpl() override;
+
+  LoadState GetLoadState() override;
+
+ private:
+  base::WeakPtr<Job> job_;
+};
+
 class ProxyResolverMojo::Job
-    : public ClientMixin<interfaces::ProxyResolverRequestClient> {
+    : public ClientMixin<interfaces::ProxyResolverRequestClient>,
+      public base::SupportsWeakPtr<Job>,
+      public base::RefCounted<Job> {
  public:
   Job(ProxyResolverMojo* resolver,
       const GURL& url,
       ProxyInfo* results,
       const CompletionCallback& callback,
       const BoundNetLog& net_log);
-  ~Job() override;
 
   // Cancels the job and prevents the callback from being run.
   void Cancel();
 
   // Returns the LoadState of this job.
   LoadState GetLoadState();
 
+  ProxyResolverMojo* GetResolver();
+
+  // Delete seld owned refpointer
+  void Remove();
+
  private:
+  ~Job() override;
+  friend class base::RefCounted<Job>;
   // Mojo error handler.
   void OnConnectionError();
 
   // Overridden from interfaces::ProxyResolverRequestClient:
   void ReportResult(
       int32_t error,
       mojo::Array<interfaces::ProxyServerPtr> proxy_servers) override;
 
   ProxyResolverMojo* resolver_;
   const GURL url_;
   ProxyInfo* results_;
   CompletionCallback callback_;
 
   base::ThreadChecker thread_checker_;
   mojo::Binding<interfaces::ProxyResolverRequestClient> binding_;
+
+  // The job holds a reference to itself to ensure that it remains alive until
+  // either completion or cancellation. This is the only owner.
+  scoped_refptr<Job> owned_self_reference_ = this;
 };
 
+ProxyResolverMojo::RequestImpl::RequestImpl(base::WeakPtr<Job> job)
+    : job_(job) {}
+
+ProxyResolverMojo::RequestImpl::~RequestImpl() {
+  if (job_) {
+    job_->Cancel();
+    job_->GetResolver()->RemoveJob(job_.get());
+  }
+}
+
+LoadState ProxyResolverMojo::RequestImpl::GetLoadState() {
+  CHECK_EQ(1u, job_->GetResolver()->pending_jobs_.count(job_.get()));
+  return job_->GetLoadState();
+}
+
 ProxyResolverMojo::Job::Job(ProxyResolverMojo* resolver,
                             const GURL& url,
                             ProxyInfo* results,
                             const CompletionCallback& callback,
                             const BoundNetLog& net_log)
     : ClientMixin<interfaces::ProxyResolverRequestClient>(
           resolver->host_resolver_,
           resolver->error_observer_.get(),
           resolver->net_log_,
           net_log),
@@ skipping 20 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!callback_.is_null());
   callback_.Reset();
 }
 
 LoadState ProxyResolverMojo::Job::GetLoadState() {
   return dns_request_in_progress() ? LOAD_STATE_RESOLVING_HOST_IN_PROXY_SCRIPT
                                    : LOAD_STATE_RESOLVING_PROXY_FOR_URL;
 }
 
+ProxyResolverMojo* ProxyResolverMojo::Job::GetResolver() {
+  return resolver_;
+};
+
+void ProxyResolverMojo::Job::Remove() {
+  owned_self_reference_ = NULL;
+}
+
 void ProxyResolverMojo::Job::OnConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "ProxyResolverMojo::Job::OnConnectionError";
   resolver_->RemoveJob(this);
 }
 
 void ProxyResolverMojo::Job::ReportResult(
     int32_t error,
     mojo::Array<interfaces::ProxyServerPtr> proxy_servers) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 36 matching lines @@
   DVLOG(1) << "ProxyResolverMojo::OnConnectionError";
 
   // Disconnect from the Mojo proxy resolver service.
   mojo_proxy_resolver_ptr_.reset();
 }
 
 void ProxyResolverMojo::RemoveJob(Job* job) {
   DCHECK(thread_checker_.CalledOnValidThread());
   size_t num_erased = pending_jobs_.erase(job);
   DCHECK(num_erased);
-  delete job;
+  job->Remove();
 }
 
 int ProxyResolverMojo::GetProxyForURL(const GURL& url,
                                       ProxyInfo* results,
                                       const CompletionCallback& callback,
-                                      RequestHandle* request,
+                                      scoped_ptr<Request>* request,
                                       const BoundNetLog& net_log) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!mojo_proxy_resolver_ptr_)
     return ERR_PAC_SCRIPT_TERMINATED;
 
-  Job* job = new Job(this, url, results, callback, net_log);
-  bool inserted = pending_jobs_.insert(job).second;
+  // Job owns itselfs.
+  scoped_refptr<Job> job = new Job(this, url, results, callback, net_log);
+  bool inserted = pending_jobs_.insert(job.get()).second;
   DCHECK(inserted);
-  *request = job;
+  request->reset(new RequestImpl(job->AsWeakPtr()));
 
   return ERR_IO_PENDING;
 }
 
-void ProxyResolverMojo::CancelRequest(RequestHandle request) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  Job* job = static_cast<Job*>(request);
-  DCHECK(job);
-  job->Cancel();
-  RemoveJob(job);
-}
 
-LoadState ProxyResolverMojo::GetLoadState(RequestHandle request) const {
-  Job* job = static_cast<Job*>(request);
-  CHECK_EQ(1u, pending_jobs_.count(job));
-  return job->GetLoadState();
-}
 
 }  // namespace
 
 // A Job to create a ProxyResolver instance.
 //
 // Note: a Job instance is not tied to a particular resolve request, and hence
 // there is no per-request logging to be done (any netlog events are only sent
 // globally) so this always uses an empty BoundNetLog.
 class ProxyResolverFactoryMojo::Job
     : public ClientMixin<interfaces::ProxyResolverFactoryRequestClient>,
@@ skipping 79 matching lines @@
     return ERR_PAC_SCRIPT_FAILED;
   }
   request->reset(new Job(this, pac_script, resolver, callback,
                          error_observer_factory_.is_null()
                              ? nullptr
                              : error_observer_factory_.Run()));
   return ERR_IO_PENDING;
 }
 
 }  // namespace net