Home | History | Annotate | Download | only in simple 
      1 // Copyright (c) 2013 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/files/scoped_temp_dir.h"
      6 #include "base/hash.h"
      7 #include "base/logging.h"
      8 #include "base/memory/scoped_ptr.h"
      9 #include "base/pickle.h"
     10 #include "base/sha1.h"
     11 #include "base/strings/stringprintf.h"
     12 #include "base/task_runner.h"
     13 #include "base/threading/platform_thread.h"
     14 #include "base/time/time.h"
     15 #include "net/disk_cache/simple/simple_index.h"
     16 #include "net/disk_cache/simple/simple_index_file.h"
     17 #include "net/disk_cache/simple/simple_util.h"
     18 #include "testing/gtest/include/gtest/gtest.h"
     19 
     20 namespace {
     21 
     22 const int64 kTestLastUsedTimeInternal = 12345;
     23 const base::Time kTestLastUsedTime =
     24     base::Time::FromInternalValue(kTestLastUsedTimeInternal);
     25 const uint64 kTestEntrySize = 789;
     26 const uint64 kKey1Hash = disk_cache::simple_util::GetEntryHashKey("key1");
     27 const uint64 kKey2Hash = disk_cache::simple_util::GetEntryHashKey("key2");
     28 const uint64 kKey3Hash = disk_cache::simple_util::GetEntryHashKey("key3");
     29 
     30 }  // namespace
     31 
     32 namespace disk_cache {
     33 
     34 class EntryMetadataTest  : public testing::Test {
     35  public:
     36   EntryMetadata NewEntryMetadataWithValues() {
     37     return EntryMetadata(kTestLastUsedTime, kTestEntrySize);
     38   }
     39 
     40   void CheckEntryMetadataValues(const EntryMetadata& entry_metadata) {
     41     EXPECT_EQ(kTestLastUsedTime, entry_metadata.GetLastUsedTime());
     42     EXPECT_EQ(kTestEntrySize, entry_metadata.GetEntrySize());
     43   }
     44 };
     45 
     46 class MockSimpleIndexFile : public SimpleIndexFile,
     47                             public base::SupportsWeakPtr<MockSimpleIndexFile> {
     48  public:
     49   MockSimpleIndexFile()
     50       : SimpleIndexFile(NULL, NULL, base::FilePath()),
     51         load_result_(NULL),
     52         load_index_entries_calls_(0),
     53         doom_entry_set_calls_(0),
     54         disk_writes_(0) {}
     55 
     56   virtual void LoadIndexEntries(
     57       base::Time cache_last_modified,
     58       const base::Closure& callback,
     59       SimpleIndexLoadResult* out_load_result) OVERRIDE {
     60     load_callback_ = callback;
     61     load_result_ = out_load_result;
     62     ++load_index_entries_calls_;
     63   }
     64 
     65   virtual void WriteToDisk(const SimpleIndex::EntrySet& entry_set,
     66                            uint64 cache_size,
     67                            const base::TimeTicks& start,
     68                            bool app_on_background) OVERRIDE {
     69     disk_writes_++;
     70     disk_write_entry_set_ = entry_set;
     71   }
     72 
     73   virtual void DoomEntrySet(
     74       scoped_ptr<std::vector<uint64> > entry_hashes,
     75       const base::Callback<void(int)>& reply_callback) OVERRIDE {
     76     last_doom_entry_hashes_ = *entry_hashes.get();
     77     last_doom_reply_callback_ = reply_callback;
     78     ++doom_entry_set_calls_;
     79   }
     80 
     81   void GetAndResetDiskWriteEntrySet(SimpleIndex::EntrySet* entry_set) {
     82     entry_set->swap(disk_write_entry_set_);
     83   }
     84 
     85   const base::Closure& load_callback() const { return load_callback_; }
     86   SimpleIndexLoadResult* load_result() const { return load_result_; }
     87   int load_index_entries_calls() const { return load_index_entries_calls_; }
     88   int disk_writes() const { return disk_writes_; }
     89   const std::vector<uint64>& last_doom_entry_hashes() const {
     90     return last_doom_entry_hashes_;
     91   }
     92   int doom_entry_set_calls() const { return doom_entry_set_calls_; }
     93 
     94  private:
     95   base::Closure load_callback_;
     96   SimpleIndexLoadResult* load_result_;
     97   int load_index_entries_calls_;
     98   std::vector<uint64> last_doom_entry_hashes_;
     99   int doom_entry_set_calls_;
    100   base::Callback<void(int)> last_doom_reply_callback_;
    101   int disk_writes_;
    102   SimpleIndex::EntrySet disk_write_entry_set_;
    103 };
    104 
    105 class SimpleIndexTest  : public testing::Test {
    106  public:
    107   virtual void SetUp() OVERRIDE {
    108     scoped_ptr<MockSimpleIndexFile> index_file(new MockSimpleIndexFile());
    109     index_file_ = index_file->AsWeakPtr();
    110     index_.reset(new SimpleIndex(NULL, base::FilePath(),
    111                                  index_file.PassAs<SimpleIndexFile>()));
    112 
    113     index_->Initialize(base::Time());
    114   }
    115 
    116   void WaitForTimeChange() {
    117     base::Time now(base::Time::Now());
    118 
    119     do {
    120       base::PlatformThread::YieldCurrentThread();
    121     } while (now == base::Time::Now());
    122   }
    123 
    124   // Redirect to allow single "friend" declaration in base class.
    125   bool GetEntryForTesting(const std::string& key, EntryMetadata* metadata) {
    126     const uint64 hash_key = simple_util::GetEntryHashKey(key);
    127     SimpleIndex::EntrySet::iterator it = index_->entries_set_.find(hash_key);
    128     if (index_->entries_set_.end() == it)
    129       return false;
    130     *metadata = it->second;
    131     return true;
    132   }
    133 
    134   void InsertIntoIndexFileReturn(const std::string& key,
    135                                  base::Time last_used_time,
    136                                  uint64 entry_size) {
    137     uint64 hash_key(simple_util::GetEntryHashKey(key));
    138     index_file_->load_result()->entries.insert(std::make_pair(
    139         hash_key, EntryMetadata(last_used_time, entry_size)));
    140   }
    141 
    142   void ReturnIndexFile() {
    143     index_file_->load_result()->did_load = true;
    144     index_file_->load_callback().Run();
    145   }
    146 
    147   // Non-const for timer manipulation.
    148   SimpleIndex* index() { return index_.get(); }
    149   const MockSimpleIndexFile* index_file() const { return index_file_.get(); }
    150 
    151  protected:
    152   scoped_ptr<SimpleIndex> index_;
    153   base::WeakPtr<MockSimpleIndexFile> index_file_;
    154 };
    155 
    156 TEST_F(EntryMetadataTest, Basics) {
    157   EntryMetadata entry_metadata;
    158   EXPECT_EQ(base::Time::FromInternalValue(0), entry_metadata.GetLastUsedTime());
    159   EXPECT_EQ(size_t(0), entry_metadata.GetEntrySize());
    160 
    161   entry_metadata = NewEntryMetadataWithValues();
    162   CheckEntryMetadataValues(entry_metadata);
    163 
    164   const base::Time new_time = base::Time::FromInternalValue(5);
    165   entry_metadata.SetLastUsedTime(new_time);
    166   EXPECT_EQ(new_time, entry_metadata.GetLastUsedTime());
    167 }
    168 
    169 TEST_F(EntryMetadataTest, Serialize) {
    170   EntryMetadata entry_metadata = NewEntryMetadataWithValues();
    171 
    172   Pickle pickle;
    173   entry_metadata.Serialize(&pickle);
    174 
    175   PickleIterator it(pickle);
    176   EntryMetadata new_entry_metadata;
    177   new_entry_metadata.Deserialize(&it);
    178   CheckEntryMetadataValues(new_entry_metadata);
    179 }
    180 
    181 TEST_F(SimpleIndexTest, IndexSizeCorrectOnMerge) {
    182   typedef disk_cache::SimpleIndex::EntrySet EntrySet;
    183   index()->SetMaxSize(100);
    184   index()->Insert("two");
    185   index()->UpdateEntrySize("two", 2);
    186   index()->Insert("five");
    187   index()->UpdateEntrySize("five", 5);
    188   index()->Insert("seven");
    189   index()->UpdateEntrySize("seven", 7);
    190   EXPECT_EQ(14U, index()->cache_size_);
    191   {
    192     scoped_ptr<SimpleIndexLoadResult> result(new SimpleIndexLoadResult());
    193     result->did_load = true;
    194     index()->MergeInitializingSet(result.Pass());
    195   }
    196   EXPECT_EQ(14U, index()->cache_size_);
    197   {
    198     scoped_ptr<SimpleIndexLoadResult> result(new SimpleIndexLoadResult());
    199     result->did_load = true;
    200     const uint64 new_hash_key = simple_util::GetEntryHashKey("eleven");
    201     result->entries.insert(
    202         std::make_pair(new_hash_key, EntryMetadata(base::Time::Now(), 11)));
    203     const uint64 redundant_hash_key = simple_util::GetEntryHashKey("seven");
    204     result->entries.insert(std::make_pair(redundant_hash_key,
    205                                           EntryMetadata(base::Time::Now(), 7)));
    206     index()->MergeInitializingSet(result.Pass());
    207   }
    208   EXPECT_EQ(2U + 5U + 7U + 11U, index()->cache_size_);
    209 }
    210 
    211 // State of index changes as expected with an insert and a remove.
    212 TEST_F(SimpleIndexTest, BasicInsertRemove) {
    213   // Confirm blank state.
    214   EntryMetadata metadata;
    215   EXPECT_EQ(base::Time(), metadata.GetLastUsedTime());
    216   EXPECT_EQ(0ul, metadata.GetEntrySize());
    217 
    218   // Confirm state after insert.
    219   index()->Insert("key1");
    220   EXPECT_TRUE(GetEntryForTesting("key1", &metadata));
    221   base::Time now(base::Time::Now());
    222   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
    223   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
    224   EXPECT_EQ(0ul, metadata.GetEntrySize());
    225 
    226   // Confirm state after remove.
    227   metadata = EntryMetadata();
    228   index()->Remove("key1");
    229   EXPECT_FALSE(GetEntryForTesting("key1", &metadata));
    230   EXPECT_EQ(base::Time(), metadata.GetLastUsedTime());
    231   EXPECT_EQ(0ul, metadata.GetEntrySize());
    232 }
    233 
    234 TEST_F(SimpleIndexTest, Has) {
    235   // Confirm the base index has dispatched the request for index entries.
    236   EXPECT_TRUE(index_file_.get());
    237   EXPECT_EQ(1, index_file_->load_index_entries_calls());
    238 
    239   // Confirm "Has()" always returns true before the callback is called.
    240   EXPECT_TRUE(index()->Has(kKey1Hash));
    241   index()->Insert("key1");
    242   EXPECT_TRUE(index()->Has(kKey1Hash));
    243   index()->Remove("key1");
    244   // TODO(rdsmith): Maybe return false on explicitly removed entries?
    245   EXPECT_TRUE(index()->Has(kKey1Hash));
    246 
    247   ReturnIndexFile();
    248 
    249   // Confirm "Has() returns conditionally now.
    250   EXPECT_FALSE(index()->Has(kKey1Hash));
    251   index()->Insert("key1");
    252   EXPECT_TRUE(index()->Has(kKey1Hash));
    253   index()->Remove("key1");
    254 }
    255 
    256 TEST_F(SimpleIndexTest, UseIfExists) {
    257   // Confirm the base index has dispatched the request for index entries.
    258   EXPECT_TRUE(index_file_.get());
    259   EXPECT_EQ(1, index_file_->load_index_entries_calls());
    260 
    261   // Confirm "UseIfExists()" always returns true before the callback is called
    262   // and updates mod time if the entry was really there.
    263   EntryMetadata metadata1, metadata2;
    264   EXPECT_TRUE(index()->UseIfExists("key1"));
    265   EXPECT_FALSE(GetEntryForTesting("key1", &metadata1));
    266   index()->Insert("key1");
    267   EXPECT_TRUE(index()->UseIfExists("key1"));
    268   EXPECT_TRUE(GetEntryForTesting("key1", &metadata1));
    269   WaitForTimeChange();
    270   EXPECT_TRUE(GetEntryForTesting("key1", &metadata2));
    271   EXPECT_EQ(metadata1.GetLastUsedTime(), metadata2.GetLastUsedTime());
    272   EXPECT_TRUE(index()->UseIfExists("key1"));
    273   EXPECT_TRUE(GetEntryForTesting("key1", &metadata2));
    274   EXPECT_LT(metadata1.GetLastUsedTime(), metadata2.GetLastUsedTime());
    275   index()->Remove("key1");
    276   EXPECT_TRUE(index()->UseIfExists("key1"));
    277 
    278   ReturnIndexFile();
    279 
    280   // Confirm "UseIfExists() returns conditionally now
    281   EXPECT_FALSE(index()->UseIfExists("key1"));
    282   EXPECT_FALSE(GetEntryForTesting("key1", &metadata1));
    283   index()->Insert("key1");
    284   EXPECT_TRUE(index()->UseIfExists("key1"));
    285   EXPECT_TRUE(GetEntryForTesting("key1", &metadata1));
    286   WaitForTimeChange();
    287   EXPECT_TRUE(GetEntryForTesting("key1", &metadata2));
    288   EXPECT_EQ(metadata1.GetLastUsedTime(), metadata2.GetLastUsedTime());
    289   EXPECT_TRUE(index()->UseIfExists("key1"));
    290   EXPECT_TRUE(GetEntryForTesting("key1", &metadata2));
    291   EXPECT_LT(metadata1.GetLastUsedTime(), metadata2.GetLastUsedTime());
    292   index()->Remove("key1");
    293   EXPECT_FALSE(index()->UseIfExists("key1"));
    294 }
    295 
    296 TEST_F(SimpleIndexTest, UpdateEntrySize) {
    297   base::Time now(base::Time::Now());
    298 
    299   index()->SetMaxSize(1000);
    300 
    301   InsertIntoIndexFileReturn("key1",
    302                             now - base::TimeDelta::FromDays(2),
    303                             475u);
    304   ReturnIndexFile();
    305 
    306   EntryMetadata metadata;
    307   EXPECT_TRUE(GetEntryForTesting("key1", &metadata));
    308   EXPECT_EQ(now - base::TimeDelta::FromDays(2), metadata.GetLastUsedTime());
    309   EXPECT_EQ(475u, metadata.GetEntrySize());
    310 
    311   index()->UpdateEntrySize("key1", 600u);
    312   EXPECT_TRUE(GetEntryForTesting("key1", &metadata));
    313   EXPECT_EQ(600u, metadata.GetEntrySize());
    314   EXPECT_EQ(1, index()->GetEntryCount());
    315 }
    316 
    317 TEST_F(SimpleIndexTest, GetEntryCount) {
    318   EXPECT_EQ(0, index()->GetEntryCount());
    319   index()->Insert("key1");
    320   EXPECT_EQ(1, index()->GetEntryCount());
    321   index()->Insert("key2");
    322   EXPECT_EQ(2, index()->GetEntryCount());
    323   index()->Insert("key3");
    324   EXPECT_EQ(3, index()->GetEntryCount());
    325   index()->Insert("key3");
    326   EXPECT_EQ(3, index()->GetEntryCount());
    327   index()->Remove("key2");
    328   EXPECT_EQ(2, index()->GetEntryCount());
    329   index()->Insert("key4");
    330   EXPECT_EQ(3, index()->GetEntryCount());
    331   index()->Remove("key3");
    332   EXPECT_EQ(2, index()->GetEntryCount());
    333   index()->Remove("key3");
    334   EXPECT_EQ(2, index()->GetEntryCount());
    335   index()->Remove("key1");
    336   EXPECT_EQ(1, index()->GetEntryCount());
    337   index()->Remove("key4");
    338   EXPECT_EQ(0, index()->GetEntryCount());
    339 }
    340 
    341 // Confirm that we get the results we expect from a simple init.
    342 TEST_F(SimpleIndexTest, BasicInit) {
    343   base::Time now(base::Time::Now());
    344 
    345   InsertIntoIndexFileReturn("key1",
    346                             now - base::TimeDelta::FromDays(2),
    347                             10u);
    348   InsertIntoIndexFileReturn("key2",
    349                             now - base::TimeDelta::FromDays(3),
    350                             100u);
    351 
    352   ReturnIndexFile();
    353 
    354   EntryMetadata metadata;
    355   EXPECT_TRUE(GetEntryForTesting("key1", &metadata));
    356   EXPECT_EQ(now - base::TimeDelta::FromDays(2), metadata.GetLastUsedTime());
    357   EXPECT_EQ(10ul, metadata.GetEntrySize());
    358   EXPECT_TRUE(GetEntryForTesting("key2", &metadata));
    359   EXPECT_EQ(now - base::TimeDelta::FromDays(3), metadata.GetLastUsedTime());
    360   EXPECT_EQ(100ul, metadata.GetEntrySize());
    361 }
    362 
    363 // Remove something that's going to come in from the loaded index.
    364 TEST_F(SimpleIndexTest, RemoveBeforeInit) {
    365   index()->Remove("key1");
    366 
    367   InsertIntoIndexFileReturn("key1",
    368                             base::Time::Now() - base::TimeDelta::FromDays(2),
    369                             10u);
    370   ReturnIndexFile();
    371 
    372   EXPECT_FALSE(index()->Has(kKey1Hash));
    373 }
    374 
    375 // Insert something that's going to come in from the loaded index; correct
    376 // result?
    377 TEST_F(SimpleIndexTest, InsertBeforeInit) {
    378   index()->Insert("key1");
    379 
    380   InsertIntoIndexFileReturn("key1",
    381                             base::Time::Now() - base::TimeDelta::FromDays(2),
    382                             10u);
    383   ReturnIndexFile();
    384 
    385   EntryMetadata metadata;
    386   EXPECT_TRUE(GetEntryForTesting("key1", &metadata));
    387   base::Time now(base::Time::Now());
    388   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
    389   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
    390   EXPECT_EQ(0ul, metadata.GetEntrySize());
    391 }
    392 
    393 // Insert and Remove something that's going to come in from the loaded index.
    394 TEST_F(SimpleIndexTest, InsertRemoveBeforeInit) {
    395   index()->Insert("key1");
    396   index()->Remove("key1");
    397 
    398   InsertIntoIndexFileReturn("key1",
    399                             base::Time::Now() - base::TimeDelta::FromDays(2),
    400                             10u);
    401   ReturnIndexFile();
    402 
    403   EXPECT_FALSE(index()->Has(kKey1Hash));
    404 }
    405 
    406 // Insert and Remove something that's going to come in from the loaded index.
    407 TEST_F(SimpleIndexTest, RemoveInsertBeforeInit) {
    408   index()->Remove("key1");
    409   index()->Insert("key1");
    410 
    411   InsertIntoIndexFileReturn("key1",
    412                             base::Time::Now() - base::TimeDelta::FromDays(2),
    413                             10u);
    414   ReturnIndexFile();
    415 
    416   EntryMetadata metadata;
    417   EXPECT_TRUE(GetEntryForTesting("key1", &metadata));
    418   base::Time now(base::Time::Now());
    419   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
    420   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
    421   EXPECT_EQ(0ul, metadata.GetEntrySize());
    422 }
    423 
    424 // Do all above tests at once + a non-conflict to test for cross-key
    425 // interactions.
    426 TEST_F(SimpleIndexTest, AllInitConflicts) {
    427   base::Time now(base::Time::Now());
    428 
    429   index()->Remove("key1");
    430   InsertIntoIndexFileReturn("key1",
    431                             now - base::TimeDelta::FromDays(2),
    432                             10u);
    433   index()->Insert("key2");
    434   InsertIntoIndexFileReturn("key2",
    435                             now - base::TimeDelta::FromDays(3),
    436                             100u);
    437   index()->Insert("key3");
    438   index()->Remove("key3");
    439   InsertIntoIndexFileReturn("key3",
    440                             now - base::TimeDelta::FromDays(4),
    441                             1000u);
    442   index()->Remove("key4");
    443   index()->Insert("key4");
    444   InsertIntoIndexFileReturn("key4",
    445                             now - base::TimeDelta::FromDays(5),
    446                             10000u);
    447   InsertIntoIndexFileReturn("key5",
    448                             now - base::TimeDelta::FromDays(6),
    449                             100000u);
    450 
    451   ReturnIndexFile();
    452 
    453   EXPECT_FALSE(index()->Has(kKey1Hash));
    454 
    455   EntryMetadata metadata;
    456   EXPECT_TRUE(GetEntryForTesting("key2", &metadata));
    457   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
    458   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
    459   EXPECT_EQ(0ul, metadata.GetEntrySize());
    460 
    461   EXPECT_FALSE(index()->Has(kKey3Hash));
    462 
    463   EXPECT_TRUE(GetEntryForTesting("key4", &metadata));
    464   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
    465   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), metadata.GetLastUsedTime());
    466   EXPECT_EQ(0ul, metadata.GetEntrySize());
    467 
    468   EXPECT_TRUE(GetEntryForTesting("key5", &metadata));
    469   EXPECT_EQ(now - base::TimeDelta::FromDays(6), metadata.GetLastUsedTime());
    470   EXPECT_EQ(100000u, metadata.GetEntrySize());
    471 }
    472 
    473 TEST_F(SimpleIndexTest, BasicEviction) {
    474   base::Time now(base::Time::Now());
    475   index()->SetMaxSize(1000);
    476   InsertIntoIndexFileReturn("key1",
    477                             now - base::TimeDelta::FromDays(2),
    478                             475u);
    479   index()->Insert("key2");
    480   index()->UpdateEntrySize("key2", 475);
    481   ReturnIndexFile();
    482 
    483   WaitForTimeChange();
    484 
    485   index()->Insert("key3");
    486   // Confirm index is as expected: No eviction, everything there.
    487   EXPECT_EQ(3, index()->GetEntryCount());
    488   EXPECT_EQ(0, index_file()->doom_entry_set_calls());
    489   EXPECT_TRUE(index()->Has(kKey1Hash));
    490   EXPECT_TRUE(index()->Has(kKey2Hash));
    491   EXPECT_TRUE(index()->Has(kKey3Hash));
    492 
    493   // Trigger an eviction, and make sure the right things are tossed.
    494   // TODO(rdsmith): This is dependent on the innards of the implementation
    495   // as to at exactly what point we trigger eviction.  Not sure how to fix
    496   // that.
    497   index()->UpdateEntrySize("key3", 475);
    498   EXPECT_EQ(1, index_file()->doom_entry_set_calls());
    499   EXPECT_EQ(1, index()->GetEntryCount());
    500   EXPECT_FALSE(index()->Has(kKey1Hash));
    501   EXPECT_FALSE(index()->Has(kKey2Hash));
    502   EXPECT_TRUE(index()->Has(kKey3Hash));
    503   ASSERT_EQ(2u, index_file_->last_doom_entry_hashes().size());
    504 }
    505 
    506 // Confirm all the operations queue a disk write at some point in the
    507 // future.
    508 TEST_F(SimpleIndexTest, DiskWriteQueued) {
    509   index()->SetMaxSize(1000);
    510   ReturnIndexFile();
    511 
    512   EXPECT_FALSE(index()->write_to_disk_timer_.IsRunning());
    513 
    514   index()->Insert("key1");
    515   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
    516   index()->write_to_disk_timer_.Stop();
    517   EXPECT_FALSE(index()->write_to_disk_timer_.IsRunning());
    518 
    519   index()->UseIfExists("key1");
    520   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
    521   index()->write_to_disk_timer_.Stop();
    522 
    523   index()->UpdateEntrySize("key1", 20);
    524   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
    525   index()->write_to_disk_timer_.Stop();
    526 
    527   index()->Remove("key1");
    528   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
    529   index()->write_to_disk_timer_.Stop();
    530 }
    531 
    532 TEST_F(SimpleIndexTest, DiskWriteExecuted) {
    533   index()->SetMaxSize(1000);
    534   ReturnIndexFile();
    535 
    536   EXPECT_FALSE(index()->write_to_disk_timer_.IsRunning());
    537 
    538   index()->Insert("key1");
    539   index()->UpdateEntrySize("key1", 20);
    540   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
    541   base::Closure user_task(index()->write_to_disk_timer_.user_task());
    542   index()->write_to_disk_timer_.Stop();
    543 
    544   EXPECT_EQ(0, index_file_->disk_writes());
    545   user_task.Run();
    546   EXPECT_EQ(1, index_file_->disk_writes());
    547   SimpleIndex::EntrySet entry_set;
    548   index_file_->GetAndResetDiskWriteEntrySet(&entry_set);
    549 
    550   uint64 hash_key(simple_util::GetEntryHashKey("key1"));
    551   base::Time now(base::Time::Now());
    552   ASSERT_EQ(1u, entry_set.size());
    553   EXPECT_EQ(hash_key, entry_set.begin()->first);
    554   const EntryMetadata& entry1(entry_set.begin()->second);
    555   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), entry1.GetLastUsedTime());
    556   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), entry1.GetLastUsedTime());
    557   EXPECT_EQ(20u, entry1.GetEntrySize());
    558 }
    559 
    560 TEST_F(SimpleIndexTest, DiskWritePostponed) {
    561   index()->SetMaxSize(1000);
    562   ReturnIndexFile();
    563 
    564   EXPECT_FALSE(index()->write_to_disk_timer_.IsRunning());
    565 
    566   index()->Insert("key1");
    567   index()->UpdateEntrySize("key1", 20);
    568   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
    569   base::TimeTicks expected_trigger(
    570       index()->write_to_disk_timer_.desired_run_time());
    571 
    572   WaitForTimeChange();
    573   EXPECT_EQ(expected_trigger, index()->write_to_disk_timer_.desired_run_time());
    574   index()->Insert("key2");
    575   index()->UpdateEntrySize("key2", 40);
    576   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
    577   EXPECT_LT(expected_trigger, index()->write_to_disk_timer_.desired_run_time());
    578   index()->write_to_disk_timer_.Stop();
    579 }
    580 
    581 }  // namespace disk_cache
    582