Track SimpleCache memory usage in net/ MemoryDumpProvider

net/disk_cache/simple/simple_backend_impl.h

 // 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.
 
 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 13 matching lines @@
 #include "net/base/cache_type.h"
 #include "net/base/net_export.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/simple/simple_entry_impl.h"
 #include "net/disk_cache/simple/simple_experiment.h"
 #include "net/disk_cache/simple/simple_index_delegate.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 class TaskRunner;
+namespace trace_event {
+class ProcessMemoryDump;
+}
 }
 
 namespace disk_cache {
 
 // SimpleBackendImpl is a new cache backend that stores entries in individual
 // files.
 // See http://www.chromium.org/developers/design-documents/network-stack/disk-cache/very-simple-backend
 //
 // The SimpleBackendImpl provides safe iteration; mutating entries during
 // iteration cannot cause a crash. It is undefined whether entries created or
@@ skipping 66 matching lines @@
   int DoomEntriesSince(base::Time initial_time,
                        const CompletionCallback& callback) override;
   int CalculateSizeOfAllEntries(const CompletionCallback& callback) override;
   int CalculateSizeOfEntriesBetween(
       base::Time initial_time,
       base::Time end_time,
       const CompletionCallback& callback) override;
   std::unique_ptr<Iterator> CreateIterator() override;
   void GetStats(base::StringPairs* stats) override;
   void OnExternalCacheHit(const std::string& key) override;
+  void DumpMemoryStats(base::trace_event::ProcessMemoryDump* pmd,
+                       const std::string& parent_absolute_name) const override;

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

Do we have stats about how often we use the blockfile or mem_backend
implementation of the Backend? Is it the case that most of the time we use
SimpleCache and most of the memory usage is from EntryMetaData and we would not
have to care about the others? If not, we should make this pure and add TODO in
the classes that says implement this later.

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

We are moving towards using SimpleCache everywhere.  It's currently being used
on Android and Linux by default.  That's what show up in traces that I obtained
from Linux and Android. I don't think we care about the others, but I will add a
TODO to investigate.

 
  private:
   class SimpleIterator;
   friend class SimpleIterator;
 
   using EntryMap = std::unordered_map<uint64_t, SimpleEntryImpl*>;
 
   using InitializeIndexCallback =
       base::Callback<void(base::Time mtime, uint64_t max_size, int result)>;
 
@@ skipping 97 matching lines @@
   // operations to be run at the completion of the Doom.
   std::unordered_map<uint64_t, std::vector<base::Closure>>
       entries_pending_doom_;
 
   net::NetLog* const net_log_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_