Do V8 GC ASAP if system memory is pressured

base/memory/memory_pressure_listener.h

Index: base/memory/memory_pressure_listener.h
diff --git a/base/memory/memory_pressure_listener.h b/base/memory/memory_pressure_listener.h
index a6ce702ccb0f68df89a80b53934a884f4463926f..5308e31c152684aa8de003ff1336b411a12bfbd7 100644
--- a/base/memory/memory_pressure_listener.h
+++ b/base/memory/memory_pressure_listener.h
@@ -12,7 +12,9 @@
 
 #include "base/base_export.h"
 #include "base/callback.h"
+#include "base/lazy_instance.h"
 #include "base/macros.h"
+#include "base/observer_list_threadsafe.h"
 
 namespace base {
 
@@ -51,22 +53,27 @@ class BASE_EXPORT MemoryPressureListener {
     // No problems, there is enough memory to use. This event is not sent via
     // callback, but the enum is used in other places to find out the current
     // state of the system.
-    MEMORY_PRESSURE_LEVEL_NONE = -1,
+    MEMORY_PRESSURE_LEVEL_NONE,
 
     // Modules are advised to free buffers that are cheap to re-allocate and not
     // immediately needed.
-    MEMORY_PRESSURE_LEVEL_MODERATE = 0,
+    MEMORY_PRESSURE_LEVEL_MODERATE,
 
     // At this level, modules are advised to free all possible memory.  The
     // alternative is to be killed by the system, which means all memory will
     // have to be re-created, plus the cost of a cold start.
-    MEMORY_PRESSURE_LEVEL_CRITICAL = 2,
+    MEMORY_PRESSURE_LEVEL_CRITICAL,
   };
 
   typedef base::Callback<void(MemoryPressureLevel)> MemoryPressureCallback;
+  typedef base::Callback<void(MemoryPressureLevel)> SyncMemoryPressureCallback;
 
   explicit MemoryPressureListener(
       const MemoryPressureCallback& memory_pressure_callback);
+  MemoryPressureListener(
+      const MemoryPressureCallback& memory_pressure_callback,
+      const SyncMemoryPressureCallback& sync_memory_pressure_callback);
+
   ~MemoryPressureListener();
 
   // Intended for use by the platform specific implementation.
@@ -81,11 +88,38 @@ class BASE_EXPORT MemoryPressureListener {
       MemoryPressureLevel memory_pressure_level);
 
  private:
+  // ObserverListThreadSafe is RefCountedThreadSafe, this traits is needed
+  // to ensure the LazyInstance will hold a reference to it.
+  struct LeakyLazyObserverListTraits :
+      base::internal::LeakyLazyInstanceTraits<
+          ObserverListThreadSafe<MemoryPressureListener> > {
+    static ObserverListThreadSafe<MemoryPressureListener>*
+        New(void* instance) {
+      ObserverListThreadSafe<MemoryPressureListener>* ret =
+          base::internal::LeakyLazyInstanceTraits<
+              ObserverListThreadSafe<MemoryPressureListener>>::New(instance);
+      // Leaky.
+      ret->AddRef();
+      return ret;
+    }
+  };
+
+  MemoryPressureListener();
+
   void Notify(MemoryPressureLevel memory_pressure_level);
+  void SyncNotify(MemoryPressureLevel memory_pressure_level);
 
   static void DoNotifyMemoryPressure(MemoryPressureLevel memory_pressure_level);
 
   MemoryPressureCallback callback_;
+  SyncMemoryPressureCallback sync_memory_pressure_callback_;
+
+  LazyInstance<ObserverListThreadSafe<MemoryPressureListener>,
+      LeakyLazyObserverListTraits> observers_;
+  LazyInstance<ObserverList<MemoryPressureListener>> sync_observers_;
+  base::LazyInstance<base::Lock>::Leaky sync_observers_lock_;
+
+  static MemoryPressureListener* g_listener;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryPressureListener);
 };