Track SimpleCache memory usage in net/ MemoryDumpProvider

net/http/http_cache.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 "net/http/http_cache.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "base/metrics/histogram_macros.h"
 #include "base/pickle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/default_clock.h"
 #include "base/time/time.h"
+#include "base/trace_event/memory_allocator_dump.h"
+#include "base/trace_event/memory_usage_estimator.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "net/base/cache_type.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/upload_data_stream.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/disk_cache_based_quic_server_info.h"
 #include "net/http/http_cache_transaction.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
@@ skipping 58 matching lines @@
       doomed(false) {
 }
 
 HttpCache::ActiveEntry::~ActiveEntry() {
   if (disk_entry) {
     disk_entry->Close();
     disk_entry = NULL;
   }
 }
 
+size_t HttpCache::ActiveEntry::EstimateMemoryUsage() const {
+  // Skip tracking |disk_entry| because that is tracked in simple_backend_impl.
+  return base::trace_event::EstimateMemoryUsage(readers) +
+         base::trace_event::EstimateMemoryUsage(pending_queue);

[jkarlin, 2017/02/23 15:14:57]

Sorry, I was wrong, this should return 0. readers and pending_queue transactions
are all owned by their respective jobs (e.g., URLRequestHttpJob) and should be
accounted for there.

[xunjieli, 2017/02/23 16:40:59]

Done. Got it. I will add those there when URLRequest*Jobs are tracked in the
MemoryDumpProvider.

+}
+
 //-----------------------------------------------------------------------------
 
 // This structure keeps track of work items that are attempting to create or
 // open cache entries or the backend itself.
 struct HttpCache::PendingOp {
   PendingOp() : disk_entry(NULL) {}
   ~PendingOp() {}
 
+  // Returns the estimate of dynamically allocated memory in bytes.
+  size_t EstimateMemoryUsage() const {
+    // |disk_entry| is tracked in |backend|.
+    return base::trace_event::EstimateMemoryUsage(backend) +
+           base::trace_event::EstimateMemoryUsage(writer) +
+           base::trace_event::EstimateMemoryUsage(pending_queue);
+  }
+
   disk_cache::Entry* disk_entry;
   std::unique_ptr<disk_cache::Backend> backend;
   std::unique_ptr<WorkItem> writer;
   CompletionCallback callback;  // BackendCallback.
   WorkItemList pending_queue;
 };
 
 //-----------------------------------------------------------------------------
 
 // The type of operation represented by a work item.
@@ skipping 45 matching lines @@
     return false;
   }
 
   WorkItemOperation operation() { return operation_; }
   void ClearTransaction() { trans_ = NULL; }
   void ClearEntry() { entry_ = NULL; }
   void ClearCallback() { callback_.Reset(); }
   bool Matches(Transaction* trans) const { return trans == trans_; }
   bool IsValid() const { return trans_ || entry_ || !callback_.is_null(); }
 
+  // Returns the estimate of dynamically allocated memory in bytes.
+  size_t EstimateMemoryUsage() const { return 0; }
+
  private:
   WorkItemOperation operation_;
   Transaction* trans_;
   ActiveEntry** entry_;
   CompletionCallback callback_;  // User callback.
   disk_cache::Backend** backend_;
 };
 
 //-----------------------------------------------------------------------------
 
@@ skipping 284 matching lines @@
 
 std::unique_ptr<HttpTransactionFactory>
 HttpCache::SetHttpNetworkTransactionFactoryForTesting(
     std::unique_ptr<HttpTransactionFactory> new_network_layer) {
   std::unique_ptr<HttpTransactionFactory> old_network_layer(
       std::move(network_layer_));
   network_layer_ = std::move(new_network_layer);
   return old_network_layer;
 }
 
+void HttpCache::DumpMemoryStats(base::trace_event::ProcessMemoryDump* pmd,
+                                const std::string& parent_absolute_name) const {
+  // Skip tracking members like |clock_| and |backend_factory_| because they
+  // don't allocate.
+  base::trace_event::MemoryAllocatorDump* dump =
+      pmd->CreateAllocatorDump(parent_absolute_name + "/http_cache");
+  dump->AddScalar(
+      base::trace_event::MemoryAllocatorDump::kNameSize,
+      base::trace_event::MemoryAllocatorDump::kUnitsBytes,
+      base::trace_event::EstimateMemoryUsage(disk_cache_) +
+          base::trace_event::EstimateMemoryUsage(active_entries_) +
+          base::trace_event::EstimateMemoryUsage(doomed_entries_) +
+          base::trace_event::EstimateMemoryUsage(playback_cache_map_) +
+          base::trace_event::EstimateMemoryUsage(pending_ops_));
+}
+
 //-----------------------------------------------------------------------------
 
 int HttpCache::CreateBackend(disk_cache::Backend** backend,
                              const CompletionCallback& callback) {
   if (!backend_factory_.get())
     return ERR_FAILED;
 
   building_backend_ = true;
 
   std::unique_ptr<WorkItem> item =
@@ skipping 660 matching lines @@
     building_backend_ = false;
     DeletePendingOp(pending_op);
   }
 
   // The cache may be gone when we return from the callback.
   if (!item->DoCallback(result, disk_cache_.get()))
     item->NotifyTransaction(result, NULL);
 }
 
 }  // namespace net