Change ProxyResolverMojo::Job to use mojo::StrongBindingSet.

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/values.h"
 #include "mojo/common/common_type_converters.h"
+#include "mojo/common/strong_binding_set.h"
 #include "mojo/common/url_type_converters.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/dns/mojo_host_resolver_impl.h"
 #include "net/interfaces/host_resolver_service.mojom.h"
 #include "net/interfaces/proxy_resolver_service.mojom.h"
 #include "net/proxy/mojo_proxy_resolver_factory.h"
 #include "net/proxy/mojo_proxy_type_converters.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 90 matching lines @@
   // ProxyResolver implementation:
   int GetProxyForURL(const GURL& url,
                      ProxyInfo* results,
                      const net::CompletionCallback& callback,
                      RequestHandle* request,
                      const BoundNetLog& net_log) override;
   void CancelRequest(RequestHandle request) override;
   LoadState GetLoadState(RequestHandle request) const override;
 
  private:
-  class Job;
+  class Job : public ClientMixin<interfaces::ProxyResolverRequestClient> {
+   public:
+    Job(ProxyResolverMojo* resolver,
+        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();
+
+   private:
+    // Overridden from interfaces::ProxyResolverRequestClient:
+    void ReportResult(
+        int32_t error,
+        mojo::Array<interfaces::ProxyServerPtr> proxy_servers) override;
+
+    ProxyResolverMojo* resolver_;
+    ProxyInfo* results_;
+    CompletionCallback callback_;
+
+    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_;
+  mojo::StrongBindingSet<Job> pending_jobs_;
 
   base::ThreadChecker thread_checker_;
 
   scoped_ptr<base::ScopedClosureRunner> on_delete_callback_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverMojo);
 };
 
-class ProxyResolverMojo::Job
-    : public ClientMixin<interfaces::ProxyResolverRequestClient> {
- 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();
-
- private:
-  // 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_;
-};
-
 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),
       resolver_(resolver),
-      url_(url),
       results_(results),
-      callback_(callback),
-      binding_(this) {
-  binding_.set_connection_error_handler(base::Bind(
-      &ProxyResolverMojo::Job::OnConnectionError, base::Unretained(this)));
-
-  interfaces::ProxyResolverRequestClientPtr client_ptr;
-  binding_.Bind(mojo::GetProxy(&client_ptr));
-  resolver_->mojo_proxy_resolver_ptr_->GetProxyForUrl(mojo::String::From(url_),
-                                                      client_ptr.Pass());
-}
+      callback_(callback) {}
 
 ProxyResolverMojo::Job::~Job() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!callback_.is_null())
     callback_.Run(ERR_PAC_SCRIPT_TERMINATED);
 }
 
 void ProxyResolverMojo::Job::Cancel() {
   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;
 }
 
-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());
   DVLOG(1) << "ProxyResolverMojo::Job::ReportResult: " << error;
 
   if (error == OK) {
     *results_ = proxy_servers.To<ProxyInfo>();
     DVLOG(1) << "Servers: " << results_->ToPacString();
   }
 
   CompletionCallback callback = callback_;
   callback_.Reset();
-  resolver_->RemoveJob(this);
+  resolver_->pending_jobs_.DestroyService(this);
   callback.Run(error);
 }
 
 ProxyResolverMojo::ProxyResolverMojo(
     interfaces::ProxyResolverPtr resolver_ptr,
     HostResolver* host_resolver,
     scoped_ptr<base::ScopedClosureRunner> on_delete_callback_runner,
     scoped_ptr<ProxyResolverErrorObserver> error_observer,
     NetLog* net_log)
     : mojo_proxy_resolver_ptr_(resolver_ptr.Pass()),
@@ skipping 12 matching lines @@
 }
 
 void ProxyResolverMojo::OnConnectionError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   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;
-}
-
 int ProxyResolverMojo::GetProxyForURL(const GURL& url,
                                       ProxyInfo* results,
                                       const CompletionCallback& callback,
                                       RequestHandle* 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;
-  DCHECK(inserted);
-  *request = job;
-
+  interfaces::ProxyResolverRequestClientPtr client_ptr;
+  *request = pending_jobs_.EmplaceService(mojo::GetProxy(&client_ptr), this,
+                                          results, callback, net_log);
+  mojo_proxy_resolver_ptr_->GetProxyForUrl(mojo::String::From(url),
+                                           client_ptr.Pass());
   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);
+  pending_jobs_.DestroyService(static_cast<Job*>(request));
 }
 
 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.
@@ skipping 81 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