[Mac] Return cached pressure level in GetCurrentPressureLevel().

base/memory/memory_pressure_monitor_mac_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/memory/memory_pressure_monitor_mac.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/macros.h"
@@ skipping 10 matching lines @@
   // A HistogramTester for verifying correct UMA stat generation.
   base::HistogramTester tester;
 
   TestMemoryPressureMonitor() { }
 
   // Clears the next run loop update time so that the next pass of the run
   // loop checks the memory pressure level immediately. Normally there's a
   // 5 second delay between pressure readings.
   void ResetRunLoopUpdateTime() { next_run_loop_update_time_ = 0; }
 
-  // Access to the last-recorded memory pressure level.
-  MemoryPressureListener::MemoryPressureLevel LastPressureLevel() {
-    return last_pressure_level_;
-  }
-
   // Sets the last UMA stat report time. Time spent in memory pressure is
   // recorded in 5-second "ticks" from the last time statistics were recorded.
   void SetLastStatisticReportTime(CFTimeInterval time) {
     last_statistic_report_time_ = time;
   }
 
   // Sets the raw macOS memory pressure level read by the memory pressure
   // monitor.
   int macos_pressure_level_for_testing_;
 
@@ skipping 58 matching lines @@
               memory_pressure ==
                   MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE ||
               memory_pressure ==
                   MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
 }
 
 TEST(MacMemoryPressureMonitorTest, MemoryPressureConversion) {
   TestMemoryPressureMonitor monitor;
 
   monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_NORMAL;
+  monitor.UpdatePressureLevel();
   MemoryPressureListener::MemoryPressureLevel memory_pressure =
       monitor.GetCurrentPressureLevel();
-  EXPECT_EQ(memory_pressure,
-            MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE);
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
+            memory_pressure);
 
   monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_WARN;
+  monitor.UpdatePressureLevel();
   memory_pressure = monitor.GetCurrentPressureLevel();
-  EXPECT_EQ(memory_pressure,
-            MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE);
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE,
+            memory_pressure);
 
   monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_CRITICAL;
+  monitor.UpdatePressureLevel();
   memory_pressure = monitor.GetCurrentPressureLevel();
-  EXPECT_EQ(memory_pressure,
-            MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
+  EXPECT_EQ(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL,
+            memory_pressure);
 }
 
 TEST(MacMemoryPressureMonitorTest, MemoryPressureRunLoopChecking) {
   TestMemoryPressureMonitor monitor;
 
   // To test grabbing the memory presure at the end of the run loop, we have to
   // run the run loop, but to do that the run loop needs a run loop source. Add
   // a timer as the source. We know that the exit observer is attached to
   // the kMessageLoopExclusiveRunLoopMode mode, so use that mode.
   ScopedCFTypeRef<CFRunLoopTimerRef> timer_ref(CFRunLoopTimerCreate(
       NULL, CFAbsoluteTimeGetCurrent() + 10, 0, 0, 0, nullptr, nullptr));
   CFRunLoopAddTimer(CFRunLoopGetCurrent(), timer_ref,
                     kMessageLoopExclusiveRunLoopMode);
 
   monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_WARN;
   monitor.ResetRunLoopUpdateTime();
   CFRunLoopRunInMode(kMessageLoopExclusiveRunLoopMode, 0, true);
-  EXPECT_EQ(monitor.LastPressureLevel(),
+  EXPECT_EQ(monitor.GetCurrentPressureLevel(),
             MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE);
 
   monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_CRITICAL;
   monitor.ResetRunLoopUpdateTime();
   CFRunLoopRunInMode(kMessageLoopExclusiveRunLoopMode, 0, true);
-  EXPECT_EQ(monitor.LastPressureLevel(),
+  EXPECT_EQ(monitor.GetCurrentPressureLevel(),
             MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL);
 
   monitor.macos_pressure_level_for_testing_ = DISPATCH_MEMORYPRESSURE_NORMAL;
   monitor.ResetRunLoopUpdateTime();
   CFRunLoopRunInMode(kMessageLoopExclusiveRunLoopMode, 0, true);
-  EXPECT_EQ(monitor.LastPressureLevel(),
+  EXPECT_EQ(monitor.GetCurrentPressureLevel(),
             MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE);
 
   CFRunLoopRemoveTimer(CFRunLoopGetCurrent(), timer_ref,
                        kMessageLoopExclusiveRunLoopMode);
 }
 
 TEST(MacMemoryPressureMonitorTest, RecordMemoryPressureStats) {
   TestMemoryPressureMonitor monitor;
   const char* kHistogram = "Memory.PressureLevel";
   CFTimeInterval now = CFAbsoluteTimeGetCurrent();
@@ skipping 53 matching lines @@
   monitor.tester.ExpectTotalCount(kHistogram, 28);
   monitor.tester.ExpectBucketCount(kHistogram, 0, 7);
   monitor.tester.ExpectBucketCount(kHistogram, 1, 20);
   monitor.tester.ExpectBucketCount(kHistogram, 2, 1);
   // When less than 1 tick of time has elapsed but the pressure level changed,
   // the subtick remainder gets zeroed out.
   EXPECT_EQ(0, monitor.SubTickSeconds());
 }
 }  // namespace mac
 }  // namespace base