Removing the |MemoryPressureObserverChromeOS::MemoryPressureLevel| enum.

base/chromeos/memory_pressure_observer_chromeos.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_observer_chromeos.h"
 
 #include "base/process/process_metrics.h"
 #include "base/time/time.h"
 
 namespace base {
 
 namespace {
 
 // The time between memory pressure checks.
 const int kMemoryPressureIntervalInMS = 1000;
 
 // Converts free percent of memory into a memory pressure value.
-MemoryPressureObserverChromeOS::MemoryPressureLevel
-GetMemoryPressureLevelFromFillLevel(
+MemoryPressureListener::MemoryPressureLevel GetMemoryPressureLevelFromFillLevel(
     int memory_fill_level) {
-  if (memory_fill_level < 50)
-    return MemoryPressureObserverChromeOS::MEMORY_PRESSURE_LEVEL_LOW;
-  if (memory_fill_level < 75)
-    return MemoryPressureObserverChromeOS::MEMORY_PRESSURE_LEVEL_MODERATE;
-  if (memory_fill_level < 90)
-    return MemoryPressureObserverChromeOS::MEMORY_PRESSURE_LEVEL_HIGH;
-  return MemoryPressureObserverChromeOS::MEMORY_PRESSURE_LEVEL_CRITICAL;
+  if (memory_fill_level < 70)
+    return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
+  return memory_fill_level < 90 ?
+      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE :
+      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
 }
 
 // Gets the used ChromeOS memory in percent.
 int 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
@@ skipping 23 matching lines @@
       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
 
 MemoryPressureObserverChromeOS::MemoryPressureObserverChromeOS()
-    : current_memory_pressure_level_(MEMORY_PRESSURE_LEVEL_LOW) {
+    : current_memory_pressure_level_(
+        MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) {
   StartObserving();
 }
 
 MemoryPressureObserverChromeOS::~MemoryPressureObserverChromeOS() {
   StopObserving();
 }
 
 void MemoryPressureObserverChromeOS::StartObserving() {
   timer_.Start(FROM_HERE,
                base::TimeDelta::FromMilliseconds(kMemoryPressureIntervalInMS),
                base::Bind(&MemoryPressureObserverChromeOS::CheckMemoryPressure,
                           base::Unretained(this)));
 }
 
 void MemoryPressureObserverChromeOS::StopObserving() {
   // If StartObserving failed, StopObserving will still get called.
   timer_.Stop();
 }
 
 void MemoryPressureObserverChromeOS::CheckMemoryPressure() {
-  MemoryPressureLevel old_pressure = current_memory_pressure_level_;
-  MemoryPressureLevel new_pressure =
+  MemoryPressureListener::MemoryPressureLevel old_pressure =
+      current_memory_pressure_level_;
+  MemoryPressureListener::MemoryPressureLevel new_pressure =
       GetMemoryPressureLevelFromFillLevel(GetUsedMemoryInPercent());
   if (old_pressure != new_pressure) {
     current_memory_pressure_level_ = new_pressure;
-    switch (new_pressure) {
-      case MEMORY_PRESSURE_LEVEL_LOW:
-        // The |MemoryPressureListener| does currently not support this.
-        break;
-      case MEMORY_PRESSURE_LEVEL_MODERATE:
-        MemoryPressureListener::NotifyMemoryPressure(
-            MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE);
-        break;
-      case MEMORY_PRESSURE_LEVEL_HIGH:
-        // The |MemoryPressureListener| does currently not support this.
-        break;
-      case MEMORY_PRESSURE_LEVEL_CRITICAL:
-        MemoryPressureListener::NotifyMemoryPressure(
-            MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
-        break;
-    }
+    // Everything but NONE will be sent to the listener.
+    if (new_pressure != MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE)
+      MemoryPressureListener::NotifyMemoryPressure(new_pressure);
   }
 }
 
 }  // namespace base