Disk cache: Add explicit support for eviction / deletion...

net/disk_cache/entry_unittest.cc

 // Copyright (c) 2006-2009 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 "base/basictypes.h"
 #include "base/platform_thread.h"
 #include "base/timer.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 20 matching lines @@
   void GrowData();
   void TruncateData();
   void ZeroLengthIO();
   void ReuseEntry(int size);
   void InvalidData();
   void DoomEntry();
   void DoomedEntry();
   void BasicSparseIO(bool async);
   void HugeSparseIO(bool async);
   void GetAvailableRange();
+  void DoomSparseEntry();
 };
 
 void DiskCacheEntryTest::InternalSyncIO() {
   disk_cache::Entry *entry1 = NULL;
   ASSERT_TRUE(cache_->CreateEntry("the first key", &entry1));
   ASSERT_TRUE(NULL != entry1);
 
   const int kSize1 = 10;
   scoped_refptr<net::IOBuffer> buffer1 = new net::IOBuffer(kSize1);
   CacheTestFillBuffer(buffer1->data(), kSize1, false);
@@ skipping 768 matching lines @@
 }
 
 TEST_F(DiskCacheEntryTest, MemoryOnlyDoomedEntry) {
   SetMemoryOnlyMode();
   InitCache();
   DoomEntry();
 }
 
 // Test that child entries in a memory cache backend are not visible from
 // enumerations.
-TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSlaveEntries) {
+TEST_F(DiskCacheEntryTest, MemoryOnlyEnumerationWithSparseEntries) {
   SetMemoryOnlyMode();
   InitCache();
 
   const int kSize = 4096;
   scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
   CacheTestFillBuffer(buf->data(), kSize, false);
 
   std::string key("the first key");
   disk_cache::Entry* parent_entry;
   ASSERT_TRUE(cache_->CreateEntry(key, &parent_entry));
@@ skipping 281 matching lines @@
   // region.
   EXPECT_EQ(500, entry->GetAvailableRange(5000, 620, &start));
   EXPECT_EQ(5120, start);
 
   // Test that multiple blocks are scanned.
   EXPECT_EQ(8192, entry->GetAvailableRange(40000, 20000, &start));
   EXPECT_EQ(50000, start);
 
   entry->Close();
 }
+
+void DiskCacheEntryTest::DoomSparseEntry() {
+  std::string key1("the first key");
+  std::string key2("the second key");
+  disk_cache::Entry *entry1, *entry2;
+  ASSERT_TRUE(cache_->CreateEntry(key1, &entry1));
+  ASSERT_TRUE(cache_->CreateEntry(key2, &entry2));
+
+  const int kSize = 4 * 1024;
+  scoped_refptr<net::IOBuffer> buf = new net::IOBuffer(kSize);
+  CacheTestFillBuffer(buf->data(), kSize, false);
+
+  int64 offset = 1024;
+  // Write to a bunch of ranges.
+  for (int i = 0; i < 12; i++) {
+    EXPECT_EQ(kSize, entry1->WriteSparseData(offset, buf, kSize, NULL));
+    // Keep the second map under the default size.
+    if (i < 9)
+      EXPECT_EQ(kSize, entry2->WriteSparseData(offset, buf, kSize, NULL));
+    offset *= 4;
+  }
+
+  if (memory_only_)
+    EXPECT_EQ(2, cache_->GetEntryCount());
+  else
+    EXPECT_EQ(15, cache_->GetEntryCount());
+
+  // Doom the first entry while it's still open.
+  entry1->Doom();
+  entry1->Close();
+  entry2->Close();
+
+  // Doom the second entry after it's fully saved.
+  EXPECT_TRUE(cache_->DoomEntry(key2));
+
+  // Make sure we do all needed work. This may fail for entry2 if between Close
+  // and DoomEntry the system decides to remove all traces of the file from the
+  // system cache so we don't see that there is pending IO.
+  MessageLoop::current()->RunAllPending();
+
+  if (memory_only_)
+    EXPECT_EQ(0, cache_->GetEntryCount());
+  else
+    EXPECT_EQ(0, cache_->GetEntryCount());
+}
+
+TEST_F(DiskCacheEntryTest, DoomSparseEntry) {
+  InitCache();
+  DoomSparseEntry();
+}
+
+TEST_F(DiskCacheEntryTest, DISABLED_MemoryOnlyDoomSparseEntry) {
+  SetMemoryOnlyMode();
+  InitCache();
+  DoomSparseEntry();
+}