Track SimpleCache memory usage in net/ MemoryDumpProvider

net/disk_cache/simple/simple_index.cc

 // Copyright (c) 2013 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 "net/disk_cache/simple/simple_index.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/pickle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/task_runner.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
+#include "base/trace_event/memory_usage_estimator.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_histogram_macros.h"
 #include "net/disk_cache/simple/simple_index_delegate.h"
 #include "net/disk_cache/simple/simple_index_file.h"
 #include "net/disk_cache/simple/simple_synchronous_entry.h"
 #include "net/disk_cache/simple/simple_util.h"
 
 #if defined(OS_POSIX)
 #include <sys/stat.h>
@@ skipping 96 matching lines @@
   int64_t tmp_last_used_time;
   uint64_t tmp_entry_size;
   if (!it->ReadInt64(&tmp_last_used_time) || !it->ReadUInt64(&tmp_entry_size) ||
       tmp_entry_size > std::numeric_limits<decltype(entry_size_)>::max())
     return false;
   SetLastUsedTime(base::Time::FromInternalValue(tmp_last_used_time));
   entry_size_ = static_cast<uint32_t>(tmp_entry_size);
   return true;
 }
 
+size_t EntryMetadata::EstimateMemoryUsage() const {
+  return 0;
+}
+
 SimpleIndex::SimpleIndex(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread,
     SimpleIndexDelegate* delegate,
     net::CacheType cache_type,
     std::unique_ptr<SimpleIndexFile> index_file)
     : delegate_(delegate),
       cache_type_(cache_type),
       cache_size_(0),
       max_size_(0),
       high_watermark_(0),
@@ skipping 109 matching lines @@
   uint64_t size = 0;
   for (const auto& entry : entries_set_) {
     const EntryMetadata& metadata = entry.second;
     base::Time entry_time = metadata.GetLastUsedTime();
     if (initial_time <= entry_time && entry_time < end_time)
       size += metadata.GetEntrySize();
   }
   return size;
 }
 
+size_t SimpleIndex::EstimateMemoryUsage() const {
+  return base::trace_event::EstimateMemoryUsage(entries_set_);

[ssid, 2017/01/31 22:24:19]

Do we need a todo here for other objects here, like removed_entries_ and
index_file_?
Or is it not required if the memory usage is not significant?

[xunjieli, 2017/02/01 01:15:52]

I added |removed_entries_|. SimpleIndexFile doesn't hold on to allocations much.
It's a bunch of static functions.  

+}
+
 void SimpleIndex::Insert(uint64_t entry_hash) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   // Upon insert we don't know yet the size of the entry.
   // It will be updated later when the SimpleEntryImpl finishes opening or
   // creating the new entry, and then UpdateEntrySize will be called.
   InsertInEntrySet(entry_hash, EntryMetadata(base::Time::Now(), 0u),
                    &entries_set_);
   if (!initialized_)
     removed_entries_.erase(entry_hash);
   PostponeWritingToDisk();
@@ skipping 237 matching lines @@
                        start - last_write_to_disk_);
     }
   }
   last_write_to_disk_ = start;
 
   index_file_->WriteToDisk(reason, entries_set_, cache_size_, start,
                            app_on_background_, base::Closure());
 }
 
 }  // namespace disk_cache