Track SimpleCache memory usage in net/ MemoryDumpProvider

net/disk_cache/simple/simple_entry_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_entry_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.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/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/net_log_parameters.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 #include "net/disk_cache/simple/simple_histogram_macros.h"
 #include "net/disk_cache/simple/simple_index.h"
 #include "net/disk_cache/simple/simple_net_log_parameters.h"
 #include "net/disk_cache/simple/simple_synchronous_entry.h"
 #include "net/disk_cache/simple/simple_util.h"
 #include "net/log/net_log.h"
@@ skipping 109 matching lines @@
   completion_callback.Run(result);
 }
 
 }  // namespace
 
 using base::Closure;
 using base::FilePath;
 using base::Time;
 using base::TaskRunner;
 
+// Static function called by base::trace_event::EstimateMemoryUsage() to
+// estimate the memory of SimpleEntryOperation.
+// This needs to be in disk_cache namespace.
+size_t EstimateMemoryUsage(const SimpleEntryOperation& op) {
+  return 0;
+}
+
 // A helper class to insure that RunNextOperationIfNeeded() is called when
 // exiting the current stack frame.
 class SimpleEntryImpl::ScopedOperationRunner {
  public:
   explicit ScopedOperationRunner(SimpleEntryImpl* entry) : entry_(entry) {
   }
 
   ~ScopedOperationRunner() {
     entry_->RunNextOperationIfNeeded();
   }
@@ skipping 374 matching lines @@
 }
 
 int SimpleEntryImpl::ReadyForSparseIO(const CompletionCallback& callback) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   // The simple Cache does not return distinct objects for the same non-doomed
   // entry, so there's no need to coordinate which object is performing sparse
   // I/O.  Therefore, CancelSparseIO and ReadyForSparseIO succeed instantly.
   return net::OK;
 }
 
+size_t SimpleEntryImpl::EstimateMemoryUsage() const {
+  return base::trace_event::EstimateMemoryUsage(pending_operations_) +
+         base::trace_event::EstimateMemoryUsage(executing_operation_) +
+         (stream_0_data_ ? stream_0_data_->capacity() : 0);

[jkarlin, 2017/02/21 16:23:29]

We're missing synchronous_entry_. That's difficult to capture because it lives
on multiple threads, but it could be large.

Perhaps you could include just the sizeof(synchronous_entry_) and comment that
it would be good to have the rest?

[xunjieli, 2017/02/21 19:44:14]

Done. I used sizeof(SimpleSynchronousEntry) because sizeof(synchronous_entry_)
is the sizeof the pointer.

+}
+
 SimpleEntryImpl::~SimpleEntryImpl() {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(0U, pending_operations_.size());
   DCHECK(state_ == STATE_UNINITIALIZED || state_ == STATE_FAILURE);
   DCHECK(!synchronous_entry_);
   net_log_.EndEvent(net::NetLogEventType::SIMPLE_CACHE_ENTRY);
 }
 
 void SimpleEntryImpl::PostClientCallback(const CompletionCallback& callback,
                                          int result) {
@@ skipping 989 matching lines @@
     }
     crc32s_end_offset_[stream_index] = offset + length;
   } else if (offset < crc32s_end_offset_[stream_index]) {
     // If a range for which the crc32 was already computed is rewritten, the
     // computation of the crc32 need to start from 0 again.
     crc32s_end_offset_[stream_index] = 0;
   }
 }
 
 }  // namespace disk_cache