Add UMA metrics for desktop memory pressure notifications.

base/memory/memory_pressure_monitor_mac.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 <CoreFoundation/CoreFoundation.h>
 
 #include <dlfcn.h>
 #include <stddef.h>
@@ skipping 86 matching lines @@
     dispatch_source_cancel(memory_level_event_source_);
   }
 }
 
 int MemoryPressureMonitor::GetMacMemoryPressureLevel() {
   // Get the raw memory pressure level from macOS.
   int mac_memory_pressure_level;
   size_t length = sizeof(int);
   sysctlbyname("kern.memorystatus_vm_pressure_level",
                &mac_memory_pressure_level, &length, nullptr, 0);
-
+  printf("kern memory pressure = %d\n", mac_memory_pressure_level);
+  
   return mac_memory_pressure_level;
 }
 
 void MemoryPressureMonitor::UpdatePressureLevel() {
   // Get the current macOS pressure level and convert to the corresponding
   // Chrome pressure level.
   int mac_memory_pressure_level = GetMacMemoryPressureLevel();
+printf("updating pressure level to %d\n", mac_memory_pressure_level);
   MemoryPressureListener::MemoryPressureLevel new_pressure_level =
       MemoryPressureLevelForMacMemoryPressureLevel(mac_memory_pressure_level);
 
   // Compute the number of "ticks" spent at |last_pressure_level_| (since the
   // last report sent to UMA).
   CFTimeInterval now = CFAbsoluteTimeGetCurrent();
   CFTimeInterval time_since_last_report = now - last_statistic_report_time_;
   last_statistic_report_time_ = now;
 
   double accumulated_time = time_since_last_report + subtick_seconds_;
@@ skipping 30 matching lines @@
   }
 }
 
 // Static.
 int MemoryPressureMonitor::GetSecondsPerUMATick() {
   return kUMATickSize;
 }
 
 MemoryPressureListener::MemoryPressureLevel
 MemoryPressureMonitor::GetCurrentPressureLevel() {
-  return last_pressure_level_;
+  MemoryPressureListener::MemoryPressureLevel level = MemoryPressureLevelForMacMemoryPressureLevel(GetMacMemoryPressureLevel());
+printf(" GetCurrentPressureLevel = %d\n", level);
+  return level;
+
+
+  //return last_pressure_level_;
 }
 
 void MemoryPressureMonitor::OnMemoryPressureChanged(
     dispatch_source_s* event_source,
     const MemoryPressureMonitor::DispatchCallback& dispatch_callback) {
   // Get the Chrome-equvialent memory pressure level.
   int mac_memory_pressure_level = dispatch_source_get_data(event_source);
+printf("OnChanged to %d\n", mac_memory_pressure_level);
   MemoryPressureListener::MemoryPressureLevel memory_pressure_level =
       MemoryPressureLevelForMacMemoryPressureLevel(mac_memory_pressure_level);
 
   // Run the callback that's waiting on memory pressure change notifications.
   // Note that we don't bother with updating |last_pressure_level_| or
   // causing memory pressure stats to be sent to UMA. Memory pressure change
   // notifications are delayed on the Mac, so the current actual memory pressure
   // level may be different than the incoming pressure level from the event.
   //
   // In general we don't want to take action (such as freeing memory) on
   // memory pressure change events, but that's how the current system is
   // designed. Given that it's incorrect to act on either stale or current
   // pressure level info, it's not clear which level is better to send. For
   // now stick with how it's been implemented to date, which is to send the
   // stale value.
   if (memory_pressure_level !=
       MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE)
     dispatch_callback.Run(memory_pressure_level);
 }
 
 void MemoryPressureMonitor::SetDispatchCallback(
     const DispatchCallback& callback) {
   dispatch_callback_ = callback;
 }
 
 }  // namespace mac
 }  // namespace base