Rename OS-specific MemoryPressureMonitor implementations.

base/chromeos/memory_pressure_monitor.cc

 // Copyright 2014 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 "base/chromeos/memory_pressure_monitor_chromeos.h"
+#include "base/chromeos/memory_pressure_monitor.h"
 
 #include <fcntl.h>
 #include <sys/select.h>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/process_metrics.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 
 namespace base {
+namespace chromeos {
 
 namespace {
 
 // The time between memory pressure checks. While under critical pressure, this
 // is also the timer to repeat cleanup attempts.
 const int kMemoryPressureIntervalMs = 1000;
 
 // The time which should pass between two moderate memory pressure calls.
 const int kModerateMemoryPressureCooldownMs = 10000;
 
@@ skipping 18 matching lines @@
 };
 
 // This is the file that will exist if low memory notification is available
 // on the device.  Whenever it becomes readable, it signals a low memory
 // condition.
 const char kLowMemFile[] = "/dev/chromeos-low-mem";
 
 // Converts a |MemoryPressureThreshold| value into a used memory percentage for
 // the moderate pressure event.
 int GetModerateMemoryThresholdInPercent(
-    MemoryPressureMonitorChromeOS::MemoryPressureThresholds thresholds) {
-  return thresholds == MemoryPressureMonitorChromeOS::
+    MemoryPressureMonitor::MemoryPressureThresholds thresholds) {
+  return thresholds == MemoryPressureMonitor::
                            THRESHOLD_AGGRESSIVE_CACHE_DISCARD ||
-         thresholds == MemoryPressureMonitorChromeOS::THRESHOLD_AGGRESSIVE
+         thresholds == MemoryPressureMonitor::THRESHOLD_AGGRESSIVE
              ? kAggressiveMemoryPressureModerateThresholdPercent
              : kNormalMemoryPressureModerateThresholdPercent;
 }
 
 // Converts a |MemoryPressureThreshold| value into a used memory percentage for
 // the critical pressure event.
 int GetCriticalMemoryThresholdInPercent(
-    MemoryPressureMonitorChromeOS::MemoryPressureThresholds thresholds) {
-  return thresholds == MemoryPressureMonitorChromeOS::
+    MemoryPressureMonitor::MemoryPressureThresholds thresholds) {
+  return thresholds == MemoryPressureMonitor::
                            THRESHOLD_AGGRESSIVE_TAB_DISCARD ||
-         thresholds == MemoryPressureMonitorChromeOS::THRESHOLD_AGGRESSIVE
+         thresholds == MemoryPressureMonitor::THRESHOLD_AGGRESSIVE
              ? kAggressiveMemoryPressureCriticalThresholdPercent
              : kNormalMemoryPressureCriticalThresholdPercent;
 }
 
 // Converts free percent of memory into a memory pressure value.
 MemoryPressureListener::MemoryPressureLevel GetMemoryPressureLevelFromFillLevel(
     int actual_fill_level,
     int moderate_threshold,
     int critical_threshold) {
   if (actual_fill_level < moderate_threshold)
@@ skipping 13 matching lines @@
   FD_SET(file_descriptor, &fds);
 
   tv.tv_sec = 0;
   tv.tv_usec = 0;
 
   return HANDLE_EINTR(select(file_descriptor + 1, &fds, NULL, NULL, &tv)) > 0;
 }
 
 }  // namespace
 
-MemoryPressureMonitorChromeOS::MemoryPressureMonitorChromeOS(
+MemoryPressureMonitor::MemoryPressureMonitor(
     MemoryPressureThresholds thresholds)
     : current_memory_pressure_level_(
           MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
       moderate_pressure_repeat_count_(0),
       moderate_pressure_threshold_percent_(
           GetModerateMemoryThresholdInPercent(thresholds)),
       critical_pressure_threshold_percent_(
           GetCriticalMemoryThresholdInPercent(thresholds)),
       low_mem_file_(HANDLE_EINTR(::open(kLowMemFile, O_RDONLY))),
       weak_ptr_factory_(this) {
   StartObserving();
   LOG_IF(ERROR, !low_mem_file_.is_valid()) << "Cannot open kernel listener";
 }
 
-MemoryPressureMonitorChromeOS::~MemoryPressureMonitorChromeOS() {
+MemoryPressureMonitor::~MemoryPressureMonitor() {
   StopObserving();
 }
 
-void MemoryPressureMonitorChromeOS::ScheduleEarlyCheck() {
+void MemoryPressureMonitor::ScheduleEarlyCheck() {
   ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, Bind(&MemoryPressureMonitorChromeOS::CheckMemoryPressure,
+      FROM_HERE, Bind(&MemoryPressureMonitor::CheckMemoryPressure,
                       weak_ptr_factory_.GetWeakPtr()));
 }
 
 MemoryPressureListener::MemoryPressureLevel
-MemoryPressureMonitorChromeOS::GetCurrentPressureLevel() const {
+MemoryPressureMonitor::GetCurrentPressureLevel() const {
   return current_memory_pressure_level_;
 }
 
-void MemoryPressureMonitorChromeOS::StartObserving() {
+// static
+MemoryPressureMonitor* MemoryPressureMonitor::Get() {
+  return static_cast<MemoryPressureMonitor*>(
+      base::MemoryPressureMonitor::Get());
+}
+
+void MemoryPressureMonitor::StartObserving() {
   timer_.Start(FROM_HERE,
                TimeDelta::FromMilliseconds(kMemoryPressureIntervalMs),
-               Bind(&MemoryPressureMonitorChromeOS::
+               Bind(&MemoryPressureMonitor::
                         CheckMemoryPressureAndRecordStatistics,
                     weak_ptr_factory_.GetWeakPtr()));
 }
 
-void MemoryPressureMonitorChromeOS::StopObserving() {
+void MemoryPressureMonitor::StopObserving() {
   // If StartObserving failed, StopObserving will still get called.
   timer_.Stop();
 }
 
-void MemoryPressureMonitorChromeOS::CheckMemoryPressureAndRecordStatistics() {
+void MemoryPressureMonitor::CheckMemoryPressureAndRecordStatistics() {
   CheckMemoryPressure();
 
   // Record UMA histogram statistics for the current memory pressure level.
   MemoryPressureLevelUMA memory_pressure_level_uma(MEMORY_PRESSURE_LEVEL_NONE);
   switch (current_memory_pressure_level_) {
     case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE:
       memory_pressure_level_uma = MEMORY_PRESSURE_LEVEL_NONE;
       break;
     case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE:
       memory_pressure_level_uma = MEMORY_PRESSURE_LEVEL_MODERATE;
       break;
     case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL:
       memory_pressure_level_uma = MEMORY_PRESSURE_LEVEL_CRITICAL;
       break;
   }
 
   UMA_HISTOGRAM_ENUMERATION("ChromeOS.MemoryPressureLevel",
                             memory_pressure_level_uma,
                             NUM_MEMORY_PRESSURE_LEVELS);
 }
 
-void MemoryPressureMonitorChromeOS::CheckMemoryPressure() {
+void MemoryPressureMonitor::CheckMemoryPressure() {
   MemoryPressureListener::MemoryPressureLevel old_pressure =
       current_memory_pressure_level_;
 
   // If we have the kernel low memory observer, we use it's flag instead of our
   // own computation (for now). Note that in "simulation mode" it can be null.
   // TODO(skuhne): We need to add code which makes sure that the kernel and this
   // computation come to similar results and then remove this override again.
   // TODO(skuhne): Add some testing framework here to see how close the kernel
   // and the internal functions are.
   if (low_mem_file_.is_valid() && IsLowMemoryCondition(low_mem_file_.get())) {
@@ skipping 37 matching lines @@
     // When we reducing the pressure level from critical to moderate, we
     // restart the timeout and do not send another notification.
     moderate_pressure_repeat_count_ = 0;
     return;
   }
   moderate_pressure_repeat_count_ = 0;
   MemoryPressureListener::NotifyMemoryPressure(current_memory_pressure_level_);
 }
 
 // Gets the used ChromeOS memory in percent.
-int MemoryPressureMonitorChromeOS::GetUsedMemoryInPercent() {
+int MemoryPressureMonitor::GetUsedMemoryInPercent() {
   base::SystemMemoryInfoKB info;
   if (!base::GetSystemMemoryInfo(&info)) {
     VLOG(1) << "Cannot determine the free memory of the system.";
     return 0;
   }
   // TODO(skuhne): Instead of adding the kernel memory pressure calculation
   // logic here, we should have a kernel mechanism similar to the low memory
   // notifier in ChromeOS which offers multiple pressure states.
   // To track this, we have crbug.com/381196.
 
@@ skipping 16 matching lines @@
 
   // Available memory is the sum of free, swap and easy reclaimable memory.
   int available_memory =
       info.free + info.swap_free / kSwapWeight + file_memory;
 
   DCHECK(available_memory < total_memory);
   int percentage = ((total_memory - available_memory) * 100) / total_memory;
   return percentage;
 }
 
+}  // namespace chromeos
 }  // namespace base