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

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 649 matching lines @@
       if (!fail_)
         *backend_ = new MockDiskCache();
       net::CompletionCallback* cb = callback_;
       callback_ = NULL;
       cb->Run(Result());  // This object can be deleted here.
     }
   }
 
   void set_fail(bool fail) { fail_ = fail; }
 
+  net::CompletionCallback* callback() { return callback_; }
+
  private:
   int Result() { return fail_ ? net::ERR_FAILED : net::OK; }
 
   disk_cache::Backend** backend_;
   net::CompletionCallback* callback_;
   bool block_;
   bool fail_;
 };
 
 //-----------------------------------------------------------------------------
@@ skipping 1292 matching lines @@
   context_list[2]->result =
       context_list[2]->callback.GetResult(context_list[2]->result);
   ReadAndVerifyTransaction(context_list[2]->trans.get(), kETagGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   delete context_list[2];
 }
 
+// Tests that we can delete the cache while creating the backend.
+TEST(HttpCache, DeleteCacheWaitingForBackend) {
+  MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
+  MockHttpCache* cache = new MockHttpCache(factory);
+
+  MockHttpRequest request(kSimpleGET_Transaction);
+
+  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());
+
+  // Just to make sure that everything is still pending.
+  MessageLoop::current()->RunAllPending();
+
+  // The request should be creating the disk cache.
+  EXPECT_FALSE(c->callback.have_result());
+
+  // 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();
+
+  delete cache;

[Paweł Hajdan Jr., 2010/07/16 21:45:51]

nit: How about using scoped pointers to make it much harder to leak things? You
could just reset the pointer at this point. Up to you.

+  MessageLoop::current()->RunAllPending();
+
+  callback->Run(net::ERR_ABORTED);
+  delete c;

[Paweł Hajdan Jr., 2010/07/16 21:45:51]

Similarly here.

+}
+
 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());
 }