[WIP][tracing] Add memory dump provider for sync Directory

sync/syncable/parent_child_index.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 "sync/syncable/parent_child_index.h"
 
 #include "base/stl_util.h"
 
 #include "sync/syncable/entry_kernel.h"
 #include "sync/syncable/syncable_id.h"
 
 namespace syncer {
 namespace syncable {
 
+namespace {
+
+template <typename Key, typename Value>
+size_t GetRbTreeMemoryUsgae(size_t num_nodes) {
+  // 4 pointers are stored for value, left, right and parent nodes in most
+  // implementations.
+  return (sizeof(std::pair<Key, Value>) + 4 * sizeof(void*)) * num_nodes;
+}
+}
+
 bool ChildComparator::operator()(const EntryKernel* a,
                                  const EntryKernel* b) const {
   const UniquePosition& a_pos = a->ref(UNIQUE_POSITION);
   const UniquePosition& b_pos = b->ref(UNIQUE_POSITION);
 
   if (a_pos.IsValid() && b_pos.IsValid()) {
     // Position is important to this type.
     return a_pos.LessThan(b_pos);
   } else if (a_pos.IsValid() && !b_pos.IsValid()) {
     // TODO(rlarocque): Remove this case.
@@ skipping 161 matching lines @@
 }
 
 const OrderedChildSet* ParentChildIndex::GetSiblings(EntryKernel* e) const {
   // This implies the entry is in the index.
   DCHECK(Contains(e));
   const OrderedChildSet* siblings = GetChildSet(e);
   DCHECK(siblings && !siblings->empty());
   return siblings;
 }
 
+size_t ParentChildIndex::MemoryUsage() const {
+  size_t total = model_type_root_ids_.capacity() * sizeof(std::string) +
+                 sizeof(this) + type_root_child_sets_.size() * sizeof(void*);
+  for (const auto& id : model_type_root_ids_)
+    total += id.value().capacity() + 1;
+  total += GetRbTreeMemoryUsgae<Id, void*>(parent_children_map_.size());
+  for (const auto& entry : parent_children_map_)
+    total += entry.first.value().capacity() + 1;
+  for (const auto& child_set : type_root_child_sets_) {
+    if (child_set)
+      total += GetRbTreeMemoryUsgae<void*, void*>(child_set->size());
+  }
+  return total;
+}
+
 /* static */
 bool ParentChildIndex::ShouldUseParentId(const Id& parent_id,
                                          ModelType model_type) {
   // For compatibility with legacy unit tests, in addition to hierarchical
   // entries, this returns true any entries directly under root and for entries
   // of UNSPECIFIED model type.
   return parent_id.IsRoot() || TypeSupportsHierarchy(model_type) ||
          !syncer::IsRealDataType(model_type);
 }
 
@@ skipping 24 matching lines @@
     type_root_child_sets_[model_type] = new OrderedChildSet();
   return type_root_child_sets_[model_type];
 }
 
 const Id& ParentChildIndex::GetModelTypeRootId(ModelType model_type) const {
   return model_type_root_ids_[model_type];
 }
 
 }  // namespace syncable
 }  // namespace syncer