Http Cache: Don't delete the callback that is waiting for...

net/http/http_cache.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/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 
@@ skipping 116 matching lines @@
 
 // This class is a specialized type of CompletionCallback that allows us to
 // pass multiple arguments to the completion routine.
 class HttpCache::BackendCallback : public CallbackRunner<Tuple1<int> > {
  public:
   BackendCallback(HttpCache* cache, PendingOp* pending_op)
       : cache_(cache), pending_op_(pending_op) {}
   ~BackendCallback() {}
 
   virtual void RunWithParams(const Tuple1<int>& params) {
-    cache_->OnIOComplete(params.a, pending_op_);
+    if (cache_)
+      cache_->OnIOComplete(params.a, pending_op_);
     delete this;
   }
 
+  void Cancel() {
+    cache_ = NULL;
+  }
+
  private:
   HttpCache* cache_;
   PendingOp* pending_op_;
   DISALLOW_COPY_AND_ASSIGN(BackendCallback);
 };
 
 //-----------------------------------------------------------------------------
 
 // This class encapsulates a transaction whose only purpose is to write metadata
 // to a given entry.
@@ skipping 125 matching lines @@
   }
 
   STLDeleteElements(&doomed_entries_);
 
   PendingOpsMap::iterator pending_it = pending_ops_.begin();
   for (; pending_it != pending_ops_.end(); ++pending_it) {
     // We are not notifying the transactions about the cache going away, even
     // though they are waiting for a callback that will never fire.
     PendingOp* pending_op = pending_it->second;
     delete pending_op->writer;
-    delete pending_op->callback;
+    if (building_backend_) {
+      // If we don't have a backend, when its construction finishes it will
+      // deliver the callbacks.
+      BackendCallback* callback =
+          static_cast<BackendCallback*>(pending_op->callback);
+      callback->Cancel();
+    } else {
+      delete pending_op->callback;
+    }
 
     STLDeleteElements(&pending_op->pending_queue);
     delete pending_op;
   }
 }
 
 int HttpCache::GetBackend(disk_cache::Backend** backend,
                           CompletionCallback* callback) {
   DCHECK(callback != NULL);
 
@@ skipping 704 matching lines @@
     // This could be an external caller or a transaction waiting on Start().
     pending_item->DoCallback(result, temp_backend_);
     pending_item->NotifyTransaction(result, NULL);
   }
 
   DeletePendingOp(pending_op);
   building_backend_ = false;
 }
 
 }  // namespace net