Leak reports collect information about the memory usage

chrome/browser/metrics/leak_detector/leak_detector_controller.cc

Index: chrome/browser/metrics/leak_detector/leak_detector_controller.cc
diff --git a/chrome/browser/metrics/leak_detector/leak_detector_controller.cc b/chrome/browser/metrics/leak_detector/leak_detector_controller.cc
index 2f58c72672003ecbc0d7dd3c3d423e863c0b2b7f..197a02ae01a4c82d83a6d02b22d9d6f324178444 100644
--- a/chrome/browser/metrics/leak_detector/leak_detector_controller.cc
+++ b/chrome/browser/metrics/leak_detector/leak_detector_controller.cc
@@ -7,8 +7,10 @@
 #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"
@@ -145,12 +147,34 @@ void GetLeakDetectorEnableParams(double* browser_probability,
 
 }  // namespace
 
+TotalMemoryGrowthTracker::TotalMemoryGrowthTracker() : total_usage_kb_(0) {
+}
+
+TotalMemoryGrowthTracker::~TotalMemoryGrowthTracker() {
+}
+
+bool TotalMemoryGrowthTracker::UpdateSample(

[mwlodar, 2016/10/05 22:00:23]

Right now we override this method totally in order to suppress generating
growth/shrink information and save some time. But maybe we should always
generate all the histogram data?

+    base::ProcessId pid, int sample, int* diff) {
+  total_usage_kb_ += sample;
+  return false;
+}
+
+size_t TotalMemoryGrowthTracker::GetTotalUsageKb() const {
+  return total_usage_kb_;
+}
+
+void TotalMemoryGrowthTracker::Reset() {
+  total_usage_kb_ = 0;
+}
+
 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),
+      weak_ptr_factory_(this),
+      waiting_for_collect_memory_usage_(false) {
   // Read the build ID once and store it.
   leak_detector::gnu_build_id_reader::ReadBuildID(&build_id_);
 
@@ -221,11 +245,50 @@ bool LeakDetectorController::ShouldRandomlyEnableLeakDetectorOnRendererProcess()
              max_renderer_processes_with_leak_detector_enabled_;
 }
 
+void LeakDetectorController::OnMemoryDetailCollectionDone(size_t index) {
+  DCHECK(thread_checker_.CalledOnValidThread());

[mwlodar, 2016/10/05 02:18:53]

Is there some guarantee that MetricsMemoryDetails will run the callback in the
same thread?

+  DCHECK(waiting_for_collect_memory_usage_);
+  waiting_for_collect_memory_usage_ = 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_.GetTotalUsageKb() / 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 (!waiting_for_collect_memory_usage_) {

[mwlodar, 2016/10/05 02:18:53]

I don't know what kind of tests suits this code the best. With some additional
code "details->StartFetch()" part could be faked in a unit test. However the
more interesting question is if MetricsMemoryDetails always uses the callback
and the memory growth tracker in a proper way.

+    waiting_for_collect_memory_usage_ = 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.
+    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);