Adding flag to specify the used memory pressure strategy

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/message_loop/message_loop.h"
 #include "base/process/process_metrics.h"
 #include "base/time/time.h"
 
 namespace base {
 
 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;
 
 // Number of event polls before the next moderate pressure event can be sent.
 const int kModerateMemoryPressureCooldown =
     kModerateMemoryPressureCooldownMs / kMemoryPressureIntervalMs;
 
 // Threshold constants to emit pressure events.
-const int kMemoryPressureModerateThresholdPercent = 70;
-const int kMemoryPressureCriticalThresholdPercent = 90;
+const int kNormalMemoryPressureModerateThresholdPercent = 60;
+const int kNormalMemoryPressureCriticalThresholdPercent = 90;
+const int kAggressiveMemoryPressureModerateThresholdPercent = 35;
+const int kAggressiveMemoryPressureCriticalThresholdPercent = 70;
+
+// Converts a |MemoryPressureThreshold| value into a used memory percentage for
+// the moderate pressure event.
+int GetModerateMemoryThresholdInPercent(
+    MemoryPressureObserverChromeOS::MemoryPressureThresholds thresholds) {
+  return thresholds == MemoryPressureObserverChromeOS::
+                           MEMORY_PRESSURE_THRESHOLD_AGGRESSIVE_CACHE_DISCARD ||
+         thresholds == MemoryPressureObserverChromeOS::
+                           MEMORY_PRESSURE_THRESHOLD_AGGRESSIVE
+             ? kAggressiveMemoryPressureModerateThresholdPercent
+             : kNormalMemoryPressureModerateThresholdPercent;
+}
+
+// Converts a |MemoryPressureThreshold| value into a used memory percentage for
+// the critical pressure event.
+int GetCriticalMemoryThresholdInPercent(
+    MemoryPressureObserverChromeOS::MemoryPressureThresholds thresholds) {
+  return thresholds == MemoryPressureObserverChromeOS::
+                           MEMORY_PRESSURE_THRESHOLD_AGGRESSIVE_TAB_DISCARD ||
+         thresholds == MemoryPressureObserverChromeOS::
+                           MEMORY_PRESSURE_THRESHOLD_AGGRESSIVE
+             ? kAggressiveMemoryPressureCriticalThresholdPercent
+             : kNormalMemoryPressureCriticalThresholdPercent;
+}
 
 // Converts free percent of memory into a memory pressure value.
 MemoryPressureListener::MemoryPressureLevel GetMemoryPressureLevelFromFillLevel(
-    int memory_fill_level) {
-  if (memory_fill_level < kMemoryPressureModerateThresholdPercent)
+    int actual_fill_level,
+    int moderate_threshold,
+    int critical_threshold) {
+  if (actual_fill_level < moderate_threshold)
     return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
-  return memory_fill_level < kMemoryPressureCriticalThresholdPercent ?
-      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE :
-      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
+  return actual_fill_level < critical_threshold
+             ? MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE
+             : MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
 }
 
 }  // namespace
 
-MemoryPressureObserverChromeOS::MemoryPressureObserverChromeOS()
+MemoryPressureObserverChromeOS::MemoryPressureObserverChromeOS(
+    MemoryPressureThresholds thresholds)
     : current_memory_pressure_level_(
-        MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
+          MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
       moderate_pressure_repeat_count_(0),
+      moderate_pressure_threshold_(
+          GetModerateMemoryThresholdInPercent(thresholds)),
+      critical_pressure_threshold_(
+          GetCriticalMemoryThresholdInPercent(thresholds)),
       weak_ptr_factory_(this) {
   StartObserving();
 }
 
 MemoryPressureObserverChromeOS::~MemoryPressureObserverChromeOS() {
   StopObserving();
 }
 
 void MemoryPressureObserverChromeOS::ScheduleEarlyCheck() {
   MessageLoop::current()->PostTask(
@@ skipping 11 matching lines @@
 
 void MemoryPressureObserverChromeOS::StopObserving() {
   // If StartObserving failed, StopObserving will still get called.
   timer_.Stop();
 }
 
 void MemoryPressureObserverChromeOS::CheckMemoryPressure() {
   MemoryPressureListener::MemoryPressureLevel old_pressure =
       current_memory_pressure_level_;
   current_memory_pressure_level_ =
-      GetMemoryPressureLevelFromFillLevel(GetUsedMemoryInPercent());
+      GetMemoryPressureLevelFromFillLevel(GetUsedMemoryInPercent(),
+                                          moderate_pressure_threshold_,
+                                          critical_pressure_threshold_);
   // In case there is no memory pressure we do not notify.
   if (current_memory_pressure_level_ ==
       MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) {
     return;
   }
   if (old_pressure == current_memory_pressure_level_) {
     // If the memory pressure is still at the same level, we notify again for a
     // critical level. In case of a moderate level repeat however, we only send
     // a notification after a certain time has passed.
     if (current_memory_pressure_level_ ==
@@ skipping 47 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 base