Implement in-memory byte hints in SimpleCache

net/disk_cache/backend_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdint.h>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 91 matching lines @@
   bool CreateSetOfRandomEntries(std::set<std::string>* key_pool);
   bool EnumerateAndMatchKeys(int max_to_open,
                              TestIterator* iter,
                              std::set<std::string>* keys_to_match,
                              size_t* count);
 
   // Computes the expected size of entry metadata, i.e. the total size without
   // the actual data stored. This depends only on the entry's |key| size.
   int GetEntryMetadataSize(std::string key);
 
+  // The Simple Backend only tracks the approximate sizes of entries. This
+  // rounds the exact size appropriately.
+  int GetRoundedSize(int exact_size);
+
   // Actual tests:
   void BackendBasics();
   void BackendKeying();
   void BackendShutdownWithPendingFileIO(bool fast);
   void BackendShutdownWithPendingIO(bool fast);
   void BackendShutdownWithPendingCreate(bool fast);
   void BackendShutdownWithPendingDoom();
   void BackendSetSize();
   void BackendLoad();
   void BackendChain();
@@ skipping 193 matching lines @@
   if (!simple_cache_mode_)
     return key.size();
 
   // For the simple cache, we must add the file header and EOF, and that for
   // every stream.
   return disk_cache::kSimpleEntryStreamCount *
          (sizeof(disk_cache::SimpleFileHeader) +
           sizeof(disk_cache::SimpleFileEOF) + key.size());
 }
 
+int DiskCacheBackendTest::GetRoundedSize(int exact_size) {
+  if (!simple_cache_mode_)
+    return exact_size;
+
+  return (exact_size + 255) & 0xFFFFFF00;
+}
+
 void DiskCacheBackendTest::BackendBasics() {
   InitCache();
   disk_cache::Entry *entry1 = NULL, *entry2 = NULL;
   EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
   ASSERT_THAT(CreateEntry("the first key", &entry1), IsOk());
   ASSERT_TRUE(NULL != entry1);
   entry1->Close();
   entry1 = NULL;
 
   ASSERT_THAT(OpenEntry("the first key", &entry1), IsOk());
@@ skipping 1667 matching lines @@
 
   // The cache is initially empty.
   EXPECT_EQ(0, CalculateSizeOfAllEntries());
 
   // Generate random entries and populate them with data of respective
   // sizes 0, 1, ..., count - 1 bytes.
   std::set<std::string> key_pool;
   CreateSetOfRandomEntries(&key_pool);
 
   int count = 0;
+  int total_size = 0;
   for (std::string key : key_pool) {
     std::string data(count, ' ');
     scoped_refptr<net::StringIOBuffer> buffer = new net::StringIOBuffer(data);
 
     // Alternate between writing to first two streams to test that we do not
     // take only one stream into account.
     disk_cache::Entry* entry;
     ASSERT_THAT(OpenEntry(key, &entry), IsOk());
     ASSERT_EQ(count, WriteData(entry, count % 2, 0, buffer.get(), count, true));
     entry->Close();
 
+    total_size += GetRoundedSize(count + GetEntryMetadataSize(key));
     ++count;
   }
 
-  // The resulting size should be (0 + 1 + ... + count - 1) plus keys.
   int result = CalculateSizeOfAllEntries();
-  int total_metadata_size = 0;
-  for (std::string key : key_pool)
-    total_metadata_size += GetEntryMetadataSize(key);
-  EXPECT_EQ((count - 1) * count / 2 + total_metadata_size, result);
+  EXPECT_EQ(total_size, result);
 
   // Add another entry and test if the size is updated. Then remove it and test
   // if the size is back to original value.
   {
     const int last_entry_size = 47;
     std::string data(last_entry_size, ' ');
     scoped_refptr<net::StringIOBuffer> buffer = new net::StringIOBuffer(data);
 
     disk_cache::Entry* entry;
     std::string key = GenerateKey(true);
     ASSERT_THAT(CreateEntry(key, &entry), IsOk());
     ASSERT_EQ(last_entry_size,
               WriteData(entry, 0, 0, buffer.get(), last_entry_size, true));
     entry->Close();
 
     int new_result = CalculateSizeOfAllEntries();
-    EXPECT_EQ(result + last_entry_size + GetEntryMetadataSize(key), new_result);
+    EXPECT_EQ(
+        result + GetRoundedSize(last_entry_size + GetEntryMetadataSize(key)),
+        new_result);
 
     DoomEntry(key);
     new_result = CalculateSizeOfAllEntries();
     EXPECT_EQ(result, new_result);
   }
 
   // After dooming the entries, the size should be back to zero.
   ASSERT_THAT(DoomAllEntries(), IsOk());
   EXPECT_EQ(0, CalculateSizeOfAllEntries());
 }
@@ skipping 33 matching lines @@
 
   ASSERT_THAT(CreateEntry("second", &entry), IsOk());
   entry->Close();
   ASSERT_THAT(CreateEntry("third_entry", &entry), IsOk());
   entry->Close();
   FlushQueueForTest();
 
   AddDelay();
   Time end = Time::Now();
 
-  int size_1 = GetEntryMetadataSize("first");
-  int size_2 = GetEntryMetadataSize("second");
-  int size_3 = GetEntryMetadataSize("third_entry");
+  int size_1 = GetRoundedSize(GetEntryMetadataSize("first"));
+  int size_2 = GetRoundedSize(GetEntryMetadataSize("second"));
+  int size_3 = GetRoundedSize(GetEntryMetadataSize("third_entry"));
 
   ASSERT_EQ(3, cache_->GetEntryCount());
   ASSERT_EQ(CalculateSizeOfAllEntries(),
             CalculateSizeOfEntriesBetween(base::Time(), base::Time::Max()));
 
   int start_end = CalculateSizeOfEntriesBetween(start, end);
   ASSERT_EQ(CalculateSizeOfAllEntries(), start_end);
   ASSERT_EQ(size_1 + size_2 + size_3, start_end);
 
   ASSERT_EQ(size_1, CalculateSizeOfEntriesBetween(start, middle));
@@ skipping 2093 matching lines @@
   disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
   base::RunLoop().RunUntilIdle();
 
   disk_cache::Entry* reopen_entry1;
   ASSERT_THAT(OpenEntry(key1, &reopen_entry1), IsOk());
 
   // This shouldn't pick up entry2's write time incorrectly.
   EXPECT_LE(reopen_entry1->GetLastModified(), entry1_timestamp);
   reopen_entry1->Close();
 }