Http cache: It turns out that the cache destructor...

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-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 "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/scoped_vector.h"
 #include "base/string_util.h"
@@ skipping 1994 matching lines @@
   // We cannot call FinishCreation because the factory itself will go away with
   // the cache, so grab the callback and attempt to use it.
   net::CompletionCallback* callback = factory->callback();
 
   cache.reset();
   MessageLoop::current()->RunAllPending();
 
   callback->Run(net::ERR_ABORTED);
 }
 
+class DeleteCacheCompletionCallback : public TestCompletionCallback {
+ public:
+  explicit DeleteCacheCompletionCallback(MockHttpCache* cache)
+      : cache_(cache) {}
+
+  virtual void RunWithParams(const Tuple1<int>& params) {
+    delete cache_;
+    TestCompletionCallback::RunWithParams(params);
+  }
+
+ private:
+  MockHttpCache* cache_;
+};
+
+// Tests that we can delete the cache while creating the backend, from within
+// one of the callbacks.
+TEST(HttpCache, DeleteCacheWaitingForBackend2) {
+  MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
+  MockHttpCache* cache = new MockHttpCache(factory);
+
+  DeleteCacheCompletionCallback cb(cache);
+  disk_cache::Backend* backend;
+  int rv = cache->http_cache()->GetBackend(&backend, &cb);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+
+  // Now let's queue a regular transaction
+  MockHttpRequest request(kSimpleGET_Transaction);
+
+  scoped_ptr<Context> c(new Context());
+  c->result = cache->http_cache()->CreateTransaction(&c->trans);
+  EXPECT_EQ(net::OK, c->result);
+
+  c->trans->Start(&request, &c->callback, net::BoundNetLog());
+
+  // And another direct backend request.
+  TestCompletionCallback cb2;
+  rv = cache->http_cache()->GetBackend(&backend, &cb2);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+
+  // Just to make sure that everything is still pending.
+  MessageLoop::current()->RunAllPending();
+
+  // The request should be queued.
+  EXPECT_FALSE(c->callback.have_result());
+
+  // Generate the callback.
+  factory->FinishCreation();
+  rv = cb.WaitForResult();
+
+  // The cache should be gone by now.
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(net::OK, c->callback.GetResult(c->result));
+  EXPECT_FALSE(cb2.have_result());
+}
+
 TEST(HttpCache, TypicalGET_ConditionalRequest) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kTypicalGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
@@ skipping 2732 matching lines @@
   // Now return 200 when validating the entry so the metadata will be lost.
   MockTransaction trans2(kTypicalGET_Transaction);
   trans2.load_flags = net::LOAD_VALIDATE_CACHE;
   RunTransactionTestWithResponseInfo(cache.http_cache(), trans2, &response);
   EXPECT_TRUE(response.metadata.get() == NULL);
 
   EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(4, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }