Update from https://crrev.com/308331

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(
+    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;
+}
+
+// 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
+  // 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.
+
+  // The available memory consists of "real" and virtual (z)ram memory.
+  // Since swappable memory uses a non pre-deterministic compression and
+  // the compression creates its own "dynamic" in the system, it gets
+  // de-emphasized by the |kSwapWeight| factor.
+  const int kSwapWeight = 4;
+
+  // The total memory we have is the "real memory" plus the virtual (z)ram.
+  int total_memory = info.total + info.swap_total / kSwapWeight;
+
+  // The kernel internally uses 50MB.
+  const int kMinFileMemory = 50 * 1024;
+
+  // Most file memory can be easily reclaimed.
+  int file_memory = info.active_file + info.inactive_file;
+  // unless it is dirty or it's a minimal portion which is required.
+  file_memory -= info.dirty + kMinFileMemory;
+
+  // 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
+
+MemoryPressureObserverChromeOS::MemoryPressureObserverChromeOS()
+    : current_memory_pressure_level_(MEMORY_PRESSURE_LEVEL_LOW) {
+  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 =
+      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;
+    }
+  }
+}
+
+}  // namespace base