Leak reports collect information about the memory usage

chrome/browser/metrics/leak_detector/leak_detector_controller.cc

 // 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.
 
 #include "chrome/browser/metrics/leak_detector/leak_detector_controller.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
+#include "base/memory/weak_ptr.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/sys_info.h"
 #include "components/metrics/leak_detector/gnu_build_id_reader.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace metrics {
 
 namespace {
 
 using ParamsMap = std::map<std::string, std::string>;
 
@@ skipping 116 matching lines @@
   }
   iter = params.find(kMaxRendererProcessesEnabledParam);
   if (iter == params.end() ||
       !base::StringToInt(iter->second, max_renderer_processes_enabled)) {
     *max_renderer_processes_enabled = kDefaultNumProcessesEnabled;
   }
 }
 
 }  // namespace
 
+LeakDetectorController::TotalMemoryGrowthTracker::TotalMemoryGrowthTracker()

[Alexei Svitkine (slow), 2016/10/11 16:47:47]

Nit: Order these same as in the .h file in relation to methods of the outer
class.

[mwlodar, 2016/10/12 21:50:51]

Done.

+    : total_usage_kb_(0) {
+}
+
+LeakDetectorController::TotalMemoryGrowthTracker::~TotalMemoryGrowthTracker() {
+}
+
+bool LeakDetectorController::TotalMemoryGrowthTracker::UpdateSample(
+    base::ProcessId pid, int sample, int* diff) {
+  total_usage_kb_ += sample;
+  return false;
+}
+
 LeakDetectorController::LeakDetectorController()
     : params_(GetLeakDetectorParams()),
       browser_process_enable_probability_(0),
       renderer_process_enable_probability_(0),
       max_renderer_processes_with_leak_detector_enabled_(0),
-      num_renderer_processes_with_leak_detector_enabled_(0) {
+      num_renderer_processes_with_leak_detector_enabled_(0),
+      enable_collect_memory_usage_step_(true),
+      waiting_for_collect_memory_usage_step_(false),
+      weak_ptr_factory_(this) {
   // Read the build ID once and store it.
   leak_detector::gnu_build_id_reader::ReadBuildID(&build_id_);
 
   GetLeakDetectorEnableParams(
       &browser_process_enable_probability_,
       &renderer_process_enable_probability_,
       &max_renderer_processes_with_leak_detector_enabled_);
 
   // Register the LeakDetectorController with the remote controller, so this
   // class can send/receive data to/from remote processes.
@@ skipping 50 matching lines @@
   --num_renderer_processes_with_leak_detector_enabled_;
 }
 
 bool LeakDetectorController::ShouldRandomlyEnableLeakDetectorOnRendererProcess()
     const {
   return base::RandDouble() < renderer_process_enable_probability_ &&
          num_renderer_processes_with_leak_detector_enabled_ <
              max_renderer_processes_with_leak_detector_enabled_;
 }
 
+void LeakDetectorController::OnMemoryDetailCollectionDone(size_t index) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(waiting_for_collect_memory_usage_step_);
+  waiting_for_collect_memory_usage_step_ = false;
+
+  // The available physical memory must be translated from bytes
+  // and the total memory usage must be translated from kb.
+  MemoryLeakReportProto::MemoryUsageInfo mem_info;
+  mem_info.set_available_ram_mb(
+      base::SysInfo::AmountOfAvailablePhysicalMemory() / 1024 / 1024);
+  mem_info.set_chrome_ram_usage_mb(
+      total_memory_growth_tracker_.total_usage_kb() / 1024);
+
+  // Update all reports that arrived in the meantime.
+  for (; index < stored_reports_.size(); index++) {
+    stored_reports_[index].mutable_memory_usage_info()->CopyFrom(mem_info);
+  }
+}
+
 void LeakDetectorController::StoreLeakReports(
     const std::vector<MemoryLeakReportProto>& reports,
     MemoryLeakReportProto::ProcessType process_type) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  // Postpone a task of collecting info about the memory usage.
+  // When the task is done, all reports collected after this point
+  // will be updated, unless GetLeakReports() gets called first.
+  if (enable_collect_memory_usage_step_ &&
+      !waiting_for_collect_memory_usage_step_) {
+    waiting_for_collect_memory_usage_step_ = true;
+
+    total_memory_growth_tracker_.reset();
+
+    // Idea of using MetricsMemoryDetails is the same as in
+    // ChromeMetricsServiceClient. As a side effect, the histogram
+    // data is generated.

[Alexei Svitkine (slow), 2016/10/11 16:47:48]

I don't think we want this to be the case. The metrics are currently logged only
once per UMA log, but this will change things, which will be confusing. Can you
implement a mechanism to suppress logging the metrics when the class is used for
your use case?

[mwlodar, 2016/10/11 20:08:09]

I can, however I would have to modify the interface of MetricsMemoryDetails. One
solution is to add a flag |generate_histograms_| that would be true on default
and add a new constructor to set it. What do you think?

[mwlodar, 2016/10/12 21:50:51]

Done.

+    base::Closure callback = base::Bind(
+        &LeakDetectorController::OnMemoryDetailCollectionDone,
+        weak_ptr_factory_.GetWeakPtr(), stored_reports_.size());
+
+    scoped_refptr<MetricsMemoryDetails> details(
+        new MetricsMemoryDetails(callback, &total_memory_growth_tracker_));
+    details->StartFetch();
+  }
+
   for (const auto& report : reports) {
     // Store the report and insert stored parameters.
     stored_reports_.push_back(report);
     stored_reports_.back().mutable_params()->CopyFrom(params_);
     stored_reports_.back().set_source_process(process_type);
     stored_reports_.back().mutable_build_id()->assign(build_id_.begin(),
                                                       build_id_.end());
   }
 }
 
 }  // namespace metrics