Make memory pressure notifier configurable

base/memory/memory_pressure_monitor.h

Index: base/memory/memory_pressure_monitor.h
diff --git a/base/memory/memory_pressure_monitor.h b/base/memory/memory_pressure_monitor.h
index 6073bd3f44ca8f26b953a31967406c747e35bb58..70542f5ebc24fb3ec02eb57b64b03eb15e91edeb 100644
--- a/base/memory/memory_pressure_monitor.h
+++ b/base/memory/memory_pressure_monitor.h
@@ -6,6 +6,7 @@
 #define BASE_MEMORY_MEMORY_PRESSURE_MONITOR_H_
 
 #include "base/base_export.h"
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/memory_pressure_listener.h"
 
@@ -32,10 +33,20 @@ class BASE_EXPORT MemoryPressureMonitor {
   // Returns the currently observed memory pressure.
   virtual MemoryPressureLevel GetCurrentPressureLevel() const = 0;
 
+  // Sets a notification callback. Once a callback is set,

[danakj, 2016/06/30 18:48:05]

I tried to get this from the doc, but I think maybe it's hidden below the
surface of the larger design:
- Why is it a callback instead of a listener interface?
- Why is there only a single listener instead of a set?

[bashi, 2016/06/30 23:33:10]

We are implementing MemoryCoordinator which will replace MemoryPressureListener.
Currently MemoryPressureMonitor lives in base/ and MemoryCoordinator will live
in components/ so I use callback to avoid dependency violation.
I'm afraid you may misunderstand what I'm going to do here. There are some
listeners actually. MemoryPressureListener::NotifyMemoryPressure() is a static
method and  it dispatches listeners owned by a singleton called g_observer. And
what I'm going to do in this CL is to replace it with a callback.

[danakj, 2016/07/01 20:49:28]

A virtual interface would do the same, where MemoryPressureMonitorObserver is an
abstract class in base, and something in components implements it and passes
that to the SetObserver method here. I prefer virtual interfaces to callbacks
for things like this when they make sense (you don't need to bind state into it)
because they are easier to find/understand in codesearch.
I see, so there may be multiple observers, but they would register with the
thing that's listening to this class here.

[bashi, 2016/07/03 23:54:47]

That makes sense. Done.

+  // MemoryPressureMonitor pushes memory pressure notifications to the callback
+  // instead of base::MemoryPressureListener::NotifyMemoryPressure.
+  using Notifier = base::Callback<void(MemoryPressureLevel level)>;

[danakj, 2016/06/30 18:48:05]

"Notifier" is the wrong direction here. The notifier is the monitor. This would
be a Listener or an Observer or the like, it receives notifications.

[bashi, 2016/06/30 23:33:10]

The callback replaces MemoryPressureListener::NotifyMemoryPressure(), which
notifies pressure level.

[danakj, 2016/07/01 20:49:28]

Yes, and the monitor notifies it by that, so it *is* the notifier. The Set here
is coming from someone who wants to be notified, to receive notifications. So
the relationship needs to be inverted in the naming.

+  void SetNotifier(const Notifier& notifier) { notifier_ = notifier; }

[danakj, 2016/07/01 20:49:28]

Can we DCHECK that this is only set once? Or only set to/from null, but not
clobbering a non-null with a non-null? Or do we need to support that?

[bashi, 2016/07/03 23:54:47]

Added DCHECK.

+
+  void Notify(MemoryPressureLevel level);

[bashi, 2016/06/27 03:47:54]

public because this is called by a static method
(mac::MemoryPressureMonitor::NotifyMemoryPressureChanged()).

+
  protected:
   MemoryPressureMonitor();
 
  private:
+  Notifier notifier_;
+
   DISALLOW_COPY_AND_ASSIGN(MemoryPressureMonitor);
 };