net/disk_cache/backend_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/basictypes.h"
   6 #include "base/file_util.h"
   7 #include "base/metrics/field_trial.h"
   8 #include "base/port.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
  12 #include "base/threading/platform_thread.h"
  13 #include "base/threading/thread_restrictions.h"
  14 #include "net/base/cache_type.h"
  15 #include "net/base/io_buffer.h"
  16 #include "net/base/net_errors.h"
  17 #include "net/base/test_completion_callback.h"
  18 #include "net/disk_cache/backend_impl.h"
  19 #include "net/disk_cache/cache_util.h"
  20 #include "net/disk_cache/disk_cache_test_base.h"
  21 #include "net/disk_cache/disk_cache_test_util.h"
  22 #include "net/disk_cache/entry_impl.h"
  23 #include "net/disk_cache/experiments.h"
  24 #include "net/disk_cache/histogram_macros.h"
  25 #include "net/disk_cache/mapped_file.h"
  26 #include "net/disk_cache/mem_backend_impl.h"
  27 #include "net/disk_cache/simple/simple_backend_impl.h"
  28 #include "net/disk_cache/simple/simple_entry_format.h"
  29 #include "net/disk_cache/simple/simple_test_util.h"
  30 #include "net/disk_cache/simple/simple_util.h"
  31 #include "net/disk_cache/tracing_cache_backend.h"
  32 #include "testing/gtest/include/gtest/gtest.h"
  33
  34 #if defined(OS_WIN)
  35 #include "base/win/scoped_handle.h"
  36 #endif
  37
  38 using base::Time;
  39
  40 namespace {
  41
  42 const char kExistingEntryKey[] = "existing entry key";
  43
  44 scoped_ptr<disk_cache::BackendImpl> CreateExistingEntryCache(
  45     const base::Thread& cache_thread,
  46     base::FilePath& cache_path) {
  47   net::TestCompletionCallback cb;
  48
  49   scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
  50       cache_path, cache_thread.message_loop_proxy(), NULL));
  51   int rv = cache->Init(cb.callback());
  52   if (cb.GetResult(rv) != net::OK)
  53     return scoped_ptr<disk_cache::BackendImpl>();
  54
  55   disk_cache::Entry* entry = NULL;
  56   rv = cache->CreateEntry(kExistingEntryKey, &entry, cb.callback());
  57   if (cb.GetResult(rv) != net::OK)
  58     return scoped_ptr<disk_cache::BackendImpl>();
  59   entry->Close();
  60
  61   return cache.Pass();
  62 }
  63
  64 }  // namespace
  65
  66 // Tests that can run with different types of caches.
  67 class DiskCacheBackendTest : public DiskCacheTestWithCache {
  68  protected:
  69   void BackendBasics();
  70   void BackendKeying();
  71   void BackendShutdownWithPendingFileIO(bool fast);
  72   void BackendShutdownWithPendingIO(bool fast);
  73   void BackendShutdownWithPendingCreate(bool fast);
  74   void BackendSetSize();
  75   void BackendLoad();
  76   void BackendChain();
  77   void BackendValidEntry();
  78   void BackendInvalidEntry();
  79   void BackendInvalidEntryRead();
  80   void BackendInvalidEntryWithLoad();
  81   void BackendTrimInvalidEntry();
  82   void BackendTrimInvalidEntry2();
  83   void BackendEnumerations();
  84   void BackendEnumerations2();
  85   void BackendInvalidEntryEnumeration();
  86   void BackendFixEnumerators();
  87   void BackendDoomRecent();
  88
  89   // Adds 5 sparse entries. |doomed_start| and |doomed_end| if not NULL,
  90   // will be filled with times, used by DoomEntriesSince and DoomEntriesBetween.
  91   // There are 4 entries after doomed_start and 2 after doomed_end.
  92   void InitSparseCache(base::Time* doomed_start, base::Time* doomed_end);
  93
  94   void BackendDoomBetween();
  95   void BackendTransaction(const std::string& name, int num_entries, bool load);
  96   void BackendRecoverInsert();
  97   void BackendRecoverRemove();
  98   void BackendRecoverWithEviction();
  99   void BackendInvalidEntry2();
 100   void BackendInvalidEntry3();
 101   void BackendInvalidEntry7();
 102   void BackendInvalidEntry8();
 103   void BackendInvalidEntry9(bool eviction);
 104   void BackendInvalidEntry10(bool eviction);
 105   void BackendInvalidEntry11(bool eviction);
 106   void BackendTrimInvalidEntry12();
 107   void BackendDoomAll();
 108   void BackendDoomAll2();
 109   void BackendInvalidRankings();
 110   void BackendInvalidRankings2();
 111   void BackendDisable();
 112   void BackendDisable2();
 113   void BackendDisable3();
 114   void BackendDisable4();
 115   void TracingBackendBasics();
 116
 117   bool CreateSetOfRandomEntries(std::set<std::string>* key_pool);
 118   bool EnumerateAndMatchKeys(int max_to_open,
 119                              void** iter,
 120                              std::set<std::string>* keys_to_match,
 121                              size_t* count);
 122 };
 123
 124 void DiskCacheBackendTest::BackendBasics() {
 125   InitCache();
 126   disk_cache::Entry *entry1 = NULL, *entry2 = NULL;
 127   EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
 128   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
 129   ASSERT_TRUE(NULL != entry1);
 130   entry1->Close();
 131   entry1 = NULL;
 132
 133   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
 134   ASSERT_TRUE(NULL != entry1);
 135   entry1->Close();
 136   entry1 = NULL;
 137
 138   EXPECT_NE(net::OK, CreateEntry("the first key", &entry1));
 139   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
 140   EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
 141   ASSERT_EQ(net::OK, CreateEntry("some other key", &entry2));
 142   ASSERT_TRUE(NULL != entry1);
 143   ASSERT_TRUE(NULL != entry2);
 144   EXPECT_EQ(2, cache_->GetEntryCount());
 145
 146   disk_cache::Entry* entry3 = NULL;
 147   ASSERT_EQ(net::OK, OpenEntry("some other key", &entry3));
 148   ASSERT_TRUE(NULL != entry3);
 149   EXPECT_TRUE(entry2 == entry3);
 150   EXPECT_EQ(2, cache_->GetEntryCount());
 151
 152   EXPECT_EQ(net::OK, DoomEntry("some other key"));
 153   EXPECT_EQ(1, cache_->GetEntryCount());
 154   entry1->Close();
 155   entry2->Close();
 156   entry3->Close();
 157
 158   EXPECT_EQ(net::OK, DoomEntry("the first key"));
 159   EXPECT_EQ(0, cache_->GetEntryCount());
 160
 161   ASSERT_EQ(net::OK, CreateEntry("the first key", &entry1));
 162   ASSERT_EQ(net::OK, CreateEntry("some other key", &entry2));
 163   entry1->Doom();
 164   entry1->Close();
 165   EXPECT_EQ(net::OK, DoomEntry("some other key"));
 166   EXPECT_EQ(0, cache_->GetEntryCount());
 167   entry2->Close();
 168 }
 169
 170 TEST_F(DiskCacheBackendTest, Basics) {
 171   BackendBasics();
 172 }
 173
 174 TEST_F(DiskCacheBackendTest, NewEvictionBasics) {
 175   SetNewEviction();
 176   BackendBasics();
 177 }
 178
 179 TEST_F(DiskCacheBackendTest, MemoryOnlyBasics) {
 180   SetMemoryOnlyMode();
 181   BackendBasics();
 182 }
 183
 184 TEST_F(DiskCacheBackendTest, AppCacheBasics) {
 185   SetCacheType(net::APP_CACHE);
 186   BackendBasics();
 187 }
 188
 189 TEST_F(DiskCacheBackendTest, ShaderCacheBasics) {
 190   SetCacheType(net::SHADER_CACHE);
 191   BackendBasics();
 192 }
 193
 194 void DiskCacheBackendTest::BackendKeying() {
 195   InitCache();
 196   const char* kName1 = "the first key";
 197   const char* kName2 = "the first Key";
 198   disk_cache::Entry *entry1, *entry2;
 199   ASSERT_EQ(net::OK, CreateEntry(kName1, &entry1));
 200
 201   ASSERT_EQ(net::OK, CreateEntry(kName2, &entry2));
 202   EXPECT_TRUE(entry1 != entry2) << "Case sensitive";
 203   entry2->Close();
 204
 205   char buffer[30];
 206   base::strlcpy(buffer, kName1, arraysize(buffer));
 207   ASSERT_EQ(net::OK, OpenEntry(buffer, &entry2));
 208   EXPECT_TRUE(entry1 == entry2);
 209   entry2->Close();
 210
 211   base::strlcpy(buffer + 1, kName1, arraysize(buffer) - 1);
 212   ASSERT_EQ(net::OK, OpenEntry(buffer + 1, &entry2));
 213   EXPECT_TRUE(entry1 == entry2);
 214   entry2->Close();
 215
 216   base::strlcpy(buffer + 3,  kName1, arraysize(buffer) - 3);
 217   ASSERT_EQ(net::OK, OpenEntry(buffer + 3, &entry2));
 218   EXPECT_TRUE(entry1 == entry2);
 219   entry2->Close();
 220
 221   // Now verify long keys.
 222   char buffer2[20000];
 223   memset(buffer2, 's', sizeof(buffer2));
 224   buffer2[1023] = '\0';
 225   ASSERT_EQ(net::OK, CreateEntry(buffer2, &entry2)) << "key on block file";
 226   entry2->Close();
 227
 228   buffer2[1023] = 'g';
 229   buffer2[19999] = '\0';
 230   ASSERT_EQ(net::OK, CreateEntry(buffer2, &entry2)) << "key on external file";
 231   entry2->Close();
 232   entry1->Close();
 233 }
 234
 235 TEST_F(DiskCacheBackendTest, Keying) {
 236   BackendKeying();
 237 }
 238
 239 TEST_F(DiskCacheBackendTest, NewEvictionKeying) {
 240   SetNewEviction();
 241   BackendKeying();
 242 }
 243
 244 TEST_F(DiskCacheBackendTest, MemoryOnlyKeying) {
 245   SetMemoryOnlyMode();
 246   BackendKeying();
 247 }
 248
 249 TEST_F(DiskCacheBackendTest, AppCacheKeying) {
 250   SetCacheType(net::APP_CACHE);
 251   BackendKeying();
 252 }
 253
 254 TEST_F(DiskCacheBackendTest, ShaderCacheKeying) {
 255   SetCacheType(net::SHADER_CACHE);
 256   BackendKeying();
 257 }
 258
 259 TEST_F(DiskCacheTest, CreateBackend) {
 260   net::TestCompletionCallback cb;
 261
 262   {
 263     ASSERT_TRUE(CleanupCacheDir());
 264     base::Thread cache_thread("CacheThread");
 265     ASSERT_TRUE(cache_thread.StartWithOptions(
 266         base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 267
 268     // Test the private factory method(s).
 269     scoped_ptr<disk_cache::Backend> cache;
 270     cache = disk_cache::MemBackendImpl::CreateBackend(0, NULL);
 271     ASSERT_TRUE(cache.get());
 272     cache.reset();
 273
 274     // Now test the public API.
 275     int rv =
 276         disk_cache::CreateCacheBackend(net::DISK_CACHE,
 277                                        net::CACHE_BACKEND_DEFAULT,
 278                                        cache_path_,
 279                                        0,
 280                                        false,
 281                                        cache_thread.message_loop_proxy().get(),
 282                                        NULL,
 283                                        &cache,
 284                                        cb.callback());
 285     ASSERT_EQ(net::OK, cb.GetResult(rv));
 286     ASSERT_TRUE(cache.get());
 287     cache.reset();
 288
 289     rv = disk_cache::CreateCacheBackend(net::MEMORY_CACHE,
 290                                         net::CACHE_BACKEND_DEFAULT,
 291                                         base::FilePath(), 0,
 292                                         false, NULL, NULL, &cache,
 293                                         cb.callback());
 294     ASSERT_EQ(net::OK, cb.GetResult(rv));
 295     ASSERT_TRUE(cache.get());
 296     cache.reset();
 297   }
 298
 299   base::MessageLoop::current()->RunUntilIdle();
 300 }
 301
 302 // Tests that |BackendImpl| fails to initialize with a missing file.
 303 TEST_F(DiskCacheBackendTest, CreateBackend_MissingFile) {
 304   ASSERT_TRUE(CopyTestCache("bad_entry"));
 305   base::FilePath filename = cache_path_.AppendASCII("data_1");
 306   base::DeleteFile(filename, false);
 307   base::Thread cache_thread("CacheThread");
 308   ASSERT_TRUE(cache_thread.StartWithOptions(
 309       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 310   net::TestCompletionCallback cb;
 311
 312   bool prev = base::ThreadRestrictions::SetIOAllowed(false);
 313   scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
 314       cache_path_, cache_thread.message_loop_proxy().get(), NULL));
 315   int rv = cache->Init(cb.callback());
 316   ASSERT_EQ(net::ERR_FAILED, cb.GetResult(rv));
 317   base::ThreadRestrictions::SetIOAllowed(prev);
 318
 319   cache.reset();
 320   DisableIntegrityCheck();
 321 }
 322
 323 TEST_F(DiskCacheBackendTest, ExternalFiles) {
 324   InitCache();
 325   // First, let's create a file on the folder.
 326   base::FilePath filename = cache_path_.AppendASCII("f_000001");
 327
 328   const int kSize = 50;
 329   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
 330   CacheTestFillBuffer(buffer1->data(), kSize, false);
 331   ASSERT_EQ(kSize, file_util::WriteFile(filename, buffer1->data(), kSize));
 332
 333   // Now let's create a file with the cache.
 334   disk_cache::Entry* entry;
 335   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
 336   ASSERT_EQ(0, WriteData(entry, 0, 20000, buffer1.get(), 0, false));
 337   entry->Close();
 338
 339   // And verify that the first file is still there.
 340   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
 341   ASSERT_EQ(kSize, file_util::ReadFile(filename, buffer2->data(), kSize));
 342   EXPECT_EQ(0, memcmp(buffer1->data(), buffer2->data(), kSize));
 343 }
 344
 345 // Tests that we deal with file-level pending operations at destruction time.
 346 void DiskCacheBackendTest::BackendShutdownWithPendingFileIO(bool fast) {
 347   net::TestCompletionCallback cb;
 348   int rv;
 349
 350   {
 351     ASSERT_TRUE(CleanupCacheDir());
 352     base::Thread cache_thread("CacheThread");
 353     ASSERT_TRUE(cache_thread.StartWithOptions(
 354         base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 355
 356     uint32 flags = disk_cache::kNoBuffering;
 357     if (!fast)
 358       flags |= disk_cache::kNoRandom;
 359
 360     UseCurrentThread();
 361     CreateBackend(flags, NULL);
 362
 363     disk_cache::EntryImpl* entry;
 364     rv = cache_->CreateEntry(
 365         "some key", reinterpret_cast<disk_cache::Entry**>(&entry),
 366         cb.callback());
 367     ASSERT_EQ(net::OK, cb.GetResult(rv));
 368
 369     const int kSize = 25000;
 370     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
 371     CacheTestFillBuffer(buffer->data(), kSize, false);
 372
 373     for (int i = 0; i < 10 * 1024 * 1024; i += 64 * 1024) {
 374       // We are using the current thread as the cache thread because we want to
 375       // be able to call directly this method to make sure that the OS (instead
 376       // of us switching thread) is returning IO pending.
 377       rv =
 378           entry->WriteDataImpl(0, i, buffer.get(), kSize, cb.callback(), false);
 379       if (rv == net::ERR_IO_PENDING)
 380         break;
 381       EXPECT_EQ(kSize, rv);
 382     }
 383
 384     // Don't call Close() to avoid going through the queue or we'll deadlock
 385     // waiting for the operation to finish.
 386     entry->Release();
 387
 388     // The cache destructor will see one pending operation here.
 389     cache_.reset();
 390
 391     if (rv == net::ERR_IO_PENDING) {
 392       if (fast)
 393         EXPECT_FALSE(cb.have_result());
 394       else
 395         EXPECT_TRUE(cb.have_result());
 396     }
 397   }
 398
 399   base::MessageLoop::current()->RunUntilIdle();
 400
 401 #if defined(OS_WIN)
 402   // Wait for the actual operation to complete, or we'll keep a file handle that
 403   // may cause issues later. Note that on Posix systems even though this test
 404   // uses a single thread, the actual IO is posted to a worker thread and the
 405   // cache destructor breaks the link to reach cb when the operation completes.
 406   rv = cb.GetResult(rv);
 407 #endif
 408 }
 409
 410 TEST_F(DiskCacheBackendTest, ShutdownWithPendingFileIO) {
 411   BackendShutdownWithPendingFileIO(false);
 412 }
 413
 414 // Here and below, tests that simulate crashes are not compiled in LeakSanitizer
 415 // builds because they contain a lot of intentional memory leaks.
 416 // The wrapper scripts used to run tests under Valgrind Memcheck and
 417 // Heapchecker will also disable these tests under those tools. See:
 418 // tools/valgrind/gtest_exclude/net_unittests.gtest-memcheck.txt
 419 // tools/heapcheck/net_unittests.gtest-heapcheck.txt
 420 #if !defined(LEAK_SANITIZER)
 421 // We'll be leaking from this test.
 422 TEST_F(DiskCacheBackendTest, ShutdownWithPendingFileIO_Fast) {
 423   // The integrity test sets kNoRandom so there's a version mismatch if we don't
 424   // force new eviction.
 425   SetNewEviction();
 426   BackendShutdownWithPendingFileIO(true);
 427 }
 428 #endif
 429
 430 // Tests that we deal with background-thread pending operations.
 431 void DiskCacheBackendTest::BackendShutdownWithPendingIO(bool fast) {
 432   net::TestCompletionCallback cb;
 433
 434   {
 435     ASSERT_TRUE(CleanupCacheDir());
 436     base::Thread cache_thread("CacheThread");
 437     ASSERT_TRUE(cache_thread.StartWithOptions(
 438         base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 439
 440     uint32 flags = disk_cache::kNoBuffering;
 441     if (!fast)
 442       flags |= disk_cache::kNoRandom;
 443
 444     CreateBackend(flags, &cache_thread);
 445
 446     disk_cache::Entry* entry;
 447     int rv = cache_->CreateEntry("some key", &entry, cb.callback());
 448     ASSERT_EQ(net::OK, cb.GetResult(rv));
 449
 450     entry->Close();
 451
 452     // The cache destructor will see one pending operation here.
 453     cache_.reset();
 454   }
 455
 456   base::MessageLoop::current()->RunUntilIdle();
 457 }
 458
 459 TEST_F(DiskCacheBackendTest, ShutdownWithPendingIO) {
 460   BackendShutdownWithPendingIO(false);
 461 }
 462
 463 #if !defined(LEAK_SANITIZER)
 464 // We'll be leaking from this test.
 465 TEST_F(DiskCacheBackendTest, ShutdownWithPendingIO_Fast) {
 466   // The integrity test sets kNoRandom so there's a version mismatch if we don't
 467   // force new eviction.
 468   SetNewEviction();
 469   BackendShutdownWithPendingIO(true);
 470 }
 471 #endif
 472
 473 // Tests that we deal with create-type pending operations.
 474 void DiskCacheBackendTest::BackendShutdownWithPendingCreate(bool fast) {
 475   net::TestCompletionCallback cb;
 476
 477   {
 478     ASSERT_TRUE(CleanupCacheDir());
 479     base::Thread cache_thread("CacheThread");
 480     ASSERT_TRUE(cache_thread.StartWithOptions(
 481         base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 482
 483     disk_cache::BackendFlags flags =
 484       fast ? disk_cache::kNone : disk_cache::kNoRandom;
 485     CreateBackend(flags, &cache_thread);
 486
 487     disk_cache::Entry* entry;
 488     int rv = cache_->CreateEntry("some key", &entry, cb.callback());
 489     ASSERT_EQ(net::ERR_IO_PENDING, rv);
 490
 491     cache_.reset();
 492     EXPECT_FALSE(cb.have_result());
 493   }
 494
 495   base::MessageLoop::current()->RunUntilIdle();
 496 }
 497
 498 TEST_F(DiskCacheBackendTest, ShutdownWithPendingCreate) {
 499   BackendShutdownWithPendingCreate(false);
 500 }
 501
 502 #if !defined(LEAK_SANITIZER)
 503 // We'll be leaking an entry from this test.
 504 TEST_F(DiskCacheBackendTest, ShutdownWithPendingCreate_Fast) {
 505   // The integrity test sets kNoRandom so there's a version mismatch if we don't
 506   // force new eviction.
 507   SetNewEviction();
 508   BackendShutdownWithPendingCreate(true);
 509 }
 510 #endif
 511
 512 TEST_F(DiskCacheTest, TruncatedIndex) {
 513   ASSERT_TRUE(CleanupCacheDir());
 514   base::FilePath index = cache_path_.AppendASCII("index");
 515   ASSERT_EQ(5, file_util::WriteFile(index, "hello", 5));
 516
 517   base::Thread cache_thread("CacheThread");
 518   ASSERT_TRUE(cache_thread.StartWithOptions(
 519       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 520   net::TestCompletionCallback cb;
 521
 522   scoped_ptr<disk_cache::Backend> backend;
 523   int rv =
 524       disk_cache::CreateCacheBackend(net::DISK_CACHE,
 525                                      net::CACHE_BACKEND_BLOCKFILE,
 526                                      cache_path_,
 527                                      0,
 528                                      false,
 529                                      cache_thread.message_loop_proxy().get(),
 530                                      NULL,
 531                                      &backend,
 532                                      cb.callback());
 533   ASSERT_NE(net::OK, cb.GetResult(rv));
 534
 535   ASSERT_FALSE(backend);
 536 }
 537
 538 void DiskCacheBackendTest::BackendSetSize() {
 539   const int cache_size = 0x10000;  // 64 kB
 540   SetMaxSize(cache_size);
 541   InitCache();
 542
 543   std::string first("some key");
 544   std::string second("something else");
 545   disk_cache::Entry* entry;
 546   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
 547
 548   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(cache_size));
 549   memset(buffer->data(), 0, cache_size);
 550   EXPECT_EQ(cache_size / 10,
 551             WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false))
 552       << "normal file";
 553
 554   EXPECT_EQ(net::ERR_FAILED,
 555             WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false))
 556       << "file size above the limit";
 557
 558   // By doubling the total size, we make this file cacheable.
 559   SetMaxSize(cache_size * 2);
 560   EXPECT_EQ(cache_size / 5,
 561             WriteData(entry, 1, 0, buffer.get(), cache_size / 5, false));
 562
 563   // Let's fill up the cache!.
 564   SetMaxSize(cache_size * 10);
 565   EXPECT_EQ(cache_size * 3 / 4,
 566             WriteData(entry, 0, 0, buffer.get(), cache_size * 3 / 4, false));
 567   entry->Close();
 568   FlushQueueForTest();
 569
 570   SetMaxSize(cache_size);
 571
 572   // The cache is 95% full.
 573
 574   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
 575   EXPECT_EQ(cache_size / 10,
 576             WriteData(entry, 0, 0, buffer.get(), cache_size / 10, false));
 577
 578   disk_cache::Entry* entry2;
 579   ASSERT_EQ(net::OK, CreateEntry("an extra key", &entry2));
 580   EXPECT_EQ(cache_size / 10,
 581             WriteData(entry2, 0, 0, buffer.get(), cache_size / 10, false));
 582   entry2->Close();  // This will trigger the cache trim.
 583
 584   EXPECT_NE(net::OK, OpenEntry(first, &entry2));
 585
 586   FlushQueueForTest();  // Make sure that we are done trimming the cache.
 587   FlushQueueForTest();  // We may have posted two tasks to evict stuff.
 588
 589   entry->Close();
 590   ASSERT_EQ(net::OK, OpenEntry(second, &entry));
 591   EXPECT_EQ(cache_size / 10, entry->GetDataSize(0));
 592   entry->Close();
 593 }
 594
 595 TEST_F(DiskCacheBackendTest, SetSize) {
 596   BackendSetSize();
 597 }
 598
 599 TEST_F(DiskCacheBackendTest, NewEvictionSetSize) {
 600   SetNewEviction();
 601   BackendSetSize();
 602 }
 603
 604 TEST_F(DiskCacheBackendTest, MemoryOnlySetSize) {
 605   SetMemoryOnlyMode();
 606   BackendSetSize();
 607 }
 608
 609 void DiskCacheBackendTest::BackendLoad() {
 610   InitCache();
 611   int seed = static_cast<int>(Time::Now().ToInternalValue());
 612   srand(seed);
 613
 614   disk_cache::Entry* entries[100];
 615   for (int i = 0; i < 100; i++) {
 616     std::string key = GenerateKey(true);
 617     ASSERT_EQ(net::OK, CreateEntry(key, &entries[i]));
 618   }
 619   EXPECT_EQ(100, cache_->GetEntryCount());
 620
 621   for (int i = 0; i < 100; i++) {
 622     int source1 = rand() % 100;
 623     int source2 = rand() % 100;
 624     disk_cache::Entry* temp = entries[source1];
 625     entries[source1] = entries[source2];
 626     entries[source2] = temp;
 627   }
 628
 629   for (int i = 0; i < 100; i++) {
 630     disk_cache::Entry* entry;
 631     ASSERT_EQ(net::OK, OpenEntry(entries[i]->GetKey(), &entry));
 632     EXPECT_TRUE(entry == entries[i]);
 633     entry->Close();
 634     entries[i]->Doom();
 635     entries[i]->Close();
 636   }
 637   FlushQueueForTest();
 638   EXPECT_EQ(0, cache_->GetEntryCount());
 639 }
 640
 641 TEST_F(DiskCacheBackendTest, Load) {
 642   // Work with a tiny index table (16 entries)
 643   SetMask(0xf);
 644   SetMaxSize(0x100000);
 645   BackendLoad();
 646 }
 647
 648 TEST_F(DiskCacheBackendTest, NewEvictionLoad) {
 649   SetNewEviction();
 650   // Work with a tiny index table (16 entries)
 651   SetMask(0xf);
 652   SetMaxSize(0x100000);
 653   BackendLoad();
 654 }
 655
 656 TEST_F(DiskCacheBackendTest, MemoryOnlyLoad) {
 657   SetMaxSize(0x100000);
 658   SetMemoryOnlyMode();
 659   BackendLoad();
 660 }
 661
 662 TEST_F(DiskCacheBackendTest, AppCacheLoad) {
 663   SetCacheType(net::APP_CACHE);
 664   // Work with a tiny index table (16 entries)
 665   SetMask(0xf);
 666   SetMaxSize(0x100000);
 667   BackendLoad();
 668 }
 669
 670 TEST_F(DiskCacheBackendTest, ShaderCacheLoad) {
 671   SetCacheType(net::SHADER_CACHE);
 672   // Work with a tiny index table (16 entries)
 673   SetMask(0xf);
 674   SetMaxSize(0x100000);
 675   BackendLoad();
 676 }
 677
 678 // Tests the chaining of an entry to the current head.
 679 void DiskCacheBackendTest::BackendChain() {
 680   SetMask(0x1);  // 2-entry table.
 681   SetMaxSize(0x3000);  // 12 kB.
 682   InitCache();
 683
 684   disk_cache::Entry* entry;
 685   ASSERT_EQ(net::OK, CreateEntry("The first key", &entry));
 686   entry->Close();
 687   ASSERT_EQ(net::OK, CreateEntry("The Second key", &entry));
 688   entry->Close();
 689 }
 690
 691 TEST_F(DiskCacheBackendTest, Chain) {
 692   BackendChain();
 693 }
 694
 695 TEST_F(DiskCacheBackendTest, NewEvictionChain) {
 696   SetNewEviction();
 697   BackendChain();
 698 }
 699
 700 TEST_F(DiskCacheBackendTest, AppCacheChain) {
 701   SetCacheType(net::APP_CACHE);
 702   BackendChain();
 703 }
 704
 705 TEST_F(DiskCacheBackendTest, ShaderCacheChain) {
 706   SetCacheType(net::SHADER_CACHE);
 707   BackendChain();
 708 }
 709
 710 TEST_F(DiskCacheBackendTest, NewEvictionTrim) {
 711   SetNewEviction();
 712   InitCache();
 713
 714   disk_cache::Entry* entry;
 715   for (int i = 0; i < 100; i++) {
 716     std::string name(base::StringPrintf("Key %d", i));
 717     ASSERT_EQ(net::OK, CreateEntry(name, &entry));
 718     entry->Close();
 719     if (i < 90) {
 720       // Entries 0 to 89 are in list 1; 90 to 99 are in list 0.
 721       ASSERT_EQ(net::OK, OpenEntry(name, &entry));
 722       entry->Close();
 723     }
 724   }
 725
 726   // The first eviction must come from list 1 (10% limit), the second must come
 727   // from list 0.
 728   TrimForTest(false);
 729   EXPECT_NE(net::OK, OpenEntry("Key 0", &entry));
 730   TrimForTest(false);
 731   EXPECT_NE(net::OK, OpenEntry("Key 90", &entry));
 732
 733   // Double check that we still have the list tails.
 734   ASSERT_EQ(net::OK, OpenEntry("Key 1", &entry));
 735   entry->Close();
 736   ASSERT_EQ(net::OK, OpenEntry("Key 91", &entry));
 737   entry->Close();
 738 }
 739
 740 // Before looking for invalid entries, let's check a valid entry.
 741 void DiskCacheBackendTest::BackendValidEntry() {
 742   InitCache();
 743
 744   std::string key("Some key");
 745   disk_cache::Entry* entry;
 746   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 747
 748   const int kSize = 50;
 749   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
 750   memset(buffer1->data(), 0, kSize);
 751   base::strlcpy(buffer1->data(), "And the data to save", kSize);
 752   EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer1.get(), kSize, false));
 753   entry->Close();
 754   SimulateCrash();
 755
 756   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 757
 758   scoped_refptr<net::IOBuffer> buffer2(new net::IOBuffer(kSize));
 759   memset(buffer2->data(), 0, kSize);
 760   EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer2.get(), kSize));
 761   entry->Close();
 762   EXPECT_STREQ(buffer1->data(), buffer2->data());
 763 }
 764
 765 TEST_F(DiskCacheBackendTest, ValidEntry) {
 766   BackendValidEntry();
 767 }
 768
 769 TEST_F(DiskCacheBackendTest, NewEvictionValidEntry) {
 770   SetNewEviction();
 771   BackendValidEntry();
 772 }
 773
 774 // The same logic of the previous test (ValidEntry), but this time force the
 775 // entry to be invalid, simulating a crash in the middle.
 776 // We'll be leaking memory from this test.
 777 void DiskCacheBackendTest::BackendInvalidEntry() {
 778   InitCache();
 779
 780   std::string key("Some key");
 781   disk_cache::Entry* entry;
 782   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 783
 784   const int kSize = 50;
 785   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
 786   memset(buffer->data(), 0, kSize);
 787   base::strlcpy(buffer->data(), "And the data to save", kSize);
 788   EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
 789   SimulateCrash();
 790
 791   EXPECT_NE(net::OK, OpenEntry(key, &entry));
 792   EXPECT_EQ(0, cache_->GetEntryCount());
 793 }
 794
 795 #if !defined(LEAK_SANITIZER)
 796 // We'll be leaking memory from this test.
 797 TEST_F(DiskCacheBackendTest, InvalidEntry) {
 798   BackendInvalidEntry();
 799 }
 800
 801 // We'll be leaking memory from this test.
 802 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry) {
 803   SetNewEviction();
 804   BackendInvalidEntry();
 805 }
 806
 807 // We'll be leaking memory from this test.
 808 TEST_F(DiskCacheBackendTest, AppCacheInvalidEntry) {
 809   SetCacheType(net::APP_CACHE);
 810   BackendInvalidEntry();
 811 }
 812
 813 // We'll be leaking memory from this test.
 814 TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntry) {
 815   SetCacheType(net::SHADER_CACHE);
 816   BackendInvalidEntry();
 817 }
 818
 819 // Almost the same test, but this time crash the cache after reading an entry.
 820 // We'll be leaking memory from this test.
 821 void DiskCacheBackendTest::BackendInvalidEntryRead() {
 822   InitCache();
 823
 824   std::string key("Some key");
 825   disk_cache::Entry* entry;
 826   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
 827
 828   const int kSize = 50;
 829   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
 830   memset(buffer->data(), 0, kSize);
 831   base::strlcpy(buffer->data(), "And the data to save", kSize);
 832   EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
 833   entry->Close();
 834   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 835   EXPECT_EQ(kSize, ReadData(entry, 0, 0, buffer.get(), kSize));
 836
 837   SimulateCrash();
 838
 839   if (type_ == net::APP_CACHE) {
 840     // Reading an entry and crashing should not make it dirty.
 841     ASSERT_EQ(net::OK, OpenEntry(key, &entry));
 842     EXPECT_EQ(1, cache_->GetEntryCount());
 843     entry->Close();
 844   } else {
 845     EXPECT_NE(net::OK, OpenEntry(key, &entry));
 846     EXPECT_EQ(0, cache_->GetEntryCount());
 847   }
 848 }
 849
 850 // We'll be leaking memory from this test.
 851 TEST_F(DiskCacheBackendTest, InvalidEntryRead) {
 852   BackendInvalidEntryRead();
 853 }
 854
 855 // We'll be leaking memory from this test.
 856 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntryRead) {
 857   SetNewEviction();
 858   BackendInvalidEntryRead();
 859 }
 860
 861 // We'll be leaking memory from this test.
 862 TEST_F(DiskCacheBackendTest, AppCacheInvalidEntryRead) {
 863   SetCacheType(net::APP_CACHE);
 864   BackendInvalidEntryRead();
 865 }
 866
 867 // We'll be leaking memory from this test.
 868 TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntryRead) {
 869   SetCacheType(net::SHADER_CACHE);
 870   BackendInvalidEntryRead();
 871 }
 872
 873 // We'll be leaking memory from this test.
 874 void DiskCacheBackendTest::BackendInvalidEntryWithLoad() {
 875   // Work with a tiny index table (16 entries)
 876   SetMask(0xf);
 877   SetMaxSize(0x100000);
 878   InitCache();
 879
 880   int seed = static_cast<int>(Time::Now().ToInternalValue());
 881   srand(seed);
 882
 883   const int kNumEntries = 100;
 884   disk_cache::Entry* entries[kNumEntries];
 885   for (int i = 0; i < kNumEntries; i++) {
 886     std::string key = GenerateKey(true);
 887     ASSERT_EQ(net::OK, CreateEntry(key, &entries[i]));
 888   }
 889   EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
 890
 891   for (int i = 0; i < kNumEntries; i++) {
 892     int source1 = rand() % kNumEntries;
 893     int source2 = rand() % kNumEntries;
 894     disk_cache::Entry* temp = entries[source1];
 895     entries[source1] = entries[source2];
 896     entries[source2] = temp;
 897   }
 898
 899   std::string keys[kNumEntries];
 900   for (int i = 0; i < kNumEntries; i++) {
 901     keys[i] = entries[i]->GetKey();
 902     if (i < kNumEntries / 2)
 903       entries[i]->Close();
 904   }
 905
 906   SimulateCrash();
 907
 908   for (int i = kNumEntries / 2; i < kNumEntries; i++) {
 909     disk_cache::Entry* entry;
 910     EXPECT_NE(net::OK, OpenEntry(keys[i], &entry));
 911   }
 912
 913   for (int i = 0; i < kNumEntries / 2; i++) {
 914     disk_cache::Entry* entry;
 915     ASSERT_EQ(net::OK, OpenEntry(keys[i], &entry));
 916     entry->Close();
 917   }
 918
 919   EXPECT_EQ(kNumEntries / 2, cache_->GetEntryCount());
 920 }
 921
 922 // We'll be leaking memory from this test.
 923 TEST_F(DiskCacheBackendTest, InvalidEntryWithLoad) {
 924   BackendInvalidEntryWithLoad();
 925 }
 926
 927 // We'll be leaking memory from this test.
 928 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntryWithLoad) {
 929   SetNewEviction();
 930   BackendInvalidEntryWithLoad();
 931 }
 932
 933 // We'll be leaking memory from this test.
 934 TEST_F(DiskCacheBackendTest, AppCacheInvalidEntryWithLoad) {
 935   SetCacheType(net::APP_CACHE);
 936   BackendInvalidEntryWithLoad();
 937 }
 938
 939 // We'll be leaking memory from this test.
 940 TEST_F(DiskCacheBackendTest, ShaderCacheInvalidEntryWithLoad) {
 941   SetCacheType(net::SHADER_CACHE);
 942   BackendInvalidEntryWithLoad();
 943 }
 944
 945 // We'll be leaking memory from this test.
 946 void DiskCacheBackendTest::BackendTrimInvalidEntry() {
 947   const int kSize = 0x3000;  // 12 kB
 948   SetMaxSize(kSize * 10);
 949   InitCache();
 950
 951   std::string first("some key");
 952   std::string second("something else");
 953   disk_cache::Entry* entry;
 954   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
 955
 956   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
 957   memset(buffer->data(), 0, kSize);
 958   EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
 959
 960   // Simulate a crash.
 961   SimulateCrash();
 962
 963   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
 964   EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
 965
 966   EXPECT_EQ(2, cache_->GetEntryCount());
 967   SetMaxSize(kSize);
 968   entry->Close();  // Trim the cache.
 969   FlushQueueForTest();
 970
 971   // If we evicted the entry in less than 20mS, we have one entry in the cache;
 972   // if it took more than that, we posted a task and we'll delete the second
 973   // entry too.
 974   base::MessageLoop::current()->RunUntilIdle();
 975
 976   // This may be not thread-safe in general, but for now it's OK so add some
 977   // ThreadSanitizer annotations to ignore data races on cache_.
 978   // See http://crbug.com/55970
 979   ANNOTATE_IGNORE_READS_BEGIN();
 980   EXPECT_GE(1, cache_->GetEntryCount());
 981   ANNOTATE_IGNORE_READS_END();
 982
 983   EXPECT_NE(net::OK, OpenEntry(first, &entry));
 984 }
 985
 986 // We'll be leaking memory from this test.
 987 TEST_F(DiskCacheBackendTest, TrimInvalidEntry) {
 988   BackendTrimInvalidEntry();
 989 }
 990
 991 // We'll be leaking memory from this test.
 992 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry) {
 993   SetNewEviction();
 994   BackendTrimInvalidEntry();
 995 }
 996
 997 // We'll be leaking memory from this test.
 998 void DiskCacheBackendTest::BackendTrimInvalidEntry2() {
 999   SetMask(0xf);  // 16-entry table.
1000
1001   const int kSize = 0x3000;  // 12 kB
1002   SetMaxSize(kSize * 40);
1003   InitCache();
1004
1005   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
1006   memset(buffer->data(), 0, kSize);
1007   disk_cache::Entry* entry;
1008
1009   // Writing 32 entries to this cache chains most of them.
1010   for (int i = 0; i < 32; i++) {
1011     std::string key(base::StringPrintf("some key %d", i));
1012     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1013     EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
1014     entry->Close();
1015     ASSERT_EQ(net::OK, OpenEntry(key, &entry));
1016     // Note that we are not closing the entries.
1017   }
1018
1019   // Simulate a crash.
1020   SimulateCrash();
1021
1022   ASSERT_EQ(net::OK, CreateEntry("Something else", &entry));
1023   EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, false));
1024
1025   FlushQueueForTest();
1026   EXPECT_EQ(33, cache_->GetEntryCount());
1027   SetMaxSize(kSize);
1028
1029   // For the new eviction code, all corrupt entries are on the second list so
1030   // they are not going away that easy.
1031   if (new_eviction_) {
1032     EXPECT_EQ(net::OK, DoomAllEntries());
1033   }
1034
1035   entry->Close();  // Trim the cache.
1036   FlushQueueForTest();
1037
1038   // We may abort the eviction before cleaning up everything.
1039   base::MessageLoop::current()->RunUntilIdle();
1040   FlushQueueForTest();
1041   // If it's not clear enough: we may still have eviction tasks running at this
1042   // time, so the number of entries is changing while we read it.
1043   ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
1044   EXPECT_GE(30, cache_->GetEntryCount());
1045   ANNOTATE_IGNORE_READS_AND_WRITES_END();
1046 }
1047
1048 // We'll be leaking memory from this test.
1049 TEST_F(DiskCacheBackendTest, TrimInvalidEntry2) {
1050   BackendTrimInvalidEntry2();
1051 }
1052
1053 // We'll be leaking memory from this test.
1054 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry2) {
1055   SetNewEviction();
1056   BackendTrimInvalidEntry2();
1057 }
1058 #endif  // !defined(LEAK_SANITIZER)
1059
1060 void DiskCacheBackendTest::BackendEnumerations() {
1061   InitCache();
1062   Time initial = Time::Now();
1063
1064   const int kNumEntries = 100;
1065   for (int i = 0; i < kNumEntries; i++) {
1066     std::string key = GenerateKey(true);
1067     disk_cache::Entry* entry;
1068     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1069     entry->Close();
1070   }
1071   EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
1072   Time final = Time::Now();
1073
1074   disk_cache::Entry* entry;
1075   void* iter = NULL;
1076   int count = 0;
1077   Time last_modified[kNumEntries];
1078   Time last_used[kNumEntries];
1079   while (OpenNextEntry(&iter, &entry) == net::OK) {
1080     ASSERT_TRUE(NULL != entry);
1081     if (count < kNumEntries) {
1082       last_modified[count] = entry->GetLastModified();
1083       last_used[count] = entry->GetLastUsed();
1084       EXPECT_TRUE(initial <= last_modified[count]);
1085       EXPECT_TRUE(final >= last_modified[count]);
1086     }
1087
1088     entry->Close();
1089     count++;
1090   };
1091   EXPECT_EQ(kNumEntries, count);
1092
1093   iter = NULL;
1094   count = 0;
1095   // The previous enumeration should not have changed the timestamps.
1096   while (OpenNextEntry(&iter, &entry) == net::OK) {
1097     ASSERT_TRUE(NULL != entry);
1098     if (count < kNumEntries) {
1099       EXPECT_TRUE(last_modified[count] == entry->GetLastModified());
1100       EXPECT_TRUE(last_used[count] == entry->GetLastUsed());
1101     }
1102     entry->Close();
1103     count++;
1104   };
1105   EXPECT_EQ(kNumEntries, count);
1106 }
1107
1108 TEST_F(DiskCacheBackendTest, Enumerations) {
1109   BackendEnumerations();
1110 }
1111
1112 TEST_F(DiskCacheBackendTest, NewEvictionEnumerations) {
1113   SetNewEviction();
1114   BackendEnumerations();
1115 }
1116
1117 TEST_F(DiskCacheBackendTest, MemoryOnlyEnumerations) {
1118   SetMemoryOnlyMode();
1119   BackendEnumerations();
1120 }
1121
1122 TEST_F(DiskCacheBackendTest, ShaderCacheEnumerations) {
1123   SetCacheType(net::SHADER_CACHE);
1124   BackendEnumerations();
1125 }
1126
1127 TEST_F(DiskCacheBackendTest, AppCacheEnumerations) {
1128   SetCacheType(net::APP_CACHE);
1129   BackendEnumerations();
1130 }
1131
1132 // Verifies enumerations while entries are open.
1133 void DiskCacheBackendTest::BackendEnumerations2() {
1134   InitCache();
1135   const std::string first("first");
1136   const std::string second("second");
1137   disk_cache::Entry *entry1, *entry2;
1138   ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
1139   entry1->Close();
1140   ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
1141   entry2->Close();
1142   FlushQueueForTest();
1143
1144   // Make sure that the timestamp is not the same.
1145   AddDelay();
1146   ASSERT_EQ(net::OK, OpenEntry(second, &entry1));
1147   void* iter = NULL;
1148   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
1149   EXPECT_EQ(entry2->GetKey(), second);
1150
1151   // Two entries and the iterator pointing at "first".
1152   entry1->Close();
1153   entry2->Close();
1154
1155   // The iterator should still be valid, so we should not crash.
1156   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
1157   EXPECT_EQ(entry2->GetKey(), first);
1158   entry2->Close();
1159   cache_->EndEnumeration(&iter);
1160
1161   // Modify the oldest entry and get the newest element.
1162   ASSERT_EQ(net::OK, OpenEntry(first, &entry1));
1163   EXPECT_EQ(0, WriteData(entry1, 0, 200, NULL, 0, false));
1164   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
1165   if (type_ == net::APP_CACHE) {
1166     // The list is not updated.
1167     EXPECT_EQ(entry2->GetKey(), second);
1168   } else {
1169     EXPECT_EQ(entry2->GetKey(), first);
1170   }
1171
1172   entry1->Close();
1173   entry2->Close();
1174   cache_->EndEnumeration(&iter);
1175 }
1176
1177 TEST_F(DiskCacheBackendTest, Enumerations2) {
1178   BackendEnumerations2();
1179 }
1180
1181 TEST_F(DiskCacheBackendTest, NewEvictionEnumerations2) {
1182   SetNewEviction();
1183   BackendEnumerations2();
1184 }
1185
1186 TEST_F(DiskCacheBackendTest, MemoryOnlyEnumerations2) {
1187   SetMemoryOnlyMode();
1188   BackendEnumerations2();
1189 }
1190
1191 TEST_F(DiskCacheBackendTest, AppCacheEnumerations2) {
1192   SetCacheType(net::APP_CACHE);
1193   BackendEnumerations2();
1194 }
1195
1196 TEST_F(DiskCacheBackendTest, ShaderCacheEnumerations2) {
1197   SetCacheType(net::SHADER_CACHE);
1198   BackendEnumerations2();
1199 }
1200
1201 // Verify that ReadData calls do not update the LRU cache
1202 // when using the SHADER_CACHE type.
1203 TEST_F(DiskCacheBackendTest, ShaderCacheEnumerationReadData) {
1204   SetCacheType(net::SHADER_CACHE);
1205   InitCache();
1206   const std::string first("first");
1207   const std::string second("second");
1208   disk_cache::Entry *entry1, *entry2;
1209   const int kSize = 50;
1210   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
1211
1212   ASSERT_EQ(net::OK, CreateEntry(first, &entry1));
1213   memset(buffer1->data(), 0, kSize);
1214   base::strlcpy(buffer1->data(), "And the data to save", kSize);
1215   EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
1216
1217   ASSERT_EQ(net::OK, CreateEntry(second, &entry2));
1218   entry2->Close();
1219
1220   FlushQueueForTest();
1221
1222   // Make sure that the timestamp is not the same.
1223   AddDelay();
1224
1225   // Read from the last item in the LRU.
1226   EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
1227   entry1->Close();
1228
1229   void* iter = NULL;
1230   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry2));
1231   EXPECT_EQ(entry2->GetKey(), second);
1232   entry2->Close();
1233   cache_->EndEnumeration(&iter);
1234 }
1235
1236 #if !defined(LEAK_SANITIZER)
1237 // Verify handling of invalid entries while doing enumerations.
1238 // We'll be leaking memory from this test.
1239 void DiskCacheBackendTest::BackendInvalidEntryEnumeration() {
1240   InitCache();
1241
1242   std::string key("Some key");
1243   disk_cache::Entry *entry, *entry1, *entry2;
1244   ASSERT_EQ(net::OK, CreateEntry(key, &entry1));
1245
1246   const int kSize = 50;
1247   scoped_refptr<net::IOBuffer> buffer1(new net::IOBuffer(kSize));
1248   memset(buffer1->data(), 0, kSize);
1249   base::strlcpy(buffer1->data(), "And the data to save", kSize);
1250   EXPECT_EQ(kSize, WriteData(entry1, 0, 0, buffer1.get(), kSize, false));
1251   entry1->Close();
1252   ASSERT_EQ(net::OK, OpenEntry(key, &entry1));
1253   EXPECT_EQ(kSize, ReadData(entry1, 0, 0, buffer1.get(), kSize));
1254
1255   std::string key2("Another key");
1256   ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
1257   entry2->Close();
1258   ASSERT_EQ(2, cache_->GetEntryCount());
1259
1260   SimulateCrash();
1261
1262   void* iter = NULL;
1263   int count = 0;
1264   while (OpenNextEntry(&iter, &entry) == net::OK) {
1265     ASSERT_TRUE(NULL != entry);
1266     EXPECT_EQ(key2, entry->GetKey());
1267     entry->Close();
1268     count++;
1269   };
1270   EXPECT_EQ(1, count);
1271   EXPECT_EQ(1, cache_->GetEntryCount());
1272 }
1273
1274 // We'll be leaking memory from this test.
1275 TEST_F(DiskCacheBackendTest, InvalidEntryEnumeration) {
1276   BackendInvalidEntryEnumeration();
1277 }
1278
1279 // We'll be leaking memory from this test.
1280 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntryEnumeration) {
1281   SetNewEviction();
1282   BackendInvalidEntryEnumeration();
1283 }
1284 #endif  // !defined(LEAK_SANITIZER)
1285
1286 // Tests that if for some reason entries are modified close to existing cache
1287 // iterators, we don't generate fatal errors or reset the cache.
1288 void DiskCacheBackendTest::BackendFixEnumerators() {
1289   InitCache();
1290
1291   int seed = static_cast<int>(Time::Now().ToInternalValue());
1292   srand(seed);
1293
1294   const int kNumEntries = 10;
1295   for (int i = 0; i < kNumEntries; i++) {
1296     std::string key = GenerateKey(true);
1297     disk_cache::Entry* entry;
1298     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
1299     entry->Close();
1300   }
1301   EXPECT_EQ(kNumEntries, cache_->GetEntryCount());
1302
1303   disk_cache::Entry *entry1, *entry2;
1304   void* iter1 = NULL;
1305   void* iter2 = NULL;
1306   ASSERT_EQ(net::OK, OpenNextEntry(&iter1, &entry1));
1307   ASSERT_TRUE(NULL != entry1);
1308   entry1->Close();
1309   entry1 = NULL;
1310
1311   // Let's go to the middle of the list.
1312   for (int i = 0; i < kNumEntries / 2; i++) {
1313     if (entry1)
1314       entry1->Close();
1315     ASSERT_EQ(net::OK, OpenNextEntry(&iter1, &entry1));
1316     ASSERT_TRUE(NULL != entry1);
1317
1318     ASSERT_EQ(net::OK, OpenNextEntry(&iter2, &entry2));
1319     ASSERT_TRUE(NULL != entry2);
1320     entry2->Close();
1321   }
1322
1323   // Messing up with entry1 will modify entry2->next.
1324   entry1->Doom();
1325   ASSERT_EQ(net::OK, OpenNextEntry(&iter2, &entry2));
1326   ASSERT_TRUE(NULL != entry2);
1327
1328   // The link entry2->entry1 should be broken.
1329   EXPECT_NE(entry2->GetKey(), entry1->GetKey());
1330   entry1->Close();
1331   entry2->Close();
1332
1333   // And the second iterator should keep working.
1334   ASSERT_EQ(net::OK, OpenNextEntry(&iter2, &entry2));
1335   ASSERT_TRUE(NULL != entry2);
1336   entry2->Close();
1337
1338   cache_->EndEnumeration(&iter1);
1339   cache_->EndEnumeration(&iter2);
1340 }
1341
1342 TEST_F(DiskCacheBackendTest, FixEnumerators) {
1343   BackendFixEnumerators();
1344 }
1345
1346 TEST_F(DiskCacheBackendTest, NewEvictionFixEnumerators) {
1347   SetNewEviction();
1348   BackendFixEnumerators();
1349 }
1350
1351 void DiskCacheBackendTest::BackendDoomRecent() {
1352   InitCache();
1353
1354   disk_cache::Entry *entry;
1355   ASSERT_EQ(net::OK, CreateEntry("first", &entry));
1356   entry->Close();
1357   ASSERT_EQ(net::OK, CreateEntry("second", &entry));
1358   entry->Close();
1359   FlushQueueForTest();
1360
1361   AddDelay();
1362   Time middle = Time::Now();
1363
1364   ASSERT_EQ(net::OK, CreateEntry("third", &entry));
1365   entry->Close();
1366   ASSERT_EQ(net::OK, CreateEntry("fourth", &entry));
1367   entry->Close();
1368   FlushQueueForTest();
1369
1370   AddDelay();
1371   Time final = Time::Now();
1372
1373   ASSERT_EQ(4, cache_->GetEntryCount());
1374   EXPECT_EQ(net::OK, DoomEntriesSince(final));
1375   ASSERT_EQ(4, cache_->GetEntryCount());
1376
1377   EXPECT_EQ(net::OK, DoomEntriesSince(middle));
1378   ASSERT_EQ(2, cache_->GetEntryCount());
1379
1380   ASSERT_EQ(net::OK, OpenEntry("second", &entry));
1381   entry->Close();
1382 }
1383
1384 TEST_F(DiskCacheBackendTest, DoomRecent) {
1385   BackendDoomRecent();
1386 }
1387
1388 TEST_F(DiskCacheBackendTest, NewEvictionDoomRecent) {
1389   SetNewEviction();
1390   BackendDoomRecent();
1391 }
1392
1393 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomRecent) {
1394   SetMemoryOnlyMode();
1395   BackendDoomRecent();
1396 }
1397
1398 void DiskCacheBackendTest::InitSparseCache(base::Time* doomed_start,
1399                                            base::Time* doomed_end) {
1400   InitCache();
1401
1402   const int kSize = 50;
1403   // This must be greater then MemEntryImpl::kMaxSparseEntrySize.
1404   const int kOffset = 10 + 1024 * 1024;
1405
1406   disk_cache::Entry* entry0 = NULL;
1407   disk_cache::Entry* entry1 = NULL;
1408   disk_cache::Entry* entry2 = NULL;
1409
1410   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
1411   CacheTestFillBuffer(buffer->data(), kSize, false);
1412
1413   ASSERT_EQ(net::OK, CreateEntry("zeroth", &entry0));
1414   ASSERT_EQ(kSize, WriteSparseData(entry0, 0, buffer.get(), kSize));
1415   ASSERT_EQ(kSize,
1416             WriteSparseData(entry0, kOffset + kSize, buffer.get(), kSize));
1417   entry0->Close();
1418
1419   FlushQueueForTest();
1420   AddDelay();
1421   if (doomed_start)
1422     *doomed_start = base::Time::Now();
1423
1424   // Order in rankings list:
1425   // first_part1, first_part2, second_part1, second_part2
1426   ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
1427   ASSERT_EQ(kSize, WriteSparseData(entry1, 0, buffer.get(), kSize));
1428   ASSERT_EQ(kSize,
1429             WriteSparseData(entry1, kOffset + kSize, buffer.get(), kSize));
1430   entry1->Close();
1431
1432   ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
1433   ASSERT_EQ(kSize, WriteSparseData(entry2, 0, buffer.get(), kSize));
1434   ASSERT_EQ(kSize,
1435             WriteSparseData(entry2, kOffset + kSize, buffer.get(), kSize));
1436   entry2->Close();
1437
1438   FlushQueueForTest();
1439   AddDelay();
1440   if (doomed_end)
1441     *doomed_end = base::Time::Now();
1442
1443   // Order in rankings list:
1444   // third_part1, fourth_part1, third_part2, fourth_part2
1445   disk_cache::Entry* entry3 = NULL;
1446   disk_cache::Entry* entry4 = NULL;
1447   ASSERT_EQ(net::OK, CreateEntry("third", &entry3));
1448   ASSERT_EQ(kSize, WriteSparseData(entry3, 0, buffer.get(), kSize));
1449   ASSERT_EQ(net::OK, CreateEntry("fourth", &entry4));
1450   ASSERT_EQ(kSize, WriteSparseData(entry4, 0, buffer.get(), kSize));
1451   ASSERT_EQ(kSize,
1452             WriteSparseData(entry3, kOffset + kSize, buffer.get(), kSize));
1453   ASSERT_EQ(kSize,
1454             WriteSparseData(entry4, kOffset + kSize, buffer.get(), kSize));
1455   entry3->Close();
1456   entry4->Close();
1457
1458   FlushQueueForTest();
1459   AddDelay();
1460 }
1461
1462 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomEntriesSinceSparse) {
1463   SetMemoryOnlyMode();
1464   base::Time start;
1465   InitSparseCache(&start, NULL);
1466   DoomEntriesSince(start);
1467   EXPECT_EQ(1, cache_->GetEntryCount());
1468 }
1469
1470 TEST_F(DiskCacheBackendTest, DoomEntriesSinceSparse) {
1471   base::Time start;
1472   InitSparseCache(&start, NULL);
1473   DoomEntriesSince(start);
1474   // NOTE: BackendImpl counts child entries in its GetEntryCount(), while
1475   // MemBackendImpl does not. Thats why expected value differs here from
1476   // MemoryOnlyDoomEntriesSinceSparse.
1477   EXPECT_EQ(3, cache_->GetEntryCount());
1478 }
1479
1480 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAllSparse) {
1481   SetMemoryOnlyMode();
1482   InitSparseCache(NULL, NULL);
1483   EXPECT_EQ(net::OK, DoomAllEntries());
1484   EXPECT_EQ(0, cache_->GetEntryCount());
1485 }
1486
1487 TEST_F(DiskCacheBackendTest, DoomAllSparse) {
1488   InitSparseCache(NULL, NULL);
1489   EXPECT_EQ(net::OK, DoomAllEntries());
1490   EXPECT_EQ(0, cache_->GetEntryCount());
1491 }
1492
1493 void DiskCacheBackendTest::BackendDoomBetween() {
1494   InitCache();
1495
1496   disk_cache::Entry *entry;
1497   ASSERT_EQ(net::OK, CreateEntry("first", &entry));
1498   entry->Close();
1499   FlushQueueForTest();
1500
1501   AddDelay();
1502   Time middle_start = Time::Now();
1503
1504   ASSERT_EQ(net::OK, CreateEntry("second", &entry));
1505   entry->Close();
1506   ASSERT_EQ(net::OK, CreateEntry("third", &entry));
1507   entry->Close();
1508   FlushQueueForTest();
1509
1510   AddDelay();
1511   Time middle_end = Time::Now();
1512
1513   ASSERT_EQ(net::OK, CreateEntry("fourth", &entry));
1514   entry->Close();
1515   ASSERT_EQ(net::OK, OpenEntry("fourth", &entry));
1516   entry->Close();
1517   FlushQueueForTest();
1518
1519   AddDelay();
1520   Time final = Time::Now();
1521
1522   ASSERT_EQ(4, cache_->GetEntryCount());
1523   EXPECT_EQ(net::OK, DoomEntriesBetween(middle_start, middle_end));
1524   ASSERT_EQ(2, cache_->GetEntryCount());
1525
1526   ASSERT_EQ(net::OK, OpenEntry("fourth", &entry));
1527   entry->Close();
1528
1529   EXPECT_EQ(net::OK, DoomEntriesBetween(middle_start, final));
1530   ASSERT_EQ(1, cache_->GetEntryCount());
1531
1532   ASSERT_EQ(net::OK, OpenEntry("first", &entry));
1533   entry->Close();
1534 }
1535
1536 TEST_F(DiskCacheBackendTest, DoomBetween) {
1537   BackendDoomBetween();
1538 }
1539
1540 TEST_F(DiskCacheBackendTest, NewEvictionDoomBetween) {
1541   SetNewEviction();
1542   BackendDoomBetween();
1543 }
1544
1545 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomBetween) {
1546   SetMemoryOnlyMode();
1547   BackendDoomBetween();
1548 }
1549
1550 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomEntriesBetweenSparse) {
1551   SetMemoryOnlyMode();
1552   base::Time start, end;
1553   InitSparseCache(&start, &end);
1554   DoomEntriesBetween(start, end);
1555   EXPECT_EQ(3, cache_->GetEntryCount());
1556
1557   start = end;
1558   end = base::Time::Now();
1559   DoomEntriesBetween(start, end);
1560   EXPECT_EQ(1, cache_->GetEntryCount());
1561 }
1562
1563 TEST_F(DiskCacheBackendTest, DoomEntriesBetweenSparse) {
1564   base::Time start, end;
1565   InitSparseCache(&start, &end);
1566   DoomEntriesBetween(start, end);
1567   EXPECT_EQ(9, cache_->GetEntryCount());
1568
1569   start = end;
1570   end = base::Time::Now();
1571   DoomEntriesBetween(start, end);
1572   EXPECT_EQ(3, cache_->GetEntryCount());
1573 }
1574
1575 void DiskCacheBackendTest::BackendTransaction(const std::string& name,
1576                                               int num_entries, bool load) {
1577   success_ = false;
1578   ASSERT_TRUE(CopyTestCache(name));
1579   DisableFirstCleanup();
1580
1581   uint32 mask;
1582   if (load) {
1583     mask = 0xf;
1584     SetMaxSize(0x100000);
1585   } else {
1586     // Clear the settings from the previous run.
1587     mask = 0;
1588     SetMaxSize(0);
1589   }
1590   SetMask(mask);
1591
1592   InitCache();
1593   ASSERT_EQ(num_entries + 1, cache_->GetEntryCount());
1594
1595   std::string key("the first key");
1596   disk_cache::Entry* entry1;
1597   ASSERT_NE(net::OK, OpenEntry(key, &entry1));
1598
1599   int actual = cache_->GetEntryCount();
1600   if (num_entries != actual) {
1601     ASSERT_TRUE(load);
1602     // If there is a heavy load, inserting an entry will make another entry
1603     // dirty (on the hash bucket) so two entries are removed.
1604     ASSERT_EQ(num_entries - 1, actual);
1605   }
1606
1607   cache_.reset();
1608   cache_impl_ = NULL;
1609
1610   ASSERT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask));
1611   success_ = true;
1612 }
1613
1614 void DiskCacheBackendTest::BackendRecoverInsert() {
1615   // Tests with an empty cache.
1616   BackendTransaction("insert_empty1", 0, false);
1617   ASSERT_TRUE(success_) << "insert_empty1";
1618   BackendTransaction("insert_empty2", 0, false);
1619   ASSERT_TRUE(success_) << "insert_empty2";
1620   BackendTransaction("insert_empty3", 0, false);
1621   ASSERT_TRUE(success_) << "insert_empty3";
1622
1623   // Tests with one entry on the cache.
1624   BackendTransaction("insert_one1", 1, false);
1625   ASSERT_TRUE(success_) << "insert_one1";
1626   BackendTransaction("insert_one2", 1, false);
1627   ASSERT_TRUE(success_) << "insert_one2";
1628   BackendTransaction("insert_one3", 1, false);
1629   ASSERT_TRUE(success_) << "insert_one3";
1630
1631   // Tests with one hundred entries on the cache, tiny index.
1632   BackendTransaction("insert_load1", 100, true);
1633   ASSERT_TRUE(success_) << "insert_load1";
1634   BackendTransaction("insert_load2", 100, true);
1635   ASSERT_TRUE(success_) << "insert_load2";
1636 }
1637
1638 TEST_F(DiskCacheBackendTest, RecoverInsert) {
1639   BackendRecoverInsert();
1640 }
1641
1642 TEST_F(DiskCacheBackendTest, NewEvictionRecoverInsert) {
1643   SetNewEviction();
1644   BackendRecoverInsert();
1645 }
1646
1647 void DiskCacheBackendTest::BackendRecoverRemove() {
1648   // Removing the only element.
1649   BackendTransaction("remove_one1", 0, false);
1650   ASSERT_TRUE(success_) << "remove_one1";
1651   BackendTransaction("remove_one2", 0, false);
1652   ASSERT_TRUE(success_) << "remove_one2";
1653   BackendTransaction("remove_one3", 0, false);
1654   ASSERT_TRUE(success_) << "remove_one3";
1655
1656   // Removing the head.
1657   BackendTransaction("remove_head1", 1, false);
1658   ASSERT_TRUE(success_) << "remove_head1";
1659   BackendTransaction("remove_head2", 1, false);
1660   ASSERT_TRUE(success_) << "remove_head2";
1661   BackendTransaction("remove_head3", 1, false);
1662   ASSERT_TRUE(success_) << "remove_head3";
1663
1664   // Removing the tail.
1665   BackendTransaction("remove_tail1", 1, false);
1666   ASSERT_TRUE(success_) << "remove_tail1";
1667   BackendTransaction("remove_tail2", 1, false);
1668   ASSERT_TRUE(success_) << "remove_tail2";
1669   BackendTransaction("remove_tail3", 1, false);
1670   ASSERT_TRUE(success_) << "remove_tail3";
1671
1672   // Removing with one hundred entries on the cache, tiny index.
1673   BackendTransaction("remove_load1", 100, true);
1674   ASSERT_TRUE(success_) << "remove_load1";
1675   BackendTransaction("remove_load2", 100, true);
1676   ASSERT_TRUE(success_) << "remove_load2";
1677   BackendTransaction("remove_load3", 100, true);
1678   ASSERT_TRUE(success_) << "remove_load3";
1679
1680   // This case cannot be reverted.
1681   BackendTransaction("remove_one4", 0, false);
1682   ASSERT_TRUE(success_) << "remove_one4";
1683   BackendTransaction("remove_head4", 1, false);
1684   ASSERT_TRUE(success_) << "remove_head4";
1685 }
1686
1687 TEST_F(DiskCacheBackendTest, RecoverRemove) {
1688   BackendRecoverRemove();
1689 }
1690
1691 TEST_F(DiskCacheBackendTest, NewEvictionRecoverRemove) {
1692   SetNewEviction();
1693   BackendRecoverRemove();
1694 }
1695
1696 void DiskCacheBackendTest::BackendRecoverWithEviction() {
1697   success_ = false;
1698   ASSERT_TRUE(CopyTestCache("insert_load1"));
1699   DisableFirstCleanup();
1700
1701   SetMask(0xf);
1702   SetMaxSize(0x1000);
1703
1704   // We should not crash here.
1705   InitCache();
1706   DisableIntegrityCheck();
1707 }
1708
1709 TEST_F(DiskCacheBackendTest, RecoverWithEviction) {
1710   BackendRecoverWithEviction();
1711 }
1712
1713 TEST_F(DiskCacheBackendTest, NewEvictionRecoverWithEviction) {
1714   SetNewEviction();
1715   BackendRecoverWithEviction();
1716 }
1717
1718 // Tests that the |BackendImpl| fails to start with the wrong cache version.
1719 TEST_F(DiskCacheTest, WrongVersion) {
1720   ASSERT_TRUE(CopyTestCache("wrong_version"));
1721   base::Thread cache_thread("CacheThread");
1722   ASSERT_TRUE(cache_thread.StartWithOptions(
1723       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
1724   net::TestCompletionCallback cb;
1725
1726   scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
1727       cache_path_, cache_thread.message_loop_proxy().get(), NULL));
1728   int rv = cache->Init(cb.callback());
1729   ASSERT_EQ(net::ERR_FAILED, cb.GetResult(rv));
1730 }
1731
1732 class BadEntropyProvider : public base::FieldTrial::EntropyProvider {
1733  public:
1734   virtual ~BadEntropyProvider() {}
1735
1736   virtual double GetEntropyForTrial(const std::string& trial_name,
1737                                     uint32 randomization_seed) const OVERRIDE {
1738     return 0.5;
1739   }
1740 };
1741
1742 // Tests that the disk cache successfully joins the control group, dropping the
1743 // existing cache in favour of a new empty cache.
1744 TEST_F(DiskCacheTest, SimpleCacheControlJoin) {
1745   base::Thread cache_thread("CacheThread");
1746   ASSERT_TRUE(cache_thread.StartWithOptions(
1747                   base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
1748
1749   scoped_ptr<disk_cache::BackendImpl> cache =
1750       CreateExistingEntryCache(cache_thread, cache_path_);
1751   ASSERT_TRUE(cache.get());
1752   cache.reset();
1753
1754   // Instantiate the SimpleCacheTrial, forcing this run into the
1755   // ExperimentControl group.
1756   base::FieldTrialList field_trial_list(new BadEntropyProvider());
1757   base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
1758                                          "ExperimentControl");
1759   net::TestCompletionCallback cb;
1760   scoped_ptr<disk_cache::Backend> base_cache;
1761   int rv =
1762       disk_cache::CreateCacheBackend(net::DISK_CACHE,
1763                                      net::CACHE_BACKEND_BLOCKFILE,
1764                                      cache_path_,
1765                                      0,
1766                                      true,
1767                                      cache_thread.message_loop_proxy().get(),
1768                                      NULL,
1769                                      &base_cache,
1770                                      cb.callback());
1771   ASSERT_EQ(net::OK, cb.GetResult(rv));
1772   EXPECT_EQ(0, base_cache->GetEntryCount());
1773 }
1774
1775 // Tests that the disk cache can restart in the control group preserving
1776 // existing entries.
1777 TEST_F(DiskCacheTest, SimpleCacheControlRestart) {
1778   // Instantiate the SimpleCacheTrial, forcing this run into the
1779   // ExperimentControl group.
1780   base::FieldTrialList field_trial_list(new BadEntropyProvider());
1781   base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
1782                                          "ExperimentControl");
1783
1784   base::Thread cache_thread("CacheThread");
1785   ASSERT_TRUE(cache_thread.StartWithOptions(
1786                   base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
1787
1788   scoped_ptr<disk_cache::BackendImpl> cache =
1789       CreateExistingEntryCache(cache_thread, cache_path_);
1790   ASSERT_TRUE(cache.get());
1791
1792   net::TestCompletionCallback cb;
1793
1794   const int kRestartCount = 5;
1795   for (int i=0; i < kRestartCount; ++i) {
1796     cache.reset(new disk_cache::BackendImpl(
1797         cache_path_, cache_thread.message_loop_proxy(), NULL));
1798     int rv = cache->Init(cb.callback());
1799     ASSERT_EQ(net::OK, cb.GetResult(rv));
1800     EXPECT_EQ(1, cache->GetEntryCount());
1801
1802     disk_cache::Entry* entry = NULL;
1803     rv = cache->OpenEntry(kExistingEntryKey, &entry, cb.callback());
1804     EXPECT_EQ(net::OK, cb.GetResult(rv));
1805     EXPECT_TRUE(entry);
1806     entry->Close();
1807   }
1808 }
1809
1810 // Tests that the disk cache can leave the control group preserving existing
1811 // entries.
1812 TEST_F(DiskCacheTest, SimpleCacheControlLeave) {
1813   base::Thread cache_thread("CacheThread");
1814   ASSERT_TRUE(cache_thread.StartWithOptions(
1815       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
1816
1817   {
1818     // Instantiate the SimpleCacheTrial, forcing this run into the
1819     // ExperimentControl group.
1820     base::FieldTrialList field_trial_list(new BadEntropyProvider());
1821     base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial",
1822                                            "ExperimentControl");
1823
1824     scoped_ptr<disk_cache::BackendImpl> cache =
1825         CreateExistingEntryCache(cache_thread, cache_path_);
1826     ASSERT_TRUE(cache.get());
1827   }
1828
1829   // Instantiate the SimpleCacheTrial, forcing this run into the
1830   // ExperimentNo group.
1831   base::FieldTrialList field_trial_list(new BadEntropyProvider());
1832   base::FieldTrialList::CreateFieldTrial("SimpleCacheTrial", "ExperimentNo");
1833   net::TestCompletionCallback cb;
1834
1835   const int kRestartCount = 5;
1836   for (int i = 0; i < kRestartCount; ++i) {
1837     scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl(
1838         cache_path_, cache_thread.message_loop_proxy(), NULL));
1839     int rv = cache->Init(cb.callback());
1840     ASSERT_EQ(net::OK, cb.GetResult(rv));
1841     EXPECT_EQ(1, cache->GetEntryCount());
1842
1843     disk_cache::Entry* entry = NULL;
1844     rv = cache->OpenEntry(kExistingEntryKey, &entry, cb.callback());
1845     EXPECT_EQ(net::OK, cb.GetResult(rv));
1846     EXPECT_TRUE(entry);
1847     entry->Close();
1848   }
1849 }
1850
1851 // Tests that the cache is properly restarted on recovery error.
1852 TEST_F(DiskCacheBackendTest, DeleteOld) {
1853   ASSERT_TRUE(CopyTestCache("wrong_version"));
1854   SetNewEviction();
1855   base::Thread cache_thread("CacheThread");
1856   ASSERT_TRUE(cache_thread.StartWithOptions(
1857       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
1858
1859   net::TestCompletionCallback cb;
1860   bool prev = base::ThreadRestrictions::SetIOAllowed(false);
1861   base::FilePath path(cache_path_);
1862   int rv =
1863       disk_cache::CreateCacheBackend(net::DISK_CACHE,
1864                                      net::CACHE_BACKEND_BLOCKFILE,
1865                                      path,
1866                                      0,
1867                                      true,
1868                                      cache_thread.message_loop_proxy().get(),
1869                                      NULL,
1870                                      &cache_,
1871                                      cb.callback());
1872   path.clear();  // Make sure path was captured by the previous call.
1873   ASSERT_EQ(net::OK, cb.GetResult(rv));
1874   base::ThreadRestrictions::SetIOAllowed(prev);
1875   cache_.reset();
1876   EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask_));
1877 }
1878
1879 // We want to be able to deal with messed up entries on disk.
1880 void DiskCacheBackendTest::BackendInvalidEntry2() {
1881   ASSERT_TRUE(CopyTestCache("bad_entry"));
1882   DisableFirstCleanup();
1883   InitCache();
1884
1885   disk_cache::Entry *entry1, *entry2;
1886   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry1));
1887   EXPECT_NE(net::OK, OpenEntry("some other key", &entry2));
1888   entry1->Close();
1889
1890   // CheckCacheIntegrity will fail at this point.
1891   DisableIntegrityCheck();
1892 }
1893
1894 TEST_F(DiskCacheBackendTest, InvalidEntry2) {
1895   BackendInvalidEntry2();
1896 }
1897
1898 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry2) {
1899   SetNewEviction();
1900   BackendInvalidEntry2();
1901 }
1902
1903 // Tests that we don't crash or hang when enumerating this cache.
1904 void DiskCacheBackendTest::BackendInvalidEntry3() {
1905   SetMask(0x1);  // 2-entry table.
1906   SetMaxSize(0x3000);  // 12 kB.
1907   DisableFirstCleanup();
1908   InitCache();
1909
1910   disk_cache::Entry* entry;
1911   void* iter = NULL;
1912   while (OpenNextEntry(&iter, &entry) == net::OK) {
1913     entry->Close();
1914   }
1915 }
1916
1917 TEST_F(DiskCacheBackendTest, InvalidEntry3) {
1918   ASSERT_TRUE(CopyTestCache("dirty_entry3"));
1919   BackendInvalidEntry3();
1920 }
1921
1922 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry3) {
1923   ASSERT_TRUE(CopyTestCache("dirty_entry4"));
1924   SetNewEviction();
1925   BackendInvalidEntry3();
1926   DisableIntegrityCheck();
1927 }
1928
1929 // Test that we handle a dirty entry on the LRU list, already replaced with
1930 // the same key, and with hash collisions.
1931 TEST_F(DiskCacheBackendTest, InvalidEntry4) {
1932   ASSERT_TRUE(CopyTestCache("dirty_entry3"));
1933   SetMask(0x1);  // 2-entry table.
1934   SetMaxSize(0x3000);  // 12 kB.
1935   DisableFirstCleanup();
1936   InitCache();
1937
1938   TrimForTest(false);
1939 }
1940
1941 // Test that we handle a dirty entry on the deleted list, already replaced with
1942 // the same key, and with hash collisions.
1943 TEST_F(DiskCacheBackendTest, InvalidEntry5) {
1944   ASSERT_TRUE(CopyTestCache("dirty_entry4"));
1945   SetNewEviction();
1946   SetMask(0x1);  // 2-entry table.
1947   SetMaxSize(0x3000);  // 12 kB.
1948   DisableFirstCleanup();
1949   InitCache();
1950
1951   TrimDeletedListForTest(false);
1952 }
1953
1954 TEST_F(DiskCacheBackendTest, InvalidEntry6) {
1955   ASSERT_TRUE(CopyTestCache("dirty_entry5"));
1956   SetMask(0x1);  // 2-entry table.
1957   SetMaxSize(0x3000);  // 12 kB.
1958   DisableFirstCleanup();
1959   InitCache();
1960
1961   // There is a dirty entry (but marked as clean) at the end, pointing to a
1962   // deleted entry through the hash collision list. We should not re-insert the
1963   // deleted entry into the index table.
1964
1965   TrimForTest(false);
1966   // The cache should be clean (as detected by CheckCacheIntegrity).
1967 }
1968
1969 // Tests that we don't hang when there is a loop on the hash collision list.
1970 // The test cache could be a result of bug 69135.
1971 TEST_F(DiskCacheBackendTest, BadNextEntry1) {
1972   ASSERT_TRUE(CopyTestCache("list_loop2"));
1973   SetMask(0x1);  // 2-entry table.
1974   SetMaxSize(0x3000);  // 12 kB.
1975   DisableFirstCleanup();
1976   InitCache();
1977
1978   // The second entry points at itselft, and the first entry is not accessible
1979   // though the index, but it is at the head of the LRU.
1980
1981   disk_cache::Entry* entry;
1982   ASSERT_EQ(net::OK, CreateEntry("The first key", &entry));
1983   entry->Close();
1984
1985   TrimForTest(false);
1986   TrimForTest(false);
1987   ASSERT_EQ(net::OK, OpenEntry("The first key", &entry));
1988   entry->Close();
1989   EXPECT_EQ(1, cache_->GetEntryCount());
1990 }
1991
1992 // Tests that we don't hang when there is a loop on the hash collision list.
1993 // The test cache could be a result of bug 69135.
1994 TEST_F(DiskCacheBackendTest, BadNextEntry2) {
1995   ASSERT_TRUE(CopyTestCache("list_loop3"));
1996   SetMask(0x1);  // 2-entry table.
1997   SetMaxSize(0x3000);  // 12 kB.
1998   DisableFirstCleanup();
1999   InitCache();
2000
2001   // There is a wide loop of 5 entries.
2002
2003   disk_cache::Entry* entry;
2004   ASSERT_NE(net::OK, OpenEntry("Not present key", &entry));
2005 }
2006
2007 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry6) {
2008   ASSERT_TRUE(CopyTestCache("bad_rankings3"));
2009   DisableFirstCleanup();
2010   SetNewEviction();
2011   InitCache();
2012
2013   // The second entry is dirty, but removing it should not corrupt the list.
2014   disk_cache::Entry* entry;
2015   ASSERT_NE(net::OK, OpenEntry("the second key", &entry));
2016   ASSERT_EQ(net::OK, OpenEntry("the first key", &entry));
2017
2018   // This should not delete the cache.
2019   entry->Doom();
2020   FlushQueueForTest();
2021   entry->Close();
2022
2023   ASSERT_EQ(net::OK, OpenEntry("some other key", &entry));
2024   entry->Close();
2025 }
2026
2027 // Tests handling of corrupt entries by keeping the rankings node around, with
2028 // a fatal failure.
2029 void DiskCacheBackendTest::BackendInvalidEntry7() {
2030   const int kSize = 0x3000;  // 12 kB.
2031   SetMaxSize(kSize * 10);
2032   InitCache();
2033
2034   std::string first("some key");
2035   std::string second("something else");
2036   disk_cache::Entry* entry;
2037   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2038   entry->Close();
2039   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2040
2041   // Corrupt this entry.
2042   disk_cache::EntryImpl* entry_impl =
2043       static_cast<disk_cache::EntryImpl*>(entry);
2044
2045   entry_impl->rankings()->Data()->next = 0;
2046   entry_impl->rankings()->Store();
2047   entry->Close();
2048   FlushQueueForTest();
2049   EXPECT_EQ(2, cache_->GetEntryCount());
2050
2051   // This should detect the bad entry.
2052   EXPECT_NE(net::OK, OpenEntry(second, &entry));
2053   EXPECT_EQ(1, cache_->GetEntryCount());
2054
2055   // We should delete the cache. The list still has a corrupt node.
2056   void* iter = NULL;
2057   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
2058   FlushQueueForTest();
2059   EXPECT_EQ(0, cache_->GetEntryCount());
2060 }
2061
2062 TEST_F(DiskCacheBackendTest, InvalidEntry7) {
2063   BackendInvalidEntry7();
2064 }
2065
2066 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry7) {
2067   SetNewEviction();
2068   BackendInvalidEntry7();
2069 }
2070
2071 // Tests handling of corrupt entries by keeping the rankings node around, with
2072 // a non fatal failure.
2073 void DiskCacheBackendTest::BackendInvalidEntry8() {
2074   const int kSize = 0x3000;  // 12 kB
2075   SetMaxSize(kSize * 10);
2076   InitCache();
2077
2078   std::string first("some key");
2079   std::string second("something else");
2080   disk_cache::Entry* entry;
2081   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2082   entry->Close();
2083   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2084
2085   // Corrupt this entry.
2086   disk_cache::EntryImpl* entry_impl =
2087       static_cast<disk_cache::EntryImpl*>(entry);
2088
2089   entry_impl->rankings()->Data()->contents = 0;
2090   entry_impl->rankings()->Store();
2091   entry->Close();
2092   FlushQueueForTest();
2093   EXPECT_EQ(2, cache_->GetEntryCount());
2094
2095   // This should detect the bad entry.
2096   EXPECT_NE(net::OK, OpenEntry(second, &entry));
2097   EXPECT_EQ(1, cache_->GetEntryCount());
2098
2099   // We should not delete the cache.
2100   void* iter = NULL;
2101   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
2102   entry->Close();
2103   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
2104   EXPECT_EQ(1, cache_->GetEntryCount());
2105 }
2106
2107 TEST_F(DiskCacheBackendTest, InvalidEntry8) {
2108   BackendInvalidEntry8();
2109 }
2110
2111 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry8) {
2112   SetNewEviction();
2113   BackendInvalidEntry8();
2114 }
2115
2116 // Tests handling of corrupt entries detected by enumerations. Note that these
2117 // tests (xx9 to xx11) are basically just going though slightly different
2118 // codepaths so they are tighlty coupled with the code, but that is better than
2119 // not testing error handling code.
2120 void DiskCacheBackendTest::BackendInvalidEntry9(bool eviction) {
2121   const int kSize = 0x3000;  // 12 kB.
2122   SetMaxSize(kSize * 10);
2123   InitCache();
2124
2125   std::string first("some key");
2126   std::string second("something else");
2127   disk_cache::Entry* entry;
2128   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2129   entry->Close();
2130   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2131
2132   // Corrupt this entry.
2133   disk_cache::EntryImpl* entry_impl =
2134       static_cast<disk_cache::EntryImpl*>(entry);
2135
2136   entry_impl->entry()->Data()->state = 0xbad;
2137   entry_impl->entry()->Store();
2138   entry->Close();
2139   FlushQueueForTest();
2140   EXPECT_EQ(2, cache_->GetEntryCount());
2141
2142   if (eviction) {
2143     TrimForTest(false);
2144     EXPECT_EQ(1, cache_->GetEntryCount());
2145     TrimForTest(false);
2146     EXPECT_EQ(1, cache_->GetEntryCount());
2147   } else {
2148     // We should detect the problem through the list, but we should not delete
2149     // the entry, just fail the iteration.
2150     void* iter = NULL;
2151     EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
2152
2153     // Now a full iteration will work, and return one entry.
2154     ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
2155     entry->Close();
2156     EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
2157
2158     // This should detect what's left of the bad entry.
2159     EXPECT_NE(net::OK, OpenEntry(second, &entry));
2160     EXPECT_EQ(2, cache_->GetEntryCount());
2161   }
2162   DisableIntegrityCheck();
2163 }
2164
2165 TEST_F(DiskCacheBackendTest, InvalidEntry9) {
2166   BackendInvalidEntry9(false);
2167 }
2168
2169 TEST_F(DiskCacheBackendTest, NewEvictionInvalidEntry9) {
2170   SetNewEviction();
2171   BackendInvalidEntry9(false);
2172 }
2173
2174 TEST_F(DiskCacheBackendTest, TrimInvalidEntry9) {
2175   BackendInvalidEntry9(true);
2176 }
2177
2178 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry9) {
2179   SetNewEviction();
2180   BackendInvalidEntry9(true);
2181 }
2182
2183 // Tests handling of corrupt entries detected by enumerations.
2184 void DiskCacheBackendTest::BackendInvalidEntry10(bool eviction) {
2185   const int kSize = 0x3000;  // 12 kB.
2186   SetMaxSize(kSize * 10);
2187   SetNewEviction();
2188   InitCache();
2189
2190   std::string first("some key");
2191   std::string second("something else");
2192   disk_cache::Entry* entry;
2193   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2194   entry->Close();
2195   ASSERT_EQ(net::OK, OpenEntry(first, &entry));
2196   EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
2197   entry->Close();
2198   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2199
2200   // Corrupt this entry.
2201   disk_cache::EntryImpl* entry_impl =
2202       static_cast<disk_cache::EntryImpl*>(entry);
2203
2204   entry_impl->entry()->Data()->state = 0xbad;
2205   entry_impl->entry()->Store();
2206   entry->Close();
2207   ASSERT_EQ(net::OK, CreateEntry("third", &entry));
2208   entry->Close();
2209   EXPECT_EQ(3, cache_->GetEntryCount());
2210
2211   // We have:
2212   // List 0: third -> second (bad).
2213   // List 1: first.
2214
2215   if (eviction) {
2216     // Detection order: second -> first -> third.
2217     TrimForTest(false);
2218     EXPECT_EQ(3, cache_->GetEntryCount());
2219     TrimForTest(false);
2220     EXPECT_EQ(2, cache_->GetEntryCount());
2221     TrimForTest(false);
2222     EXPECT_EQ(1, cache_->GetEntryCount());
2223   } else {
2224     // Detection order: third -> second -> first.
2225     // We should detect the problem through the list, but we should not delete
2226     // the entry.
2227     void* iter = NULL;
2228     ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
2229     entry->Close();
2230     ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
2231     EXPECT_EQ(first, entry->GetKey());
2232     entry->Close();
2233     EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
2234   }
2235   DisableIntegrityCheck();
2236 }
2237
2238 TEST_F(DiskCacheBackendTest, InvalidEntry10) {
2239   BackendInvalidEntry10(false);
2240 }
2241
2242 TEST_F(DiskCacheBackendTest, TrimInvalidEntry10) {
2243   BackendInvalidEntry10(true);
2244 }
2245
2246 // Tests handling of corrupt entries detected by enumerations.
2247 void DiskCacheBackendTest::BackendInvalidEntry11(bool eviction) {
2248   const int kSize = 0x3000;  // 12 kB.
2249   SetMaxSize(kSize * 10);
2250   SetNewEviction();
2251   InitCache();
2252
2253   std::string first("some key");
2254   std::string second("something else");
2255   disk_cache::Entry* entry;
2256   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2257   entry->Close();
2258   ASSERT_EQ(net::OK, OpenEntry(first, &entry));
2259   EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
2260   entry->Close();
2261   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2262   entry->Close();
2263   ASSERT_EQ(net::OK, OpenEntry(second, &entry));
2264   EXPECT_EQ(0, WriteData(entry, 0, 200, NULL, 0, false));
2265
2266   // Corrupt this entry.
2267   disk_cache::EntryImpl* entry_impl =
2268       static_cast<disk_cache::EntryImpl*>(entry);
2269
2270   entry_impl->entry()->Data()->state = 0xbad;
2271   entry_impl->entry()->Store();
2272   entry->Close();
2273   ASSERT_EQ(net::OK, CreateEntry("third", &entry));
2274   entry->Close();
2275   FlushQueueForTest();
2276   EXPECT_EQ(3, cache_->GetEntryCount());
2277
2278   // We have:
2279   // List 0: third.
2280   // List 1: second (bad) -> first.
2281
2282   if (eviction) {
2283     // Detection order: third -> first -> second.
2284     TrimForTest(false);
2285     EXPECT_EQ(2, cache_->GetEntryCount());
2286     TrimForTest(false);
2287     EXPECT_EQ(1, cache_->GetEntryCount());
2288     TrimForTest(false);
2289     EXPECT_EQ(1, cache_->GetEntryCount());
2290   } else {
2291     // Detection order: third -> second.
2292     // We should detect the problem through the list, but we should not delete
2293     // the entry, just fail the iteration.
2294     void* iter = NULL;
2295     ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
2296     entry->Close();
2297     EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
2298
2299     // Now a full iteration will work, and return two entries.
2300     ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
2301     entry->Close();
2302     ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
2303     entry->Close();
2304     EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
2305   }
2306   DisableIntegrityCheck();
2307 }
2308
2309 TEST_F(DiskCacheBackendTest, InvalidEntry11) {
2310   BackendInvalidEntry11(false);
2311 }
2312
2313 TEST_F(DiskCacheBackendTest, TrimInvalidEntry11) {
2314   BackendInvalidEntry11(true);
2315 }
2316
2317 // Tests handling of corrupt entries in the middle of a long eviction run.
2318 void DiskCacheBackendTest::BackendTrimInvalidEntry12() {
2319   const int kSize = 0x3000;  // 12 kB
2320   SetMaxSize(kSize * 10);
2321   InitCache();
2322
2323   std::string first("some key");
2324   std::string second("something else");
2325   disk_cache::Entry* entry;
2326   ASSERT_EQ(net::OK, CreateEntry(first, &entry));
2327   entry->Close();
2328   ASSERT_EQ(net::OK, CreateEntry(second, &entry));
2329
2330   // Corrupt this entry.
2331   disk_cache::EntryImpl* entry_impl =
2332       static_cast<disk_cache::EntryImpl*>(entry);
2333
2334   entry_impl->entry()->Data()->state = 0xbad;
2335   entry_impl->entry()->Store();
2336   entry->Close();
2337   ASSERT_EQ(net::OK, CreateEntry("third", &entry));
2338   entry->Close();
2339   ASSERT_EQ(net::OK, CreateEntry("fourth", &entry));
2340   TrimForTest(true);
2341   EXPECT_EQ(1, cache_->GetEntryCount());
2342   entry->Close();
2343   DisableIntegrityCheck();
2344 }
2345
2346 TEST_F(DiskCacheBackendTest, TrimInvalidEntry12) {
2347   BackendTrimInvalidEntry12();
2348 }
2349
2350 TEST_F(DiskCacheBackendTest, NewEvictionTrimInvalidEntry12) {
2351   SetNewEviction();
2352   BackendTrimInvalidEntry12();
2353 }
2354
2355 // We want to be able to deal with messed up entries on disk.
2356 void DiskCacheBackendTest::BackendInvalidRankings2() {
2357   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2358   DisableFirstCleanup();
2359   InitCache();
2360
2361   disk_cache::Entry *entry1, *entry2;
2362   EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
2363   ASSERT_EQ(net::OK, OpenEntry("some other key", &entry2));
2364   entry2->Close();
2365
2366   // CheckCacheIntegrity will fail at this point.
2367   DisableIntegrityCheck();
2368 }
2369
2370 TEST_F(DiskCacheBackendTest, InvalidRankings2) {
2371   BackendInvalidRankings2();
2372 }
2373
2374 TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankings2) {
2375   SetNewEviction();
2376   BackendInvalidRankings2();
2377 }
2378
2379 // If the LRU is corrupt, we delete the cache.
2380 void DiskCacheBackendTest::BackendInvalidRankings() {
2381   disk_cache::Entry* entry;
2382   void* iter = NULL;
2383   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry));
2384   entry->Close();
2385   EXPECT_EQ(2, cache_->GetEntryCount());
2386
2387   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry));
2388   FlushQueueForTest();  // Allow the restart to finish.
2389   EXPECT_EQ(0, cache_->GetEntryCount());
2390 }
2391
2392 TEST_F(DiskCacheBackendTest, InvalidRankingsSuccess) {
2393   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2394   DisableFirstCleanup();
2395   InitCache();
2396   BackendInvalidRankings();
2397 }
2398
2399 TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankingsSuccess) {
2400   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2401   DisableFirstCleanup();
2402   SetNewEviction();
2403   InitCache();
2404   BackendInvalidRankings();
2405 }
2406
2407 TEST_F(DiskCacheBackendTest, InvalidRankingsFailure) {
2408   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2409   DisableFirstCleanup();
2410   InitCache();
2411   SetTestMode();  // Fail cache reinitialization.
2412   BackendInvalidRankings();
2413 }
2414
2415 TEST_F(DiskCacheBackendTest, NewEvictionInvalidRankingsFailure) {
2416   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2417   DisableFirstCleanup();
2418   SetNewEviction();
2419   InitCache();
2420   SetTestMode();  // Fail cache reinitialization.
2421   BackendInvalidRankings();
2422 }
2423
2424 // If the LRU is corrupt and we have open entries, we disable the cache.
2425 void DiskCacheBackendTest::BackendDisable() {
2426   disk_cache::Entry *entry1, *entry2;
2427   void* iter = NULL;
2428   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry1));
2429
2430   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry2));
2431   EXPECT_EQ(0, cache_->GetEntryCount());
2432   EXPECT_NE(net::OK, CreateEntry("Something new", &entry2));
2433
2434   entry1->Close();
2435   FlushQueueForTest();  // Flushing the Close posts a task to restart the cache.
2436   FlushQueueForTest();  // This one actually allows that task to complete.
2437
2438   EXPECT_EQ(0, cache_->GetEntryCount());
2439 }
2440
2441 TEST_F(DiskCacheBackendTest, DisableSuccess) {
2442   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2443   DisableFirstCleanup();
2444   InitCache();
2445   BackendDisable();
2446 }
2447
2448 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess) {
2449   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2450   DisableFirstCleanup();
2451   SetNewEviction();
2452   InitCache();
2453   BackendDisable();
2454 }
2455
2456 TEST_F(DiskCacheBackendTest, DisableFailure) {
2457   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2458   DisableFirstCleanup();
2459   InitCache();
2460   SetTestMode();  // Fail cache reinitialization.
2461   BackendDisable();
2462 }
2463
2464 TEST_F(DiskCacheBackendTest, NewEvictionDisableFailure) {
2465   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2466   DisableFirstCleanup();
2467   SetNewEviction();
2468   InitCache();
2469   SetTestMode();  // Fail cache reinitialization.
2470   BackendDisable();
2471 }
2472
2473 // This is another type of corruption on the LRU; disable the cache.
2474 void DiskCacheBackendTest::BackendDisable2() {
2475   EXPECT_EQ(8, cache_->GetEntryCount());
2476
2477   disk_cache::Entry* entry;
2478   void* iter = NULL;
2479   int count = 0;
2480   while (OpenNextEntry(&iter, &entry) == net::OK) {
2481     ASSERT_TRUE(NULL != entry);
2482     entry->Close();
2483     count++;
2484     ASSERT_LT(count, 9);
2485   };
2486
2487   FlushQueueForTest();
2488   EXPECT_EQ(0, cache_->GetEntryCount());
2489 }
2490
2491 TEST_F(DiskCacheBackendTest, DisableSuccess2) {
2492   ASSERT_TRUE(CopyTestCache("list_loop"));
2493   DisableFirstCleanup();
2494   InitCache();
2495   BackendDisable2();
2496 }
2497
2498 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess2) {
2499   ASSERT_TRUE(CopyTestCache("list_loop"));
2500   DisableFirstCleanup();
2501   SetNewEviction();
2502   InitCache();
2503   BackendDisable2();
2504 }
2505
2506 TEST_F(DiskCacheBackendTest, DisableFailure2) {
2507   ASSERT_TRUE(CopyTestCache("list_loop"));
2508   DisableFirstCleanup();
2509   InitCache();
2510   SetTestMode();  // Fail cache reinitialization.
2511   BackendDisable2();
2512 }
2513
2514 TEST_F(DiskCacheBackendTest, NewEvictionDisableFailure2) {
2515   ASSERT_TRUE(CopyTestCache("list_loop"));
2516   DisableFirstCleanup();
2517   SetNewEviction();
2518   InitCache();
2519   SetTestMode();  // Fail cache reinitialization.
2520   BackendDisable2();
2521 }
2522
2523 // If the index size changes when we disable the cache, we should not crash.
2524 void DiskCacheBackendTest::BackendDisable3() {
2525   disk_cache::Entry *entry1, *entry2;
2526   void* iter = NULL;
2527   EXPECT_EQ(2, cache_->GetEntryCount());
2528   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry1));
2529   entry1->Close();
2530
2531   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry2));
2532   FlushQueueForTest();
2533
2534   ASSERT_EQ(net::OK, CreateEntry("Something new", &entry2));
2535   entry2->Close();
2536
2537   EXPECT_EQ(1, cache_->GetEntryCount());
2538 }
2539
2540 TEST_F(DiskCacheBackendTest, DisableSuccess3) {
2541   ASSERT_TRUE(CopyTestCache("bad_rankings2"));
2542   DisableFirstCleanup();
2543   SetMaxSize(20 * 1024 * 1024);
2544   InitCache();
2545   BackendDisable3();
2546 }
2547
2548 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess3) {
2549   ASSERT_TRUE(CopyTestCache("bad_rankings2"));
2550   DisableFirstCleanup();
2551   SetMaxSize(20 * 1024 * 1024);
2552   SetNewEviction();
2553   InitCache();
2554   BackendDisable3();
2555 }
2556
2557 // If we disable the cache, already open entries should work as far as possible.
2558 void DiskCacheBackendTest::BackendDisable4() {
2559   disk_cache::Entry *entry1, *entry2, *entry3, *entry4;
2560   void* iter = NULL;
2561   ASSERT_EQ(net::OK, OpenNextEntry(&iter, &entry1));
2562
2563   char key2[2000];
2564   char key3[20000];
2565   CacheTestFillBuffer(key2, sizeof(key2), true);
2566   CacheTestFillBuffer(key3, sizeof(key3), true);
2567   key2[sizeof(key2) - 1] = '\0';
2568   key3[sizeof(key3) - 1] = '\0';
2569   ASSERT_EQ(net::OK, CreateEntry(key2, &entry2));
2570   ASSERT_EQ(net::OK, CreateEntry(key3, &entry3));
2571
2572   const int kBufSize = 20000;
2573   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kBufSize));
2574   memset(buf->data(), 0, kBufSize);
2575   EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));
2576   EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
2577
2578   // This line should disable the cache but not delete it.
2579   EXPECT_NE(net::OK, OpenNextEntry(&iter, &entry4));
2580   EXPECT_EQ(0, cache_->GetEntryCount());
2581
2582   EXPECT_NE(net::OK, CreateEntry("cache is disabled", &entry4));
2583
2584   EXPECT_EQ(100, ReadData(entry2, 0, 0, buf.get(), 100));
2585   EXPECT_EQ(100, WriteData(entry2, 0, 0, buf.get(), 100, false));
2586   EXPECT_EQ(100, WriteData(entry2, 1, 0, buf.get(), 100, false));
2587
2588   EXPECT_EQ(kBufSize, ReadData(entry3, 0, 0, buf.get(), kBufSize));
2589   EXPECT_EQ(kBufSize, WriteData(entry3, 0, 0, buf.get(), kBufSize, false));
2590   EXPECT_EQ(kBufSize, WriteData(entry3, 1, 0, buf.get(), kBufSize, false));
2591
2592   std::string key = entry2->GetKey();
2593   EXPECT_EQ(sizeof(key2) - 1, key.size());
2594   key = entry3->GetKey();
2595   EXPECT_EQ(sizeof(key3) - 1, key.size());
2596
2597   entry1->Close();
2598   entry2->Close();
2599   entry3->Close();
2600   FlushQueueForTest();  // Flushing the Close posts a task to restart the cache.
2601   FlushQueueForTest();  // This one actually allows that task to complete.
2602
2603   EXPECT_EQ(0, cache_->GetEntryCount());
2604 }
2605
2606 TEST_F(DiskCacheBackendTest, DisableSuccess4) {
2607   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2608   DisableFirstCleanup();
2609   InitCache();
2610   BackendDisable4();
2611 }
2612
2613 TEST_F(DiskCacheBackendTest, NewEvictionDisableSuccess4) {
2614   ASSERT_TRUE(CopyTestCache("bad_rankings"));
2615   DisableFirstCleanup();
2616   SetNewEviction();
2617   InitCache();
2618   BackendDisable4();
2619 }
2620
2621 TEST_F(DiskCacheTest, Backend_UsageStatsTimer) {
2622   MessageLoopHelper helper;
2623
2624   ASSERT_TRUE(CleanupCacheDir());
2625   scoped_ptr<disk_cache::BackendImpl> cache;
2626   cache.reset(new disk_cache::BackendImpl(
2627       cache_path_, base::MessageLoopProxy::current().get(), NULL));
2628   ASSERT_TRUE(NULL != cache.get());
2629   cache->SetUnitTestMode();
2630   ASSERT_EQ(net::OK, cache->SyncInit());
2631
2632   // Wait for a callback that never comes... about 2 secs :). The message loop
2633   // has to run to allow invocation of the usage timer.
2634   helper.WaitUntilCacheIoFinished(1);
2635 }
2636
2637 TEST_F(DiskCacheBackendTest, Backend_UsageStats) {
2638   InitCache();
2639   disk_cache::Entry* entry;
2640   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
2641   entry->Close();
2642   FlushQueueForTest();
2643
2644   disk_cache::StatsItems stats;
2645   cache_->GetStats(&stats);
2646   EXPECT_FALSE(stats.empty());
2647
2648   disk_cache::StatsItems::value_type hits("Create hit", "0x1");
2649   EXPECT_EQ(1, std::count(stats.begin(), stats.end(), hits));
2650
2651   cache_.reset();
2652
2653   // Now open the cache and verify that the stats are still there.
2654   DisableFirstCleanup();
2655   InitCache();
2656   EXPECT_EQ(1, cache_->GetEntryCount());
2657
2658   stats.clear();
2659   cache_->GetStats(&stats);
2660   EXPECT_FALSE(stats.empty());
2661
2662   EXPECT_EQ(1, std::count(stats.begin(), stats.end(), hits));
2663 }
2664
2665 void DiskCacheBackendTest::BackendDoomAll() {
2666   InitCache();
2667
2668   disk_cache::Entry *entry1, *entry2;
2669   ASSERT_EQ(net::OK, CreateEntry("first", &entry1));
2670   ASSERT_EQ(net::OK, CreateEntry("second", &entry2));
2671   entry1->Close();
2672   entry2->Close();
2673
2674   ASSERT_EQ(net::OK, CreateEntry("third", &entry1));
2675   ASSERT_EQ(net::OK, CreateEntry("fourth", &entry2));
2676
2677   ASSERT_EQ(4, cache_->GetEntryCount());
2678   EXPECT_EQ(net::OK, DoomAllEntries());
2679   ASSERT_EQ(0, cache_->GetEntryCount());
2680
2681   // We should stop posting tasks at some point (if we post any).
2682   base::MessageLoop::current()->RunUntilIdle();
2683
2684   disk_cache::Entry *entry3, *entry4;
2685   EXPECT_NE(net::OK, OpenEntry("third", &entry3));
2686   ASSERT_EQ(net::OK, CreateEntry("third", &entry3));
2687   ASSERT_EQ(net::OK, CreateEntry("fourth", &entry4));
2688
2689   EXPECT_EQ(net::OK, DoomAllEntries());
2690   ASSERT_EQ(0, cache_->GetEntryCount());
2691
2692   entry1->Close();
2693   entry2->Close();
2694   entry3->Doom();  // The entry should be already doomed, but this must work.
2695   entry3->Close();
2696   entry4->Close();
2697
2698   // Now try with all references released.
2699   ASSERT_EQ(net::OK, CreateEntry("third", &entry1));
2700   ASSERT_EQ(net::OK, CreateEntry("fourth", &entry2));
2701   entry1->Close();
2702   entry2->Close();
2703
2704   ASSERT_EQ(2, cache_->GetEntryCount());
2705   EXPECT_EQ(net::OK, DoomAllEntries());
2706   ASSERT_EQ(0, cache_->GetEntryCount());
2707
2708   EXPECT_EQ(net::OK, DoomAllEntries());
2709 }
2710
2711 TEST_F(DiskCacheBackendTest, DoomAll) {
2712   BackendDoomAll();
2713 }
2714
2715 TEST_F(DiskCacheBackendTest, NewEvictionDoomAll) {
2716   SetNewEviction();
2717   BackendDoomAll();
2718 }
2719
2720 TEST_F(DiskCacheBackendTest, MemoryOnlyDoomAll) {
2721   SetMemoryOnlyMode();
2722   BackendDoomAll();
2723 }
2724
2725 TEST_F(DiskCacheBackendTest, AppCacheOnlyDoomAll) {
2726   SetCacheType(net::APP_CACHE);
2727   BackendDoomAll();
2728 }
2729
2730 TEST_F(DiskCacheBackendTest, ShaderCacheOnlyDoomAll) {
2731   SetCacheType(net::SHADER_CACHE);
2732   BackendDoomAll();
2733 }
2734
2735 // If the index size changes when we doom the cache, we should not crash.
2736 void DiskCacheBackendTest::BackendDoomAll2() {
2737   EXPECT_EQ(2, cache_->GetEntryCount());
2738   EXPECT_EQ(net::OK, DoomAllEntries());
2739
2740   disk_cache::Entry* entry;
2741   ASSERT_EQ(net::OK, CreateEntry("Something new", &entry));
2742   entry->Close();
2743
2744   EXPECT_EQ(1, cache_->GetEntryCount());
2745 }
2746
2747 TEST_F(DiskCacheBackendTest, DoomAll2) {
2748   ASSERT_TRUE(CopyTestCache("bad_rankings2"));
2749   DisableFirstCleanup();
2750   SetMaxSize(20 * 1024 * 1024);
2751   InitCache();
2752   BackendDoomAll2();
2753 }
2754
2755 TEST_F(DiskCacheBackendTest, NewEvictionDoomAll2) {
2756   ASSERT_TRUE(CopyTestCache("bad_rankings2"));
2757   DisableFirstCleanup();
2758   SetMaxSize(20 * 1024 * 1024);
2759   SetNewEviction();
2760   InitCache();
2761   BackendDoomAll2();
2762 }
2763
2764 // We should be able to create the same entry on multiple simultaneous instances
2765 // of the cache.
2766 TEST_F(DiskCacheTest, MultipleInstances) {
2767   base::ScopedTempDir store1, store2;
2768   ASSERT_TRUE(store1.CreateUniqueTempDir());
2769   ASSERT_TRUE(store2.CreateUniqueTempDir());
2770
2771   base::Thread cache_thread("CacheThread");
2772   ASSERT_TRUE(cache_thread.StartWithOptions(
2773       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
2774   net::TestCompletionCallback cb;
2775
2776   const int kNumberOfCaches = 2;
2777   scoped_ptr<disk_cache::Backend> cache[kNumberOfCaches];
2778
2779   int rv =
2780       disk_cache::CreateCacheBackend(net::DISK_CACHE,
2781                                      net::CACHE_BACKEND_DEFAULT,
2782                                      store1.path(),
2783                                      0,
2784                                      false,
2785                                      cache_thread.message_loop_proxy().get(),
2786                                      NULL,
2787                                      &cache[0],
2788                                      cb.callback());
2789   ASSERT_EQ(net::OK, cb.GetResult(rv));
2790   rv = disk_cache::CreateCacheBackend(net::MEDIA_CACHE,
2791                                       net::CACHE_BACKEND_DEFAULT,
2792                                       store2.path(),
2793                                       0,
2794                                       false,
2795                                       cache_thread.message_loop_proxy().get(),
2796                                       NULL,
2797                                       &cache[1],
2798                                       cb.callback());
2799   ASSERT_EQ(net::OK, cb.GetResult(rv));
2800
2801   ASSERT_TRUE(cache[0].get() != NULL && cache[1].get() != NULL);
2802
2803   std::string key("the first key");
2804   disk_cache::Entry* entry;
2805   for (int i = 0; i < kNumberOfCaches; i++) {
2806     rv = cache[i]->CreateEntry(key, &entry, cb.callback());
2807     ASSERT_EQ(net::OK, cb.GetResult(rv));
2808     entry->Close();
2809   }
2810 }
2811
2812 // Test the six regions of the curve that determines the max cache size.
2813 TEST_F(DiskCacheTest, AutomaticMaxSize) {
2814   const int kDefaultSize = 80 * 1024 * 1024;
2815   int64 large_size = kDefaultSize;
2816   int64 largest_size = kint32max;
2817
2818   // Region 1: expected = available * 0.8
2819   EXPECT_EQ((kDefaultSize - 1) * 8 / 10,
2820             disk_cache::PreferedCacheSize(large_size - 1));
2821   EXPECT_EQ(kDefaultSize * 8 / 10,
2822             disk_cache::PreferedCacheSize(large_size));
2823   EXPECT_EQ(kDefaultSize - 1,
2824             disk_cache::PreferedCacheSize(large_size * 10 / 8 - 1));
2825
2826   // Region 2: expected = default_size
2827   EXPECT_EQ(kDefaultSize,
2828             disk_cache::PreferedCacheSize(large_size * 10 / 8));
2829   EXPECT_EQ(kDefaultSize,
2830             disk_cache::PreferedCacheSize(large_size * 10 - 1));
2831
2832   // Region 3: expected = available * 0.1
2833   EXPECT_EQ(kDefaultSize,
2834             disk_cache::PreferedCacheSize(large_size * 10));
2835   EXPECT_EQ((kDefaultSize * 25 - 1) / 10,
2836             disk_cache::PreferedCacheSize(large_size * 25 - 1));
2837
2838   // Region 4: expected = default_size * 2.5
2839   EXPECT_EQ(kDefaultSize * 25 / 10,
2840             disk_cache::PreferedCacheSize(large_size * 25));
2841   EXPECT_EQ(kDefaultSize * 25 / 10,
2842             disk_cache::PreferedCacheSize(large_size * 100 - 1));
2843   EXPECT_EQ(kDefaultSize * 25 / 10,
2844             disk_cache::PreferedCacheSize(large_size * 100));
2845   EXPECT_EQ(kDefaultSize * 25 / 10,
2846             disk_cache::PreferedCacheSize(large_size * 250 - 1));
2847
2848   // Region 5: expected = available * 0.1
2849   EXPECT_EQ(kDefaultSize * 25 / 10,
2850             disk_cache::PreferedCacheSize(large_size * 250));
2851   EXPECT_EQ(kint32max - 1,
2852             disk_cache::PreferedCacheSize(largest_size * 100 - 1));
2853
2854   // Region 6: expected = kint32max
2855   EXPECT_EQ(kint32max,
2856             disk_cache::PreferedCacheSize(largest_size * 100));
2857   EXPECT_EQ(kint32max,
2858             disk_cache::PreferedCacheSize(largest_size * 10000));
2859 }
2860
2861 // Tests that we can "migrate" a running instance from one experiment group to
2862 // another.
2863 TEST_F(DiskCacheBackendTest, Histograms) {
2864   InitCache();
2865   disk_cache::BackendImpl* backend_ = cache_impl_;  // Needed be the macro.
2866
2867   for (int i = 1; i < 3; i++) {
2868     CACHE_UMA(HOURS, "FillupTime", i, 28);
2869   }
2870 }
2871
2872 // Make sure that we keep the total memory used by the internal buffers under
2873 // control.
2874 TEST_F(DiskCacheBackendTest, TotalBuffersSize1) {
2875   InitCache();
2876   std::string key("the first key");
2877   disk_cache::Entry* entry;
2878   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
2879
2880   const int kSize = 200;
2881   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
2882   CacheTestFillBuffer(buffer->data(), kSize, true);
2883
2884   for (int i = 0; i < 10; i++) {
2885     SCOPED_TRACE(i);
2886     // Allocate 2MB for this entry.
2887     EXPECT_EQ(kSize, WriteData(entry, 0, 0, buffer.get(), kSize, true));
2888     EXPECT_EQ(kSize, WriteData(entry, 1, 0, buffer.get(), kSize, true));
2889     EXPECT_EQ(kSize,
2890               WriteData(entry, 0, 1024 * 1024, buffer.get(), kSize, false));
2891     EXPECT_EQ(kSize,
2892               WriteData(entry, 1, 1024 * 1024, buffer.get(), kSize, false));
2893
2894     // Delete one of the buffers and truncate the other.
2895     EXPECT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, true));
2896     EXPECT_EQ(0, WriteData(entry, 1, 10, buffer.get(), 0, true));
2897
2898     // Delete the second buffer, writing 10 bytes to disk.
2899     entry->Close();
2900     ASSERT_EQ(net::OK, OpenEntry(key, &entry));
2901   }
2902
2903   entry->Close();
2904   EXPECT_EQ(0, cache_impl_->GetTotalBuffersSize());
2905 }
2906
2907 // This test assumes at least 150MB of system memory.
2908 TEST_F(DiskCacheBackendTest, TotalBuffersSize2) {
2909   InitCache();
2910
2911   const int kOneMB = 1024 * 1024;
2912   EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
2913   EXPECT_EQ(kOneMB, cache_impl_->GetTotalBuffersSize());
2914
2915   EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
2916   EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
2917
2918   EXPECT_TRUE(cache_impl_->IsAllocAllowed(0, kOneMB));
2919   EXPECT_EQ(kOneMB * 3, cache_impl_->GetTotalBuffersSize());
2920
2921   cache_impl_->BufferDeleted(kOneMB);
2922   EXPECT_EQ(kOneMB * 2, cache_impl_->GetTotalBuffersSize());
2923
2924   // Check the upper limit.
2925   EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, 30 * kOneMB));
2926
2927   for (int i = 0; i < 30; i++)
2928     cache_impl_->IsAllocAllowed(0, kOneMB);  // Ignore the result.
2929
2930   EXPECT_FALSE(cache_impl_->IsAllocAllowed(0, kOneMB));
2931 }
2932
2933 // Tests that sharing of external files works and we are able to delete the
2934 // files when we need to.
2935 TEST_F(DiskCacheBackendTest, FileSharing) {
2936   InitCache();
2937
2938   disk_cache::Addr address(0x80000001);
2939   ASSERT_TRUE(cache_impl_->CreateExternalFile(&address));
2940   base::FilePath name = cache_impl_->GetFileName(address);
2941
2942   scoped_refptr<disk_cache::File> file(new disk_cache::File(false));
2943   file->Init(name);
2944
2945 #if defined(OS_WIN)
2946   DWORD sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
2947   DWORD access = GENERIC_READ | GENERIC_WRITE;
2948   base::win::ScopedHandle file2(CreateFile(
2949       name.value().c_str(), access, sharing, NULL, OPEN_EXISTING, 0, NULL));
2950   EXPECT_FALSE(file2.IsValid());
2951
2952   sharing |= FILE_SHARE_DELETE;
2953   file2.Set(CreateFile(name.value().c_str(), access, sharing, NULL,
2954                        OPEN_EXISTING, 0, NULL));
2955   EXPECT_TRUE(file2.IsValid());
2956 #endif
2957
2958   EXPECT_TRUE(base::DeleteFile(name, false));
2959
2960   // We should be able to use the file.
2961   const int kSize = 200;
2962   char buffer1[kSize];
2963   char buffer2[kSize];
2964   memset(buffer1, 't', kSize);
2965   memset(buffer2, 0, kSize);
2966   EXPECT_TRUE(file->Write(buffer1, kSize, 0));
2967   EXPECT_TRUE(file->Read(buffer2, kSize, 0));
2968   EXPECT_EQ(0, memcmp(buffer1, buffer2, kSize));
2969
2970   EXPECT_TRUE(disk_cache::DeleteCacheFile(name));
2971 }
2972
2973 TEST_F(DiskCacheBackendTest, UpdateRankForExternalCacheHit) {
2974   InitCache();
2975
2976   disk_cache::Entry* entry;
2977
2978   for (int i = 0; i < 2; ++i) {
2979     std::string key = base::StringPrintf("key%d", i);
2980     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
2981     entry->Close();
2982   }
2983
2984   // Ping the oldest entry.
2985   cache_->OnExternalCacheHit("key0");
2986
2987   TrimForTest(false);
2988
2989   // Make sure the older key remains.
2990   EXPECT_EQ(1, cache_->GetEntryCount());
2991   ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
2992   entry->Close();
2993 }
2994
2995 TEST_F(DiskCacheBackendTest, ShaderCacheUpdateRankForExternalCacheHit) {
2996   SetCacheType(net::SHADER_CACHE);
2997   InitCache();
2998
2999   disk_cache::Entry* entry;
3000
3001   for (int i = 0; i < 2; ++i) {
3002     std::string key = base::StringPrintf("key%d", i);
3003     ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3004     entry->Close();
3005   }
3006
3007   // Ping the oldest entry.
3008   cache_->OnExternalCacheHit("key0");
3009
3010   TrimForTest(false);
3011
3012   // Make sure the older key remains.
3013   EXPECT_EQ(1, cache_->GetEntryCount());
3014   ASSERT_EQ(net::OK, OpenEntry("key0", &entry));
3015   entry->Close();
3016 }
3017
3018 void DiskCacheBackendTest::TracingBackendBasics() {
3019   InitCache();
3020   cache_.reset(new disk_cache::TracingCacheBackend(cache_.Pass()));
3021   cache_impl_ = NULL;
3022   EXPECT_EQ(net::DISK_CACHE, cache_->GetCacheType());
3023   if (!simple_cache_mode_) {
3024     EXPECT_EQ(0, cache_->GetEntryCount());
3025   }
3026
3027   net::TestCompletionCallback cb;
3028   disk_cache::Entry* entry = NULL;
3029   EXPECT_NE(net::OK, OpenEntry("key", &entry));
3030   EXPECT_TRUE(NULL == entry);
3031
3032   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
3033   EXPECT_TRUE(NULL != entry);
3034
3035   disk_cache::Entry* same_entry = NULL;
3036   ASSERT_EQ(net::OK, OpenEntry("key", &same_entry));
3037   EXPECT_TRUE(NULL != same_entry);
3038
3039   if (!simple_cache_mode_) {
3040     EXPECT_EQ(1, cache_->GetEntryCount());
3041   }
3042   entry->Close();
3043   entry = NULL;
3044   same_entry->Close();
3045   same_entry = NULL;
3046 }
3047
3048 TEST_F(DiskCacheBackendTest, TracingBackendBasics) {
3049   TracingBackendBasics();
3050 }
3051
3052 // The simple cache backend isn't intended to work on windows, which has very
3053 // different file system guarantees from Windows.
3054 #if !defined(OS_WIN)
3055
3056 TEST_F(DiskCacheBackendTest, SimpleCacheBasics) {
3057   SetSimpleCacheMode();
3058   BackendBasics();
3059 }
3060
3061 TEST_F(DiskCacheBackendTest, SimpleCacheAppCacheBasics) {
3062   SetCacheType(net::APP_CACHE);
3063   SetSimpleCacheMode();
3064   BackendBasics();
3065 }
3066
3067 TEST_F(DiskCacheBackendTest, SimpleCacheKeying) {
3068   SetSimpleCacheMode();
3069   BackendKeying();
3070 }
3071
3072 TEST_F(DiskCacheBackendTest, SimpleCacheAppCacheKeying) {
3073   SetSimpleCacheMode();
3074   SetCacheType(net::APP_CACHE);
3075   BackendKeying();
3076 }
3077
3078 TEST_F(DiskCacheBackendTest, DISABLED_SimpleCacheSetSize) {
3079   SetSimpleCacheMode();
3080   BackendSetSize();
3081 }
3082
3083 // MacOS has a default open file limit of 256 files, which is incompatible with
3084 // this simple cache test.
3085 #if defined(OS_MACOSX)
3086 #define SIMPLE_MAYBE_MACOS(TestName) DISABLED_ ## TestName
3087 #else
3088 #define SIMPLE_MAYBE_MACOS(TestName) TestName
3089 #endif
3090
3091 TEST_F(DiskCacheBackendTest, SIMPLE_MAYBE_MACOS(SimpleCacheLoad)) {
3092   SetMaxSize(0x100000);
3093   SetSimpleCacheMode();
3094   BackendLoad();
3095 }
3096
3097 TEST_F(DiskCacheBackendTest, SIMPLE_MAYBE_MACOS(SimpleCacheAppCacheLoad)) {
3098   SetCacheType(net::APP_CACHE);
3099   SetSimpleCacheMode();
3100   SetMaxSize(0x100000);
3101   BackendLoad();
3102 }
3103
3104 TEST_F(DiskCacheBackendTest, SimpleDoomRecent) {
3105   SetSimpleCacheMode();
3106   BackendDoomRecent();
3107 }
3108
3109 TEST_F(DiskCacheBackendTest, SimpleDoomBetween) {
3110   SetSimpleCacheMode();
3111   BackendDoomBetween();
3112 }
3113
3114 // See http://crbug.com/237450.
3115 TEST_F(DiskCacheBackendTest, FLAKY_SimpleCacheDoomAll) {
3116   SetSimpleCacheMode();
3117   BackendDoomAll();
3118 }
3119
3120 TEST_F(DiskCacheBackendTest, FLAKY_SimpleCacheAppCacheOnlyDoomAll) {
3121   SetCacheType(net::APP_CACHE);
3122   SetSimpleCacheMode();
3123   BackendDoomAll();
3124 }
3125
3126 TEST_F(DiskCacheBackendTest, SimpleCacheTracingBackendBasics) {
3127   SetSimpleCacheMode();
3128   TracingBackendBasics();
3129   // TODO(pasko): implement integrity checking on the Simple Backend.
3130   DisableIntegrityCheck();
3131 }
3132
3133 TEST_F(DiskCacheBackendTest, SimpleCacheOpenMissingFile) {
3134   SetSimpleCacheMode();
3135   InitCache();
3136
3137   const char* key = "the first key";
3138   disk_cache::Entry* entry = NULL;
3139
3140   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3141   ASSERT_TRUE(entry != NULL);
3142   entry->Close();
3143   entry = NULL;
3144
3145   // To make sure the file creation completed we need to call open again so that
3146   // we block until it actually created the files.
3147   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3148   ASSERT_TRUE(entry != NULL);
3149   entry->Close();
3150   entry = NULL;
3151
3152   // Delete one of the files in the entry.
3153   base::FilePath to_delete_file = cache_path_.AppendASCII(
3154       disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, 0));
3155   EXPECT_TRUE(base::PathExists(to_delete_file));
3156   EXPECT_TRUE(disk_cache::DeleteCacheFile(to_delete_file));
3157
3158   // Failing to open the entry should delete the rest of these files.
3159   ASSERT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
3160
3161   // Confirm the rest of the files are gone.
3162   for (int i = 1; i < disk_cache::kSimpleEntryFileCount; ++i) {
3163     base::FilePath
3164         should_be_gone_file(cache_path_.AppendASCII(
3165             disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, i)));
3166     EXPECT_FALSE(base::PathExists(should_be_gone_file));
3167   }
3168 }
3169
3170 TEST_F(DiskCacheBackendTest, SimpleCacheOpenBadFile) {
3171   SetSimpleCacheMode();
3172   InitCache();
3173
3174   const char* key = "the first key";
3175   disk_cache::Entry* entry = NULL;
3176
3177   ASSERT_EQ(net::OK, CreateEntry(key, &entry));
3178   disk_cache::Entry* null = NULL;
3179   ASSERT_NE(null, entry);
3180   entry->Close();
3181   entry = NULL;
3182
3183   // To make sure the file creation completed we need to call open again so that
3184   // we block until it actually created the files.
3185   ASSERT_EQ(net::OK, OpenEntry(key, &entry));
3186   ASSERT_NE(null, entry);
3187   entry->Close();
3188   entry = NULL;
3189
3190   // Write an invalid header on stream 1.
3191   base::FilePath entry_file1_path = cache_path_.AppendASCII(
3192       disk_cache::simple_util::GetFilenameFromKeyAndIndex(key, 1));
3193
3194   disk_cache::SimpleFileHeader header;
3195   header.initial_magic_number = GG_UINT64_C(0xbadf00d);
3196   EXPECT_EQ(
3197       implicit_cast<int>(sizeof(header)),
3198       file_util::WriteFile(entry_file1_path, reinterpret_cast<char*>(&header),
3199                            sizeof(header)));
3200   ASSERT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
3201 }
3202
3203 // Tests that the Simple Cache Backend fails to initialize with non-matching
3204 // file structure on disk.
3205 TEST_F(DiskCacheBackendTest, SimpleCacheOverBlockfileCache) {
3206   // Create a cache structure with the |BackendImpl|.
3207   InitCache();
3208   disk_cache::Entry* entry;
3209   const int kSize = 50;
3210   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
3211   CacheTestFillBuffer(buffer->data(), kSize, false);
3212   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
3213   ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
3214   entry->Close();
3215   cache_.reset();
3216
3217   // Check that the |SimpleBackendImpl| does not favor this structure.
3218   base::Thread cache_thread("CacheThread");
3219   ASSERT_TRUE(cache_thread.StartWithOptions(
3220       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
3221   disk_cache::SimpleBackendImpl* simple_cache =
3222       new disk_cache::SimpleBackendImpl(cache_path_,
3223                                         0,
3224                                         net::DISK_CACHE,
3225                                         cache_thread.message_loop_proxy().get(),
3226                                         NULL);
3227   net::TestCompletionCallback cb;
3228   int rv = simple_cache->Init(cb.callback());
3229   EXPECT_NE(net::OK, cb.GetResult(rv));
3230   delete simple_cache;
3231   DisableIntegrityCheck();
3232 }
3233
3234 // Tests that the |BackendImpl| refuses to initialize on top of the files
3235 // generated by the Simple Cache Backend.
3236 TEST_F(DiskCacheBackendTest, BlockfileCacheOverSimpleCache) {
3237   // Create a cache structure with the |SimpleBackendImpl|.
3238   SetSimpleCacheMode();
3239   InitCache();
3240   disk_cache::Entry* entry;
3241   const int kSize = 50;
3242   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
3243   CacheTestFillBuffer(buffer->data(), kSize, false);
3244   ASSERT_EQ(net::OK, CreateEntry("key", &entry));
3245   ASSERT_EQ(0, WriteData(entry, 0, 0, buffer.get(), 0, false));
3246   entry->Close();
3247   cache_.reset();
3248
3249   // Check that the |BackendImpl| does not favor this structure.
3250   base::Thread cache_thread("CacheThread");
3251   ASSERT_TRUE(cache_thread.StartWithOptions(
3252       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
3253   disk_cache::BackendImpl* cache = new disk_cache::BackendImpl(
3254       cache_path_, base::MessageLoopProxy::current().get(), NULL);
3255   cache->SetUnitTestMode();
3256   net::TestCompletionCallback cb;
3257   int rv = cache->Init(cb.callback());
3258   EXPECT_NE(net::OK, cb.GetResult(rv));
3259   delete cache;
3260   DisableIntegrityCheck();
3261 }
3262
3263 TEST_F(DiskCacheBackendTest, SimpleCacheFixEnumerators) {
3264   SetSimpleCacheMode();
3265   BackendFixEnumerators();
3266 }
3267
3268 // Creates entries based on random keys. Stores these keys in |key_pool|.
3269 bool DiskCacheBackendTest::CreateSetOfRandomEntries(
3270     std::set<std::string>* key_pool) {
3271   const int kNumEntries = 10;
3272
3273   for (int i = 0; i < kNumEntries; ++i) {
3274     std::string key = GenerateKey(true);
3275     disk_cache::Entry* entry;
3276     if (CreateEntry(key, &entry) != net::OK)
3277       return false;
3278     key_pool->insert(key);
3279     entry->Close();
3280   }
3281   return key_pool->size() == implicit_cast<size_t>(cache_->GetEntryCount());
3282 }
3283
3284 // Performs iteration over the backend and checks that the keys of entries
3285 // opened are in |keys_to_match|, then erases them. Up to |max_to_open| entries
3286 // will be opened, if it is positive. Otherwise, iteration will continue until
3287 // OpenNextEntry stops returning net::OK.
3288 bool DiskCacheBackendTest::EnumerateAndMatchKeys(
3289     int max_to_open,
3290     void** iter,
3291     std::set<std::string>* keys_to_match,
3292     size_t* count) {
3293   disk_cache::Entry* entry;
3294
3295   while (OpenNextEntry(iter, &entry) == net::OK) {
3296     if (!entry)
3297       return false;
3298     EXPECT_EQ(1U, keys_to_match->erase(entry->GetKey()));
3299     entry->Close();
3300     ++(*count);
3301     if (max_to_open >= 0 && implicit_cast<int>(*count) >= max_to_open)
3302       break;
3303   };
3304
3305   return true;
3306 }
3307
3308 // Tests basic functionality of the SimpleBackend implementation of the
3309 // enumeration API.
3310 TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationBasics) {
3311   SetSimpleCacheMode();
3312   InitCache();
3313   std::set<std::string> key_pool;
3314   ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
3315
3316   // Check that enumeration returns all entries.
3317   std::set<std::string> keys_to_match(key_pool);
3318   void* iter = NULL;
3319   size_t count = 0;
3320   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
3321   cache_->EndEnumeration(&iter);
3322   EXPECT_EQ(key_pool.size(), count);
3323   EXPECT_TRUE(keys_to_match.empty());
3324
3325   // Check that opening entries does not affect enumeration.
3326   keys_to_match = key_pool;
3327   iter = NULL;
3328   count = 0;
3329   disk_cache::Entry* entry_opened_before;
3330   ASSERT_EQ(net::OK, OpenEntry(*(key_pool.begin()), &entry_opened_before));
3331   ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size()/2,
3332                                     &iter,
3333                                     &keys_to_match,
3334                                     &count));
3335
3336   disk_cache::Entry* entry_opened_middle;
3337   ASSERT_EQ(net::OK,
3338             OpenEntry(*(keys_to_match.begin()), &entry_opened_middle));
3339   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
3340   cache_->EndEnumeration(&iter);
3341   entry_opened_before->Close();
3342   entry_opened_middle->Close();
3343
3344   EXPECT_EQ(key_pool.size(), count);
3345   EXPECT_TRUE(keys_to_match.empty());
3346 }
3347
3348 // Tests that the enumerations are not affected by dooming an entry in the
3349 // middle.
3350 TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationWhileDoomed) {
3351   SetSimpleCacheMode();
3352   InitCache();
3353   std::set<std::string> key_pool;
3354   ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
3355
3356   // Check that enumeration returns all entries but the doomed one.
3357   std::set<std::string> keys_to_match(key_pool);
3358   void* iter = NULL;
3359   size_t count = 0;
3360   ASSERT_TRUE(EnumerateAndMatchKeys(key_pool.size()/2,
3361                                     &iter,
3362                                     &keys_to_match,
3363                                     &count));
3364
3365   std::string key_to_delete = *(keys_to_match.begin());
3366   DoomEntry(key_to_delete);
3367   keys_to_match.erase(key_to_delete);
3368   key_pool.erase(key_to_delete);
3369   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
3370   cache_->EndEnumeration(&iter);
3371
3372   EXPECT_EQ(key_pool.size(), count);
3373   EXPECT_TRUE(keys_to_match.empty());
3374 }
3375
3376 // Tests that enumerations are not affected by corrupt files.
3377 TEST_F(DiskCacheBackendTest, SimpleCacheEnumerationCorruption) {
3378   SetSimpleCacheMode();
3379   InitCache();
3380   std::set<std::string> key_pool;
3381   ASSERT_TRUE(CreateSetOfRandomEntries(&key_pool));
3382
3383   // Create a corrupt entry. The write/read sequence ensures that the entry will
3384   // have been created before corrupting the platform files, in the case of
3385   // optimistic operations.
3386   const std::string key = "the key";
3387   disk_cache::Entry* corrupted_entry;
3388
3389   ASSERT_EQ(net::OK, CreateEntry(key, &corrupted_entry));
3390   ASSERT_TRUE(corrupted_entry);
3391   const int kSize = 50;
3392   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
3393   CacheTestFillBuffer(buffer->data(), kSize, false);
3394   ASSERT_EQ(kSize,
3395             WriteData(corrupted_entry, 0, 0, buffer.get(), kSize, false));
3396   ASSERT_EQ(kSize, ReadData(corrupted_entry, 0, 0, buffer.get(), kSize));
3397   corrupted_entry->Close();
3398
3399   EXPECT_TRUE(disk_cache::simple_util::CreateCorruptFileForTests(
3400       key, cache_path_));
3401   EXPECT_EQ(key_pool.size() + 1,
3402             implicit_cast<size_t>(cache_->GetEntryCount()));
3403
3404   // Check that enumeration returns all entries but the corrupt one.
3405   std::set<std::string> keys_to_match(key_pool);
3406   void* iter = NULL;
3407   size_t count = 0;
3408   ASSERT_TRUE(EnumerateAndMatchKeys(-1, &iter, &keys_to_match, &count));
3409   cache_->EndEnumeration(&iter);
3410
3411   EXPECT_EQ(key_pool.size(), count);
3412   EXPECT_TRUE(keys_to_match.empty());
3413 }
3414
3415 #endif  // !defined(OS_WIN)