The CertVerifierJob destructor should delete canceled requests....

net/base/cert_verifier.cc

 // Copyright (c) 2010 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/base/cert_verifier.h"
 
 #include "base/compiler_specific.h"
 #include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
@@ skipping 91 matching lines @@
   // Copies the contents of |verify_result| to the caller's
   // CertVerifyResult and calls the callback.
   void Post(const CachedCertVerifyResult& verify_result) {
     if (callback_) {
       *verify_result_ = verify_result.result;
       callback_->Run(verify_result.error);
     }
     delete this;
   }
 
+  bool canceled() const { return !callback_; }
+
  private:
   CompletionCallback* callback_;
   CertVerifyResult* verify_result_;
 };
 
 
 // CertVerifierWorker runs on a worker thread and takes care of the blocking
 // process of performing the certificate verification.  Deletes itself
 // eventually if Start() succeeds.
 class CertVerifierWorker {
@@ skipping 107 matching lines @@
 };
 
 // A CertVerifierJob is a one-to-one counterpart of a CertVerifierWorker. It
 // lives only on the CertVerifier's origin message loop.
 class CertVerifierJob {
  public:
   explicit CertVerifierJob(CertVerifierWorker* worker) : worker_(worker) {
   }
 
   ~CertVerifierJob() {
-    if (worker_)
+    if (worker_) {
       worker_->Cancel();
+      DeleteAllCanceled();
+    }
   }
 
   void AddRequest(CertVerifierRequest* request) {
     requests_.push_back(request);
   }
 
   void HandleResult(const CachedCertVerifyResult& verify_result) {
     worker_ = NULL;
     PostAll(verify_result);
   }
 
  private:
   void PostAll(const CachedCertVerifyResult& verify_result) {
     std::vector<CertVerifierRequest*> requests;
     requests_.swap(requests);
 
     for (std::vector<CertVerifierRequest*>::iterator
          i = requests.begin(); i != requests.end(); i++) {
       (*i)->Post(verify_result);
       // Post() causes the CertVerifierRequest to delete itself.
     }
   }
 
+  void DeleteAllCanceled() {
+    for (std::vector<CertVerifierRequest*>::iterator
+         i = requests_.begin(); i != requests_.end(); i++) {
+      if ((*i)->canceled()) {
+        delete *i;
+      } else {
+        LOG(DFATAL) << "CertVerifierRequest leaked!";
+      }
+    }
+  }
+
   std::vector<CertVerifierRequest*> requests_;
   CertVerifierWorker* worker_;
 };
 
 
 CertVerifier::CertVerifier()
     : time_service_(new DefaultTimeService),
       requests_(0),
       cache_hits_(0),
       inflight_joins_(0) {
@@ skipping 47 matching lines @@
   if (j != inflight_.end()) {
     // An identical request is in flight already. We'll just attach our
     // callback.
     inflight_joins_++;
     job = j->second;
   } else {
     // Need to make a new request.
     CertVerifierWorker* worker = new CertVerifierWorker(cert, hostname, flags,
                                                         this);
     job = new CertVerifierJob(worker);
-    inflight_.insert(std::make_pair(key, job));
     if (!worker->Start()) {
-      inflight_.erase(key);
       delete job;
       delete worker;
       *out_req = NULL;
-      return ERR_FAILED;  // TODO(wtc): Log an error message.
+      LOG(ERROR) << "CertVerifierWorker couldn't be started.";
+      return ERR_FAILED;

[willchan no longer on Chromium, 2011/01/04 21:33:54]

Is this ERR_FAILED ok?  I don't know if we can choose a better error code.  This
reminds me, are we logging anything to the NetLog?  That's a good TODO item to
add if you haven't already.

     }
+    inflight_.insert(std::make_pair(key, job));
   }
 
   CertVerifierRequest* request =
       new CertVerifierRequest(callback, verify_result);
   job->AddRequest(request);
   *out_req = request;
   return ERR_IO_PENDING;
 }
 
 void CertVerifier::CancelRequest(RequestHandle req) {
@@ skipping 123 matching lines @@
   cur_request_callback_ = NULL;
 
   // Call the user's original callback.
   callback->Run(result);
 }
 
 }  // namespace net
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(net::CertVerifierWorker);