[sync] Add model type counters to memory dumps.

components/sync/syncable/directory.cc

 // Copyright 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 "components/sync/syncable/directory.h"
 
 #include <inttypes.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 901 matching lines @@
 size_t Directory::GetEntriesCount() const {
   ScopedKernelLock lock(this);
   return kernel_->metahandles_map.size();
 }
 
 void Directory::OnMemoryDump(base::trace_event::ProcessMemoryDump* pmd) {
   std::string dump_name_base =
       base::StringPrintf("sync/0x%" PRIXPTR, reinterpret_cast<uintptr_t>(this));
 
   size_t kernel_memory_usage;
+  size_t model_type_entry_count[MODEL_TYPE_COUNT] = {0};
   {
     using base::trace_event::EstimateMemoryUsage;
 
     ReadTransaction trans(FROM_HERE, this);
     ScopedKernelLock lock(this);
     kernel_memory_usage =
         EstimateMemoryUsage(kernel_->name) +
         EstimateMemoryUsage(kernel_->metahandles_map) +
         EstimateMemoryUsage(kernel_->ids_map) +
         EstimateMemoryUsage(kernel_->server_tags_map) +
         EstimateMemoryUsage(kernel_->client_tags_map) +
         EstimateMemoryUsage(kernel_->parent_child_index) +
         EstimateMemoryUsage(kernel_->index_by_attachment_id) +
         EstimateMemoryUsage(kernel_->unapplied_update_metahandles) +
         EstimateMemoryUsage(kernel_->unsynced_metahandles) +
         EstimateMemoryUsage(kernel_->dirty_metahandles) +
         EstimateMemoryUsage(kernel_->metahandles_to_purge) +
         EstimateMemoryUsage(kernel_->persisted_info) +
         EstimateMemoryUsage(kernel_->cache_guid);
+
+    for (const auto& handle_and_kernel : kernel_->metahandles_map) {
+      const EntryKernel* kernel = handle_and_kernel.second.get();
+      // Counting logic from DirectoryBackingStore::LoadEntries()
+      ModelType model_type = kernel->GetModelType();
+      if (!IsRealDataType(model_type)) {
+        model_type = kernel->GetServerModelType();
+      }
+      ++model_type_entry_count[model_type];
+    }
+  }
+
+  // Similar to UploadModelTypeEntryCount()
+  for (size_t i = FIRST_REAL_MODEL_TYPE; i != MODEL_TYPE_COUNT; ++i) {
+    ModelType model_type = static_cast<ModelType>(i);
+    std::string notification_type;
+    if (RealModelTypeToNotificationType(model_type, &notification_type)) {
+      std::string dump_name =
+          base::StringPrintf("%s/model_type/%s", dump_name_base.c_str(),
+                             notification_type.c_str());
+      pmd->CreateAllocatorDump(dump_name)->AddScalar(
+          base::trace_event::MemoryAllocatorDump::kNameObjectCount,
+          base::trace_event::MemoryAllocatorDump::kUnitsObjects,
+          model_type_entry_count[i]);
+    }
   }
 
   {
     std::string dump_name =
         base::StringPrintf("%s/kernel", dump_name_base.c_str());
 
     auto* dump = pmd->CreateAllocatorDump(dump_name);
     dump->AddScalar(base::trace_event::MemoryAllocatorDump::kNameSize,
                     base::trace_event::MemoryAllocatorDump::kUnitsBytes,
                     kernel_memory_usage);
@@ skipping 656 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_;
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_;
 }
 
 }  // namespace syncable
 }  // namespace syncer