Disk cache: Switch the disk cache to use the cache_thread....

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 351 matching lines @@
 bool MockDiskEntry::ignore_callbacks_ = false;
 
 class MockDiskCache : public disk_cache::Backend {
  public:
   MockDiskCache()
       : open_count_(0), create_count_(0), fail_requests_(false),
         soft_failures_(false) {
   }
 
   ~MockDiskCache() {
-    EntryMap::iterator it = entries_.begin();
-    for (; it != entries_.end(); ++it)
-      it->second->Release();
+    ReleaseAll();
   }
 
   virtual int32 GetEntryCount() const {
     return static_cast<int32>(entries_.size());
   }
 
   virtual int OpenEntry(const std::string& key, disk_cache::Entry** entry,
                         net::CompletionCallback* callback) {
     DCHECK(callback);
     if (fail_requests_)
@@ skipping 104 matching lines @@
 
   // returns number of times a cache entry was successfully created
   int create_count() const { return create_count_; }
 
   // Fail any subsequent CreateEntry and OpenEntry.
   void set_fail_requests() { fail_requests_ = true; }
 
   // Return entries that fail some of their requests.
   void set_soft_failures(bool value) { soft_failures_ = value; }
 
+  void ReleaseAll() {
+    EntryMap::iterator it = entries_.begin();
+    for (; it != entries_.end(); ++it)
+      it->second->Release();
+    entries_.clear();
+  }
+
  private:
   typedef base::hash_map<std::string, MockDiskEntry*> EntryMap;
 
   class CallbackRunner : public Task {
    public:
     CallbackRunner(net::CompletionCallback* callback, int result)
         : callback_(callback), result_(result) {}
     virtual void Run() {
       callback_->Run(result_);
     }
@@ skipping 1204 matching lines @@
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   for (int i = 1; i < kNumTransactions; ++i) {
     delete context_list[i];
   }
 }
 
+// Tests that we can cancel a single request to open a disk cache entry.
+TEST(HttpCache, SimpleGET_CancelCreate) {
+  MockHttpCache cache;
+
+  MockHttpRequest request(kSimpleGET_Transaction);
+
+  Context* c = new Context();
+
+  c->result = cache.http_cache()->CreateTransaction(&c->trans);
+  EXPECT_EQ(net::OK, c->result);
+
+  c->result = c->trans->Start(&request, &c->callback, net::BoundNetLog());
+  EXPECT_EQ(net::ERR_IO_PENDING, c->result);
+
+  // Release the reference that the mock disk cache keeps for this entry, so
+  // that we test that the http cache handles the cancelation correctly.
+  cache.disk_cache()->ReleaseAll();
+  delete c;
+
+  MessageLoop::current()->RunAllPending();
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
+}
+
 // Tests that we delete/create entries even if multiple requests are queued.
 TEST(HttpCache, SimpleGET_ManyWriters_BypassCache) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
   request.load_flags = net::LOAD_BYPASS_CACHE;
 
   std::vector<Context*> context_list;
   const int kNumTransactions = 5;
 
@@ skipping 2944 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());
 }