Track SimpleCache memory usage in net/ MemoryDumpProvider

net/disk_cache/simple/simple_backend_impl.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_backend_impl.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <functional>
 #include <limits>
@@ skipping 12 matching lines @@
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "base/trace_event/memory_usage_estimator.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_entry_impl.h"
 #include "net/disk_cache/simple/simple_experiment.h"
 #include "net/disk_cache/simple/simple_histogram_macros.h"
 #include "net/disk_cache/simple/simple_index.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"
@@ skipping 154 matching lines @@
   if (result == net::OK) {
     SIMPLE_CACHE_UMA(TIMES, "CreationToIndex", cache_type, creation_to_index);
   } else {
     SIMPLE_CACHE_UMA(TIMES,
                      "CreationToIndexFail", cache_type, creation_to_index);
   }
 }
 
 }  // namespace
 
+// Static function which is called by base::trace_event::EstimateMemoryUsage()
+// to estimate the memory of SimpleEntryImpl* type.
+// This needs to be in disk_cache namespace.
+size_t EstimateMemoryUsage(const SimpleEntryImpl* const& entry_impl) {

[jkarlin, 2017/02/24 18:38:09]

Have you verified that this actually gets called? I don't see it defined in the
header.

I think we need more tests to verify that everything is actually being counted.

[xunjieli, 2017/02/24 18:42:17]

I verified manually that this is called. (build chrome locally and get a trace
from chrome://tracing). The unit test (backend_unittest.cc) also enters this
code, but I am not sure what's the best way to write a stricter test expectation
(rather than using LT(0, EMU()).

+  return sizeof(SimpleEntryImpl) + entry_impl->EstimateMemoryUsage();
+}
+
 class SimpleBackendImpl::ActiveEntryProxy
     : public SimpleEntryImpl::ActiveEntryProxy {
  public:
   ~ActiveEntryProxy() override {
     if (backend_) {
       DCHECK_EQ(1U, backend_->active_entries_.count(entry_hash_));
       backend_->active_entries_.erase(entry_hash_);
     }
   }
 
@@ skipping 328 matching lines @@
   std::pair<std::string, std::string> item;
   item.first = "Cache type";
   item.second = "Simple Cache";
   stats->push_back(item);
 }
 
 void SimpleBackendImpl::OnExternalCacheHit(const std::string& key) {
   index_->UseIfExists(simple_util::GetEntryHashKey(key));
 }
 
+size_t SimpleBackendImpl::EstimateMemoryUsage() const {
+  // TODO(xunjieli): crbug.com/669108. Track |entries_pending_doom_| once
+  // base::Closure is suppported in memory_usage_estimator.h.
+  return base::trace_event::EstimateMemoryUsage(index_) +
+         base::trace_event::EstimateMemoryUsage(active_entries_);
+}
+
 void SimpleBackendImpl::InitializeIndex(const CompletionCallback& callback,
                                         const DiskStatResult& result) {
   if (result.net_error == net::OK) {
     index_->SetMaxSize(result.max_size);
     index_->Initialize(result.cache_dir_mtime);
   }
   callback.Run(result.net_error);
 }
 
 void SimpleBackendImpl::IndexReadyForDoom(Time initial_time,
@@ skipping 182 matching lines @@
 }
 
 // static
 void SimpleBackendImpl::FlushWorkerPoolForTesting() {
   // We only need to do this if we there is an active task runner.
   if (base::ThreadTaskRunnerHandle::IsSet())
     g_sequenced_worker_pool.Get().FlushForTesting();
 }
 
 }  // namespace disk_cache