[Sync] Implement MemoryDumpProvider.

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>
@@ skipping 74 matching lines @@
 
 // std::unique_ptr
 
 template <class T, class D>
 size_t EstimateMemoryUsage(const std::unique_ptr<T, D>& ptr);
 
 template <class T, class D>
 size_t EstimateMemoryUsage(const std::unique_ptr<T[], D>& array,
                            size_t array_length);
 
+// std::shared_ptr
+
+template <class T>
+size_t EstimateMemoryUsage(const std::shared_ptr<T>& ptr);
+
 // Containers
 
 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);
@@ skipping 164 matching lines @@
 size_t EstimateMemoryUsage(const std::unique_ptr<T, D>& ptr) {
   return ptr ? (sizeof(T) + EstimateItemMemoryUsage(*ptr)) : 0;
 }
 
 template <class T, class D>
 size_t EstimateMemoryUsage(const std::unique_ptr<T[], D>& array,
                            size_t array_length) {
   return EstimateMemoryUsage(array.get(), array_length);
 }
 
+// std::shared_ptr
+
+template <class T>
+size_t EstimateMemoryUsage(const std::shared_ptr<T>& ptr) {
+  auto use_count = ptr.use_count();
+  if (use_count == 0) {
+    return 0;
+  }
+  // Model shared_ptr after libc++,
+  // see __shared_ptr_pointer from include/memory
+  struct SharedPointer {
+    void* vtbl;
+    long shared_owners;
+    long shared_weak_owners;
+    T* value;
+  };
+  // If object of size S shared N > S times we prefer to (potentially)
+  // overestimate than to return 0.
+  return sizeof(SharedPointer) +
+         (EstimateItemMemoryUsage(*ptr) + (use_count - 1)) / use_count;
+}
+
 // std::pair
 
 template <class F, class S>
 size_t EstimateMemoryUsage(const std::pair<F, S>& pair) {
   return EstimateItemMemoryUsage(pair.first) +
          EstimateItemMemoryUsage(pair.second);
 }
 
 // std::vector
 
@@ skipping 120 matching lines @@
       typename std::unordered_multimap<K, V, H, KE, A>::value_type;
   return EstimateHashMapMemoryUsage<value_type>(map.bucket_count(),
                                                 map.size()) +
          EstimateIterableMemoryUsage(map);
 }
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_USAGE_ESTIMATOR_H_