Keep track of byte usage of the memory cache backend

base/trace_event/memory_usage_estimator.h

 // Copyright 2016 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 BASE_TRACE_EVENT_MEMORY_USAGE_ESTIMATOR_H_
 #define BASE_TRACE_EVENT_MEMORY_USAGE_ESTIMATOR_H_
 
 #include <stdint.h>
 
 #include <array>
 #include <deque>
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
 #include <set>
 #include <stack>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "base/base_export.h"
+#include "base/containers/linked_list.h"
 #include "base/strings/string16.h"
 #include "base/template_util.h"
 
 // Composable memory usage estimators.
 //
 // This file defines set of EstimateMemoryUsage(object) functions that return
 // approximate memory usage of their argument.
 //
 // The ultimate goal is to make memory usage estimation for a class simply a
 // matter of aggregating EstimateMemoryUsage() results over all fields.
@@ skipping 69 matching lines @@
 
 template <class F, class S>
 size_t EstimateMemoryUsage(const std::pair<F, S>& pair);
 
 template <class T, class A>
 size_t EstimateMemoryUsage(const std::vector<T, A>& vector);
 
 template <class T, class A>
 size_t EstimateMemoryUsage(const std::list<T, A>& list);
 
+template <class T>
+size_t EstimateMemoryUsage(const base::LinkedList<T>& list);
+
 template <class T, class C, class A>
 size_t EstimateMemoryUsage(const std::set<T, C, A>& set);
 
 template <class T, class C, class A>
 size_t EstimateMemoryUsage(const std::multiset<T, C, A>& set);
 
 template <class K, class V, class C, class A>
 size_t EstimateMemoryUsage(const std::map<K, V, C, A>& map);
 
 template <class K, class V, class C, class A>
@@ skipping 221 matching lines @@
   using value_type = typename std::list<T, A>::value_type;
   struct Node {
     Node* prev;
     Node* next;
     value_type value;
   };
   return sizeof(Node) * list.size() +
          EstimateIterableMemoryUsage(list);
 }
 
+template <class T>
+size_t EstimateMemoryUsage(const base::LinkedList<T>& list) {
+  size_t memory_usage = 0u;
+  for (base::LinkNode<T>* node = list.head(); node != list.end();
+       node = node->next()) {
+    // Since we increment by calling node = node->next() we know that node
+    // isn't nullptr.
+    memory_usage += EstimateMemoryUsage(*node->value()) + sizeof(T);
+  }
+  return memory_usage;
+}
+
 // Tree containers
 
 template <class V>
 size_t EstimateTreeMemoryUsage(size_t size) {
   // Tree containers are modeled after libc++
   // (__tree_node from include/__tree)
   struct Node {
     Node* left;
     Node* right;
     Node* parent;
@@ skipping 159 matching lines @@
 
 template <class T, class C>
 size_t EstimateMemoryUsage(const std::stack<T, C>& stack) {
   return EstimateMemoryUsage(internal::GetUnderlyingContainer(stack));
 }
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_USAGE_ESTIMATOR_H_