Implement a method to get the total size of a cache entry

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/metrics/field_trial.h"
@@ skipping 1787 matching lines @@
 void DiskCacheBackendTest::BackendCalculateSizeOfAllEntries() {
   InitCache();
 
   // 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);
+  // Keep track of the sum of the individual entry sizes and check that it is
+  // consistent with CalculateSizeOfAllEntries().
+  int64_t sum_entry_size = 0;
 
   int count = 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));
+    sum_entry_size += entry->GetEntrySize();
     entry->Close();
 
     ++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(sum_entry_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));
+    ASSERT_EQ(last_entry_size + GetEntryMetadataSize(key),
+              entry->GetEntrySize());
     entry->Close();
 
     int new_result = CalculateSizeOfAllEntries();
     EXPECT_EQ(result + last_entry_size + GetEntryMetadataSize(key), new_result);
 
     DoomEntry(key);
     new_result = CalculateSizeOfAllEntries();
     EXPECT_EQ(result, new_result);
+    EXPECT_EQ(sum_entry_size, new_result);
   }
 
   // After dooming the entries, the size should be back to zero.
   ASSERT_THAT(DoomAllEntries(), IsOk());
   EXPECT_EQ(0, CalculateSizeOfAllEntries());
 }
 
 TEST_F(DiskCacheBackendTest, CalculateSizeOfAllEntries) {
   BackendCalculateSizeOfAllEntries();
 }
@@ skipping 1995 matching lines @@
   // because that would advance the cache directory mtime and invalidate the
   // index.
   entry2->Doom();
   entry2->Close();
 
   DisableFirstCleanup();
   InitCache();
   EXPECT_EQ(disk_cache::SimpleIndex::INITIALIZE_METHOD_LOADED,
             simple_cache_impl_->index()->init_method());
 }