Create base::win::MemoryPressureMonitor class.

base/win/memory_pressure_monitor_unittest.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 "base/win/memory_pressure_monitor.h"
+
+#include "base/basictypes.h"
+#include "base/memory/memory_pressure_listener.h"
+#include "base/message_loop/message_loop.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace win {
+
+namespace {
+
+struct PressureSettings {
+  int phys;
+  int virt;
+  MemoryPressureListener::MemoryPressureLevel level;
+};
+
+}  // namespace
+
+// This is outside of the anonymous namespace so that it can be seen as a friend
+// to the monitor class.
+class TestMemoryPressureMonitor : public MemoryPressureMonitor {
+ public:
+  using MemoryPressureMonitor::CalculateCurrentPressureLevel;
+  using MemoryPressureMonitor::CheckMemoryPressure;
+
+  static const DWORDLONG k4GB = 4ull * 1024 * 1024 * 1024;
+
+  TestMemoryPressureMonitor() {
+    // Disable any timers which are going on and set a special memory reporting
+    // function.
+    StopObserving();
+  }
+
+  virtual ~TestMemoryPressureMonitor() {}
+
+  MOCK_METHOD1(OnMemoryPressure,
+               void(MemoryPressureListener::MemoryPressureLevel level));
+
+  // Sets up the memory status to reflect the provided loads.
+  void SetMemoryLoad(int phys_load_pct, int virt_load_pct) {
+    mem_status_.dwMemoryLoad = static_cast<DWORD>(phys_load_pct);
+    mem_status_.ullTotalPhys = k4GB;
+    mem_status_.ullAvailPhys = (k4GB * (100 - phys_load_pct)) / 100;
+    mem_status_.ullTotalPageFile = k4GB;
+    mem_status_.ullAvailPageFile = k4GB;
+    mem_status_.ullTotalVirtual = k4GB;
+    mem_status_.ullAvailVirtual = (k4GB * (100 - virt_load_pct)) / 100;
+  }
+
+  // Sets up the memory status to reflect the provided absolute memory left.
+  // This uses quite small total memory quantities so that the absolute memory
+  // limits have a chance to kick in.
+  void SetMemoryFree(int phys_left_mb) {
+    static DWORDLONG kMBBytes = 1024 * 1024;
+
+    // Figure out an amount of memory that makes sense for the desired
+    // quantities of memory to be left.
+    DWORDLONG total_mb = 64;  // Minimum of 64MB.
+    while (total_mb < phys_left_mb)
+      total_mb *= 2;
+    DWORDLONG total_bytes = total_mb * kMBBytes;
+
+    mem_status_.ullTotalPhys = total_bytes;
+    mem_status_.ullAvailPhys =
+        static_cast<DWORDLONG>(phys_left_mb) * kMBBytes;
+    mem_status_.ullTotalPageFile = total_bytes;
+    mem_status_.ullAvailPageFile = total_bytes;
+    mem_status_.ullTotalVirtual = k4GB;
+    mem_status_.ullAvailVirtual = k4GB;
+    mem_status_.dwMemoryLoad = static_cast<DWORD>(
+        100 * (mem_status_.ullTotalPhys - mem_status_.ullAvailPhys) /
+        mem_status_.ullTotalPhys);
+  }
+
+ private:
+  bool GetSystemMemoryStatus(MEMORYSTATUSEX* mem_status) override {
+    // Simply copy the memory status set by the test fixture.
+    *mem_status = mem_status_;
+    return true;
+  }
+
+  MEMORYSTATUSEX mem_status_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestMemoryPressureMonitor);
+};
+
+// Tests the fundamental direct calculation of memory pressure.
+TEST(WinMemoryPressureMonitorTest, CalculateCurrentMemoryPressureLevel) {
+  base::MessageLoopForUI message_loop;
+  TestMemoryPressureMonitor monitor;
+
+  // A bunch of memory load settings and the expected memory pressure.
+  const PressureSettings kLoadSettings[] = {
+      { 10, 10, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE },
+      { 40, 40, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE },
+      { 65, 10, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE },
+      { 65, 65, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE },
+      { 98, 10, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL },
+      { 98, 65, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL },
+      { 98, 98, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL },
+#if !defined(ARCH_CPU_64_BITS)
+      // This simulates low virtual memory, which is only applicable on
+      // 32-bit systems.
+      { 10, 65, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE },
+      { 10, 98, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL },
+      { 65, 98, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL },
+#endif  // !defined(ARCH_CPU_64_BITS)
+  };
+
+  for (const PressureSettings& setting : kLoadSettings) {
+    monitor.SetMemoryLoad(setting.phys, setting.virt);
+    EXPECT_EQ(setting.level, monitor.CalculateCurrentPressureLevel());
+  }
+
+  // A bunch of free memory settings and the expected memory pressure. The
+  // 'virt' parameter is ignored, thus zeroed.
+  const PressureSettings kFreeSettings[] = {
+      { 500, 0, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE },
+      { 250, 0, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE },
+      { 250, 0, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE },
+      { 50, 0, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL },
+      { 50, 0, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL },
+      { 50, 0, MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL },
+  };
+
+  for (const PressureSettings& setting : kFreeSettings) {
+    monitor.SetMemoryFree(setting.phys);
+    EXPECT_EQ(setting.level, monitor.CalculateCurrentPressureLevel());
+  }
+}
+
+// This test tests the various transition states from memory pressure, looking
+// for the correct behavior on event reposting as well as state updates.
+TEST(WinMemoryPressureMonitorTest, CheckMemoryPressure) {
+  base::MessageLoopForUI message_loop;
+  testing::StrictMock<TestMemoryPressureMonitor> monitor;
+  MemoryPressureListener listener(
+      base::Bind(&TestMemoryPressureMonitor::OnMemoryPressure,
+                 base::Unretained(&monitor)));
+
+  // Checking the memory pressure at 0% load should not produce any
+  // events.
+  monitor.SetMemoryLoad(0, 0);
+  monitor.CheckMemoryPressure();
+  message_loop.RunUntilIdle();
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
+            monitor.GetCurrentPressureLevel());
+
+  // Setting the memory level to 80% should produce a moderate pressure level.
+  EXPECT_CALL(monitor,
+              OnMemoryPressure(MemoryPressureListener::
+                                   MEMORY_PRESSURE_LEVEL_MODERATE));
+  monitor.SetMemoryLoad(80, 80);
+  monitor.CheckMemoryPressure();
+  message_loop.RunUntilIdle();
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
+            monitor.GetCurrentPressureLevel());
+  testing::Mock::VerifyAndClearExpectations(&monitor);
+
+  // Check that the event gets reposted after a while.
+  for (int i = 0; i < monitor.kModeratePressureCooldownCycles; ++i) {
+    if (i + 1 == monitor.kModeratePressureCooldownCycles) {
+      EXPECT_CALL(monitor,
+                  OnMemoryPressure(MemoryPressureListener::
+                                       MEMORY_PRESSURE_LEVEL_MODERATE));
+    }
+    monitor.CheckMemoryPressure();
+    message_loop.RunUntilIdle();
+    EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
+              monitor.GetCurrentPressureLevel());
+  }
+  testing::Mock::VerifyAndClearExpectations(&monitor);

[grt (UTC plus 2), 2015/05/06 18:14:57]

shouldn't this be up one line so that it's in the loop?

+
+  // Setting the memory usage to 99% should produce critical levels.
+  EXPECT_CALL(monitor,
+              OnMemoryPressure(MemoryPressureListener::
+                                   MEMORY_PRESSURE_LEVEL_CRITICAL));
+  monitor.SetMemoryLoad(99, 99);
+  monitor.CheckMemoryPressure();
+  message_loop.RunUntilIdle();
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
+            monitor.GetCurrentPressureLevel());
+  testing::Mock::VerifyAndClearExpectations(&monitor);
+
+  // Calling it again should immediately produce a second call.
+  EXPECT_CALL(monitor,
+              OnMemoryPressure(MemoryPressureListener::
+                                   MEMORY_PRESSURE_LEVEL_CRITICAL));
+  monitor.CheckMemoryPressure();
+  message_loop.RunUntilIdle();
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
+            monitor.GetCurrentPressureLevel());
+  testing::Mock::VerifyAndClearExpectations(&monitor);
+
+  // When lowering the pressure again there should be a notification and the
+  // pressure should go back to moderate.
+  EXPECT_CALL(monitor,
+              OnMemoryPressure(MemoryPressureListener::
+                                   MEMORY_PRESSURE_LEVEL_MODERATE));
+  monitor.SetMemoryLoad(80, 80);
+  monitor.CheckMemoryPressure();
+  message_loop.RunUntilIdle();
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
+            monitor.GetCurrentPressureLevel());
+  testing::Mock::VerifyAndClearExpectations(&monitor);
+
+  // Check that the event gets reposted after a while.
+  for (int i = 0; i < monitor.kModeratePressureCooldownCycles; ++i) {
+    if (i + 1 == monitor.kModeratePressureCooldownCycles) {
+      EXPECT_CALL(monitor,
+                  OnMemoryPressure(MemoryPressureListener::
+                                       MEMORY_PRESSURE_LEVEL_MODERATE));
+    }
+    monitor.CheckMemoryPressure();
+    message_loop.RunUntilIdle();
+    EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
+              monitor.GetCurrentPressureLevel());
+  }
+  testing::Mock::VerifyAndClearExpectations(&monitor);

[grt (UTC plus 2), 2015/05/06 18:14:57]

here, too: in the loop?

+
+  // Going down to no pressure should not produce an notification.
+  monitor.SetMemoryLoad(0, 0);
+  monitor.CheckMemoryPressure();
+  message_loop.RunUntilIdle();
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
+            monitor.GetCurrentPressureLevel());
+  testing::Mock::VerifyAndClearExpectations(&monitor);
+}
+
+}  // namespace win
+}  // namespace base