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