Sync MDP: implement MemoryDumpProvider

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
+#include "base/trace_event/memory_dump_manager.h"
+#include "base/trace_event/memory_usage_estimators.h"
+#include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "components/sync/base/attachment_id_proto.h"
 #include "components/sync/base/unique_position.h"
 #include "components/sync/base/unrecoverable_error_handler.h"
+#include "components/sync/protocol/proto_size_estimations.h"
 #include "components/sync/syncable/entry.h"
 #include "components/sync/syncable/entry_kernel.h"
 #include "components/sync/syncable/in_memory_directory_backing_store.h"
 #include "components/sync/syncable/model_neutral_mutable_entry.h"
 #include "components/sync/syncable/on_disk_directory_backing_store.h"
 #include "components/sync/syncable/scoped_kernel_lock.h"
 #include "components/sync/syncable/scoped_parent_child_index_updater.h"
 #include "components/sync/syncable/syncable_base_transaction.h"
 #include "components/sync/syncable/syncable_changes_version.h"
 #include "components/sync/syncable/syncable_read_transaction.h"
@@ skipping 31 matching lines @@
   download_progress[model_type].set_token("");
 }
 
 bool Directory::PersistedKernelInfo::HasEmptyDownloadProgress(
     ModelType model_type) {
   const sync_pb::DataTypeProgressMarker& progress_marker =
       download_progress[model_type];
   return progress_marker.token().empty();
 }
 
+size_t Directory::PersistedKernelInfo::EstimateMemoryUsage() const {
+  using base::trace_event::EstimateMemoryUsage;
+  return EstimateMemoryUsage(store_birthday) +
+         EstimateMemoryUsage(bag_of_chips) +
+         EstimateMemoryUsage(datatype_context);
+
+}
+
 Directory::SaveChangesSnapshot::SaveChangesSnapshot()
     : kernel_info_status(KERNEL_SHARE_INFO_INVALID) {}
 
 Directory::SaveChangesSnapshot::~SaveChangesSnapshot() {}
 
 bool Directory::SaveChangesSnapshot::HasUnsavedMetahandleChanges() const {
   return !dirty_metas.empty() || !metahandles_to_purge.empty() ||
          !delete_journals.empty() || !delete_journals_to_purge.empty();
 }
 
@@ skipping 798 matching lines @@
   ScopedKernelLock lock(this);
   kernel_->persisted_info.download_progress[model_type].SerializeToString(
       value_out);
 }
 
 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;
+  {
+    using base::trace_event::EstimateMemoryUsage;
+
+    ScopedKernelLock lock(this); // TODO(dskiba): is this the correct lock?
+    kernel_memory_usage =
+        EstimateMemoryUsage(kernel_->name) +
+        EstimateMemoryUsage(kernel_->metahandles_map) +
+        EstimateMemoryUsage(kernel_->ids_map) +
+        EstimateMemoryUsage(kernel_->server_tags_map) +
+        EstimateMemoryUsage(kernel_->client_tags_map) +
+        // TODO(dskiba): 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_->info_status) +
+        EstimateMemoryUsage(kernel_->persisted_info) +
+        EstimateMemoryUsage(kernel_->cache_guid);
+  }
+
+  {
+    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);
+    const char* system_allocator_name =
+        base::trace_event::MemoryDumpManager::GetInstance()
+            ->system_allocator_pool_name();
+    if (system_allocator_name) {
+      pmd->AddSuballocation(dump->guid(), system_allocator_name);
+    }
+  }
+
+  if (store_) {
+    std::string dump_name = base::StringPrintf(
+        "%s/store", dump_name_base.c_str());
+    auto* dump = pmd->CreateAllocatorDump(dump_name);
+    store_->ReportMemoryUsage(dump);
+  }
+}
+
 void Directory::SetDownloadProgress(
     ModelType model_type,
     const sync_pb::DataTypeProgressMarker& new_progress) {
   ScopedKernelLock lock(this);
   kernel_->persisted_info.download_progress[model_type].CopyFrom(new_progress);
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 }
 
 bool Directory::HasEmptyDownloadProgress(ModelType type) const {
   ScopedKernelLock lock(this);
@@ skipping 631 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_;
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_;
 }
 
 }  // namespace syncable
 }  // namespace syncer