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 121 matching lines @@
   }
 }
 
 }  // namespace
 
 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 43 matching lines @@
 void LeakDetectorController::SendLeakReports(
     const std::vector<MemoryLeakReportProto>& reports) {
   StoreLeakReports(reports, MemoryLeakReportProto::RENDERER_PROCESS);
 }
 
 void LeakDetectorController::OnRemoteProcessShutdown() {
   DCHECK_GT(num_renderer_processes_with_leak_detector_enabled_, 0);
   --num_renderer_processes_with_leak_detector_enabled_;
 }
 
+LeakDetectorController::TotalMemoryGrowthTracker::TotalMemoryGrowthTracker()
+    : total_usage_kb_(0) {}
+
+LeakDetectorController::TotalMemoryGrowthTracker::~TotalMemoryGrowthTracker() {}
+
+bool LeakDetectorController::TotalMemoryGrowthTracker::UpdateSample(
+    base::ProcessId pid,
+    int sample,
+    int* diff) {
+  total_usage_kb_ += sample;
+  return false;
+}
+
 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 similar as in
+    // ChromeMetricsServiceClient. However, here generation of histogram data
+    // is suppressed.
+    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->set_generate_histograms(false);
+    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