[Sync] Record sync memory usage in histogram broken by datatypes

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 969 matching lines @@
     }
   }
 
   if (store_) {
     std::string dump_name =
         base::StringPrintf("%s/store", dump_name_base.c_str());
     store_->ReportMemoryUsage(pmd, dump_name);
   }
 }
 
+// Iterates over entries of |map|, summs memory usage estimate of entries whose

[Patrick Noland, 2017/06/19 23:34:52]

[nit] sums

[pavely, 2017/06/19 23:53:37]

Done.

+// entry type is |model_type|. Passing owning container will also include memory
+// estimate of EntryKernel.
+template <typename Container>
+size_t EstimateFiteredMapMemoryUsage(const Container& map,
+                                     ModelType model_type) {
+  using base::trace_event::EstimateMemoryUsage;
+  size_t memory_usage = 0;
+  for (const auto& kv : map) {
+    const ModelType entry_type =
+        GetModelTypeFromSpecifics(kv.second->ref(SPECIFICS));
+    if (entry_type == model_type) {
+      memory_usage += EstimateMemoryUsage(kv);
+    }
+  }
+  return memory_usage;
+}
+
+size_t Directory::EstimateMemoryUsageByType(ModelType model_type) {
+  using base::trace_event::EstimateMemoryUsage;
+  ReadTransaction trans(FROM_HERE, this);
+  ScopedKernelLock lock(this);
+
+  size_t memory_usage = 0;
+  memory_usage +=
+      EstimateFiteredMapMemoryUsage(kernel_->metahandles_map, model_type);
+  memory_usage += EstimateFiteredMapMemoryUsage(kernel_->ids_map, model_type);
+  memory_usage +=
+      EstimateFiteredMapMemoryUsage(kernel_->server_tags_map, model_type);
+  memory_usage +=
+      EstimateFiteredMapMemoryUsage(kernel_->client_tags_map, model_type);
+  memory_usage += EstimateMemoryUsage(
+      kernel_->persisted_info.download_progress[model_type]);
+  return memory_usage;
+}
+
 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 167 matching lines @@
                                      std::vector<int64_t>* result) {
   ScopedKernelLock lock(this);
   GetMetaHandlesOfType(lock, trans, type, result);
 }
 
 void Directory::GetMetaHandlesOfType(const ScopedKernelLock& lock,
                                      BaseTransaction* trans,
                                      ModelType type,
                                      std::vector<int64_t>* result) {
   result->clear();
-  for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
-       it != kernel_->metahandles_map.end(); ++it) {
-    EntryKernel* entry = it->second.get();
+  for (const auto& handle_and_kernel : kernel_->metahandles_map) {
+    EntryKernel* entry = handle_and_kernel.second.get();
     const ModelType entry_type =
         GetModelTypeFromSpecifics(entry->ref(SPECIFICS));
     if (entry_type == type)
-      result->push_back(it->first);
+      result->push_back(handle_and_kernel.first);
   }
 }
 
 void Directory::CollectMetaHandleCounts(
     std::vector<int>* num_entries_by_type,
     std::vector<int>* num_to_delete_entries_by_type) {
   syncable::ReadTransaction trans(FROM_HERE, this);
   ScopedKernelLock lock(this);
 
   for (MetahandlesMap::iterator it = kernel_->metahandles_map.begin();
@@ skipping 437 matching lines @@
 Directory::Kernel* Directory::kernel() {
   return kernel_.get();
 }
 
 const Directory::Kernel* Directory::kernel() const {
   return kernel_.get();
 }
 
 }  // namespace syncable
 }  // namespace syncer