base/memory/memory_pressure_monitor_chromeos_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/memory_pressure_monitor_chromeos.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/memory/memory_pressure_listener.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace base {
  13 namespace chromeos {
  14
  15 namespace {
  16
  17 // True if the memory notifier got called.
  18 // Do not read/modify value directly.
  19 bool on_memory_pressure_called = false;
  20
  21 // If the memory notifier got called, this is the memory pressure reported.
  22 MemoryPressureListener::MemoryPressureLevel on_memory_pressure_level =
  23     MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
  24
  25 // Processes OnMemoryPressure calls.
  26 void OnMemoryPressure(MemoryPressureListener::MemoryPressureLevel level) {
  27   on_memory_pressure_called = true;
  28   on_memory_pressure_level = level;
  29 }
  30
  31 // Resets the indicator for memory pressure.
  32 void ResetOnMemoryPressureCalled() {
  33   on_memory_pressure_called = false;
  34 }
  35
  36 // Returns true when OnMemoryPressure was called (and resets it).
  37 bool WasOnMemoryPressureCalled() {
  38   bool b = on_memory_pressure_called;
  39   ResetOnMemoryPressureCalled();
  40   return b;
  41 }
  42
  43 }  // namespace
  44
  45 class TestMemoryPressureMonitor : public MemoryPressureMonitor {
  46  public:
  47   TestMemoryPressureMonitor()
  48       : MemoryPressureMonitor(THRESHOLD_DEFAULT),
  49         memory_in_percent_override_(0) {
  50     // Disable any timers which are going on and set a special memory reporting
  51     // function.
  52     StopObserving();
  53   }
  54   ~TestMemoryPressureMonitor() override {}
  55
  56   void SetMemoryInPercentOverride(int percent) {
  57     memory_in_percent_override_ = percent;
  58   }
  59
  60   void CheckMemoryPressureForTest() {
  61     CheckMemoryPressure();
  62   }
  63
  64  private:
  65   int GetUsedMemoryInPercent() override {
  66     return memory_in_percent_override_;
  67   }
  68
  69   int memory_in_percent_override_;
  70   DISALLOW_COPY_AND_ASSIGN(TestMemoryPressureMonitor);
  71 };
  72
  73 // This test tests the various transition states from memory pressure, looking
  74 // for the correct behavior on event reposting as well as state updates.
  75 TEST(ChromeOSMemoryPressureMonitorTest, CheckMemoryPressure) {
  76   base::MessageLoopForUI message_loop;
  77   scoped_ptr<TestMemoryPressureMonitor> monitor(
  78       new TestMemoryPressureMonitor);
  79   scoped_ptr<MemoryPressureListener> listener(
  80       new MemoryPressureListener(base::Bind(&OnMemoryPressure)));
  81   // Checking the memory pressure while 0% are used should not produce any
  82   // events.
  83   monitor->SetMemoryInPercentOverride(0);
  84   ResetOnMemoryPressureCalled();
  85
  86   monitor->CheckMemoryPressureForTest();
  87   message_loop.RunUntilIdle();
  88   EXPECT_FALSE(WasOnMemoryPressureCalled());
  89   EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
  90             monitor->GetCurrentPressureLevel());
  91
  92   // Setting the memory level to 80% should produce a moderate pressure level.
  93   monitor->SetMemoryInPercentOverride(80);
  94   monitor->CheckMemoryPressureForTest();
  95   message_loop.RunUntilIdle();
  96   EXPECT_TRUE(WasOnMemoryPressureCalled());
  97   EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
  98             monitor->GetCurrentPressureLevel());
  99   EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
 100             on_memory_pressure_level);
 101
 102   // We need to check that the event gets reposted after a while.
 103   int i = 0;
 104   for (; i < 100; i++) {
 105     monitor->CheckMemoryPressureForTest();
 106     message_loop.RunUntilIdle();
 107     EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
 108               monitor->GetCurrentPressureLevel());
 109     if (WasOnMemoryPressureCalled()) {
 110       EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
 111                 on_memory_pressure_level);
 112       break;
 113     }
 114   }
 115   // Should be more then 5 and less then 100.
 116   EXPECT_LE(5, i);
 117   EXPECT_GE(99, i);
 118
 119   // Setting the memory usage to 99% should produce critical levels.
 120   monitor->SetMemoryInPercentOverride(99);
 121   monitor->CheckMemoryPressureForTest();
 122   message_loop.RunUntilIdle();
 123   EXPECT_TRUE(WasOnMemoryPressureCalled());
 124   EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
 125             on_memory_pressure_level);
 126   EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
 127             monitor->GetCurrentPressureLevel());
 128
 129   // Calling it again should immediately produce a second call.
 130   monitor->CheckMemoryPressureForTest();
 131   message_loop.RunUntilIdle();
 132   EXPECT_TRUE(WasOnMemoryPressureCalled());
 133   EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
 134             on_memory_pressure_level);
 135   EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
 136             monitor->GetCurrentPressureLevel());
 137
 138   // When lowering the pressure again we should not get an event, but the
 139   // pressure should go back to moderate.
 140   monitor->SetMemoryInPercentOverride(80);
 141   monitor->CheckMemoryPressureForTest();
 142   message_loop.RunUntilIdle();
 143   EXPECT_FALSE(WasOnMemoryPressureCalled());
 144   EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
 145             monitor->GetCurrentPressureLevel());
 146
 147   // We should need exactly the same amount of calls as before, before the next
 148   // call comes in.
 149   int j = 0;
 150   for (; j < 100; j++) {
 151     monitor->CheckMemoryPressureForTest();
 152     message_loop.RunUntilIdle();
 153     EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
 154               monitor->GetCurrentPressureLevel());
 155     if (WasOnMemoryPressureCalled()) {
 156       EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
 157                 on_memory_pressure_level);
 158       break;
 159     }
 160   }
 161   // We should have needed exactly the same amount of checks as before.
 162   EXPECT_EQ(j, i);
 163 }
 164
 165 }  // namespace chromeos
 166 }  // namespace base