Use a base::LinkedList rather than a std::deque to back CertNetFetcherImpl's request list.

net/cert_net/cert_net_fetcher_impl.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/cert_net/cert_net_fetcher_impl.h"
 
-#include <deque>
-
 #include "base/callback_helpers.h"
+#include "base/containers/linked_list.h"
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/stl_util.h"
 #include "base/timer/timer.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/url_request_context.h"
 
 // TODO(eroman): Add support for POST parameters.
 // TODO(eroman): Add controls for bypassing the cache.
@@ skipping 47 matching lines @@
 }
 
 enum HttpMethod {
   HTTP_METHOD_GET,
   HTTP_METHOD_POST,
 };
 
 }  // namespace
 
 // CertNetFetcherImpl::RequestImpl tracks an outstanding call to Fetch().
-class CertNetFetcherImpl::RequestImpl : public CertNetFetcher::Request {
+class CertNetFetcherImpl::RequestImpl : public CertNetFetcher::Request,
+                                        public base::LinkNode<RequestImpl> {

[davidben, 2015/04/08 22:45:33]

Huh, I didn't know that existed. Neat.

  public:
   RequestImpl(Job* job, const FetchCallback& callback)
       : callback_(callback), job_(job) {
     DCHECK(!callback.is_null());
   }
 
   // Deletion cancels the outstanding request.
   ~RequestImpl() override;
 
   void OnJobCancelled(Job* job) {
@@ skipping 75 matching lines @@
   // Removes |request| from the job.
   void DetachRequest(RequestImpl* request);
 
   // Creates and starts a URLRequest for the job. After the request has
   // completed, OnJobCompleted() will be invoked and all the registered requests
   // notified of completion.
   void StartURLRequest(URLRequestContext* context);
 
  private:
   // The pointers in RequestList are not owned by the Job.
-  using RequestList = std::deque<RequestImpl*>;
+  using RequestList = base::LinkedList<RequestImpl>;
 
   // Implementation of URLRequest::Delegate
   void OnReceivedRedirect(URLRequest* request,
                           const RedirectInfo& redirect_info,
                           bool* defer_redirect) override;
   void OnResponseStarted(URLRequest* request) override;
   void OnReadCompleted(URLRequest* request, int bytes_read) override;
 
   // Clears the URLRequest and timer. Helper for doing work common to
   // cancellation and job completion.
@@ skipping 53 matching lines @@
       parent_(parent) {
 }
 
 CertNetFetcherImpl::Job::~Job() {
   Cancel();
 }
 
 void CertNetFetcherImpl::Job::Cancel() {
   parent_ = nullptr;
 
-  for (RequestImpl* request : requests_)
-    request->OnJobCancelled(this);
-  requests_.clear();
+  // Notify each request of cancellation and remove it from the list.
+  for (base::LinkNode<RequestImpl>* current = requests_.head();
+       current != requests_.end();) {
+    base::LinkNode<RequestImpl>* next = current->next();
+    current->value()->OnJobCancelled(this);
+    current->RemoveFromList();
+    current = next;
+  }
+
+  DCHECK(requests_.empty());
 
   Stop();
 }
 
 scoped_ptr<CertNetFetcher::Request> CertNetFetcherImpl::Job::CreateRequest(
     const FetchCallback& callback) {
   scoped_ptr<RequestImpl> request(new RequestImpl(this, callback));
-  requests_.push_back(request.get());
+  requests_.Append(request.get());
   return request.Pass();
 }
 
 void CertNetFetcherImpl::Job::DetachRequest(RequestImpl* request) {
   scoped_ptr<Job> delete_this;
 
-  // TODO(eroman): If a lot of requests are cancelled this is not efficient.
-  RequestList::iterator it =
-      std::find(requests_.begin(), requests_.end(), request);
-  CHECK(it != requests_.end());
-  requests_.erase(it);
+  request->RemoveFromList();
 
   // If there are no longer any requests attached to the job then
   // cancel and delete it.
   if (requests_.empty())
     delete_this = parent_->RemoveJob(this);
 }
 
 void CertNetFetcherImpl::Job::StartURLRequest(URLRequestContext* context) {
   Error error = CanFetchUrl(request_params_->url);
   if (error != OK) {
@@ skipping 127 matching lines @@
   // Invoking the callbacks is subtle as state may be mutated while iterating
   // through the callbacks:
   //
   //   * The parent CertNetFetcherImpl may be deleted
   //   * Requests in this job may be cancelled
 
   scoped_ptr<Job> delete_this = parent_->RemoveJob(this);
   parent_->SetCurrentlyCompletingJob(this);
 
   while (!requests_.empty()) {
-    RequestImpl* request = requests_.front();
-    requests_.pop_front();
-    request->OnJobCompleted(this, result_net_error_, response_body_);
+    base::LinkNode<RequestImpl>* request = requests_.head();
+    request->RemoveFromList();
+    request->value()->OnJobCompleted(this, result_net_error_, response_body_);
   }
 
   if (parent_)
     parent_->ClearCurrentlyCompletingJob(this);
 }
 
 CertNetFetcherImpl::CertNetFetcherImpl(URLRequestContext* context)
     : currently_completing_job_(nullptr), context_(context) {
 }
 
@@ skipping 109 matching lines @@
   DCHECK(job);
   currently_completing_job_ = job;
 }
 
 void CertNetFetcherImpl::ClearCurrentlyCompletingJob(Job* job) {
   DCHECK_EQ(currently_completing_job_, job);
   currently_completing_job_ = nullptr;
 }
 
 }  // namespace net