Make ResourceReporter a client of memory coordinator

chrome/browser/chromeos/resource_reporter/resource_reporter.cc

 // Copyright 2015 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/chromeos/resource_reporter/resource_reporter.h"
 
 #include <cstdint>
 #include <queue>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/memory_pressure_monitor.h"
 #include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/task_manager/task_manager_interface.h"
 #include "components/rappor/rappor_service.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 90 matching lines @@
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (is_monitoring_)
     return;
 
   task_manager_to_observe_ = task_manager_to_observe;
   DCHECK(task_manager_to_observe_);
   is_monitoring_ = true;
   memory_pressure_listener_.reset(new base::MemoryPressureListener(
       base::Bind(&ResourceReporter::OnMemoryPressure, base::Unretained(this))));
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 }
 
 void ResourceReporter::StopMonitoring() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (!is_monitoring_)
     return;
 
   // We might be shutting down right after a critical memory pressure event, and
   // before we get an update from the task manager with all background
   // calculations refreshed. In this case we must unregister from the task
   // manager here.
-  if (observed_task_manager())
-    observed_task_manager()->RemoveObserver(this);
+  StopRecordingCurrentState();
 
   is_monitoring_ = false;
   memory_pressure_listener_.reset();
+
+  base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
 }
 
 void ResourceReporter::OnTasksRefreshedWithBackgroundCalculations(
     const task_manager::TaskIdList& task_ids) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   task_records_.clear();
   task_records_.reserve(task_ids.size());
 
   for (const auto& id : task_ids) {
@@ skipping 35 matching lines @@
   }
 
   // Now that we got the data, we don't need the task manager anymore.
   if (base::MemoryPressureMonitor::Get()->GetCurrentPressureLevel() !=
           MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_CRITICAL ||
       !task_records_.empty()) {
     // The memory pressure events are emitted once per second. In order to avoid
     // unsubscribing and then resubscribing to the task manager again on the
     // next event, we keep listening to the task manager as long as the memory
     // pressure level is critical AND we couldn't find any violators yet.
-    observed_task_manager()->RemoveObserver(this);
+    StopRecordingCurrentState();
   }
 
   // Schedule reporting the samples.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&ResourceReporter::ReportSamples, base::Unretained(this)));
 }
 
 // static
 const double ResourceReporter::kTaskCpuThresholdForReporting = 70.0;
@@ skipping 179 matching lines @@
         GET_ENUM_VAL(MemoryUsageRange::NUM_RANGES));
     rappor_service->RecordSampleObj(kMemoryRapporMetric,
                                     std::move(memory_sample));
   }
 }
 
 void ResourceReporter::OnMemoryPressure(
     MemoryPressureLevel memory_pressure_level) {
   if (memory_pressure_level ==
       MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_CRITICAL) {
-    // If we are already listening to the task manager, then we're waiting for
-    // a refresh event.
-    if (observed_task_manager())
-      return;
-
-    // We only record Rappor samples only if it's the first ever critical memory
-    // pressure event we receive, or it has been more than
-    // |kMinimumTimeBetweenReportsInMs| since the last time we recorded samples.
-    if (g_browser_process->local_state()) {
-      const base::Time now = base::Time::NowFromSystemTime();
-      const base::Time last_rappor_report_time =
-          base::Time::FromDoubleT(g_browser_process->local_state()->GetDouble(
-              kLastRapporReportTimeKey));
-      const base::TimeDelta delta_since_last_report =
-          now >= last_rappor_report_time ? now - last_rappor_report_time
-                                         : base::TimeDelta::Max();
-
-      if (delta_since_last_report < kMinimumTimeBetweenReports)
-        return;
-    }
-
-    // Start listening to the task manager and wait for the first refresh event
-    // with background calculations completion.
-    task_manager_to_observe_->AddObserver(this);
+    StartRecordingCurrentState();
   } else {
-    // If we are still listening to the task manager from an earlier critical
-    // memory pressure level, we need to stop listening to it.
-    if (observed_task_manager())
-      observed_task_manager()->RemoveObserver(this);
+    StopRecordingCurrentState();
   }
 }
 
+void ResourceReporter::StartRecordingCurrentState() {
+  // If we are already listening to the task manager, then we're waiting for
+  // a refresh event.
+  if (observed_task_manager())
+    return;
+
+  // We only record Rappor samples only if it's the first ever critical memory
+  // pressure event we receive, or it has been more than
+  // |kMinimumTimeBetweenReportsInMs| since the last time we recorded samples.
+  if (g_browser_process->local_state()) {
+    const base::Time now = base::Time::NowFromSystemTime();
+    const base::Time last_rappor_report_time = base::Time::FromDoubleT(
+        g_browser_process->local_state()->GetDouble(kLastRapporReportTimeKey));
+    const base::TimeDelta delta_since_last_report =
+        now >= last_rappor_report_time ? now - last_rappor_report_time
+                                       : base::TimeDelta::Max();
+
+    if (delta_since_last_report < kMinimumTimeBetweenReports)
+      return;
+  }
+
+  // Start listening to the task manager and wait for the first refresh event
+  // with background calculations completion.
+  task_manager_to_observe_->AddObserver(this);
+}
+
+void ResourceReporter::StopRecordingCurrentState() {
+  // If we are still listening to the task manager from an earlier critical
+  // memory pressure level, we need to stop listening to it.
+  if (observed_task_manager())
+    observed_task_manager()->RemoveObserver(this);
+}
+
+void ResourceReporter::OnMemoryStateChange(base::MemoryState state) {
+  switch (state) {
+    case base::MemoryState::NORMAL:
+      StopRecordingCurrentState();
+      break;
+    case base::MemoryState::THROTTLED:
+      StartRecordingCurrentState();
+      break;
+    case base::MemoryState::SUSPENDED:
+    // Note: Not supported at present. Fall through.
+    case base::MemoryState::UNKNOWN:
+      NOTREACHED();
+      break;
+  }
+}
+
 }  // namespace chromeos