Create base::win::MemoryPressureMonitor class.

base/win/memory_pressure_monitor.h

Index: base/win/memory_pressure_monitor.h
diff --git a/base/win/memory_pressure_monitor.h b/base/win/memory_pressure_monitor.h
new file mode 100644
index 0000000000000000000000000000000000000000..d78e6ae841435bdb25bd6bd2a6c523dd80f1c993
--- /dev/null
+++ b/base/win/memory_pressure_monitor.h
@@ -0,0 +1,96 @@
+// 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.
+
+#ifndef BASE_WIN_MEMORY_PRESSURE_MONITOR_WIN_H_
+#define BASE_WIN_MEMORY_PRESSURE_MONITOR_WIN_H_
+
+#include "base/base_export.h"
+#include "base/memory/memory_pressure_listener.h"
+#include "base/memory/memory_pressure_monitor.h"
+#include "base/memory/weak_ptr.h"
+#include "base/synchronization/lock.h"
+#include "base/timer/timer.h"
+
+// Forward declaration. This is defined by windows.h.
+struct _MEMORYSTATUSEX;

[Nico, 2015/05/05 21:25:12]

If you want, you can also say

typedef struct _MEMORYSTATUSEX MEMORYSTATUSEX;

then you don't need all these underscores everywhere.

(nit: remove "forward declaration" from the comment, that's just filler. "// To
not pull in Windows.h" is a better comment imho)

[chrisha, 2015/05/06 02:40:24]

Done.

+
+namespace base {
+namespace win {
+
+class TestMemoryPressureMonitor;
+
+// Windows memory pressure monitor. Because there is no OS provided signal this
+// polls at a low frequency (once per second), and applies internal hysteresis.

[Nico, 2015/05/05 21:25:12]

:-(

Is once per minute enough?

Can we make it obvious in the api that registering an observer is expensive on
windows and mostly compute this on demand when needed?

[chrisha, 2015/05/06 02:40:24]

Once per minute is maybe too low, but we could likely strike a compromise here.
If we did change this I would prefer it be adaptive depending on memory load
(ie: poll more frequently when memory activity is high). Thoughts?

+class BASE_EXPORT MemoryPressureMonitor : public base::MemoryPressureMonitor {
+ public:
+  using MemoryPressureLevel = base::MemoryPressureListener::MemoryPressureLevel;
+
+  MemoryPressureMonitor();
+  virtual ~MemoryPressureMonitor() override;

[Nico, 2015/05/05 21:25:11]

no virtual

[chrisha, 2015/05/06 02:40:24]

Done.

+
+  // Schedules a memory pressure check to run soon on the current thread.
+  void CheckMemoryPressureSoon();
+
+  // Get the current memory pressure level.
+  MemoryPressureLevel GetCurrentPressureLevel() const override;
+
+ private:
+  friend TestMemoryPressureMonitor;
+
+  // Starts observing the memory fill level.
+  // Calls to StartObserving should always be matched with calls to
+  // StopObserving.
+  void StartObserving();
+
+  // Stop observing the memory fill level.
+  // May be safely called if StartObserving has not been called.
+  void StopObserving();
+
+  // Checks memory pressure, storing the current level, applying any hysteresis
+  // and emitting memory pressure level change signals as necessary. This
+  // function is called periodically while the monitor is observing memory
+  // pressure. This is split out from CheckMemoryPressureAndRecordStatistics so
+  // that it may be called by CheckMemoryPressureSoon and not invoke UMA
+  // logging. Acquires and runs under lock_.
+  void CheckMemoryPressure();
+
+  // Wrapper to CheckMemoryPressure that also records the observed memory
+  // pressure level via an UMA enumeration. This is the function that is called
+  // periodically by the timer.
+  void CheckMemoryPressureAndRecordStatistics();
+
+  // Calculates the current instantaneous memory pressure level. This does not
+  // use any hysteresis and simply returns the result at the current moment.
+  MemoryPressureLevel CalculateCurrentPressureLevel();
+
+  // Gets system memory status. This is virtual as a unittesting hook.
+  // Returns true if the system call succeeds, false otherwise.
+  virtual bool GetSystemMemoryStatus(_MEMORYSTATUSEX* mem_status);
+
+  // A periodic timer to check for memory pressure changes.
+  base::RepeatingTimer<MemoryPressureMonitor> timer_;
+
+  // A lock for synchronizing access to this class.
+  base::Lock lock_;
+
+  // The current memory pressure.
+  MemoryPressureLevel current_memory_pressure_level_;  // Under |lock_|.
+
+  // To slow down the amount of moderate pressure event calls, this gets used to
+  // count the number of events since the last event occured. This is used by
+  // |CheckMemoryPressure| to apply hysteresis on the raw results of
+  // |CalculateCurrentPressureLevel|.
+  int moderate_pressure_repeat_count_;  // Under |lock_|.
+
+  // Weak pointer factory to ourself used for scheduling calls to
+  // CheckMemoryPressure/CheckMemoryPressureAndRecordStatistics via |timer_|.
+  base::WeakPtrFactory<MemoryPressureMonitor> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(MemoryPressureMonitor);
+};
+
+}  // namespace win
+}  // namespace base
+
+#endif  // BASE_WIN_MEMORY_PRESSURE_MONITOR_WIN_H_