Do V8 GC ASAP if system memory is pressured

base/memory/memory_pressure_listener.h

 // Copyright 2013 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.
 
 // MemoryPressure provides static APIs for handling memory pressure on
 // platforms that have such signals, such as Android and ChromeOS.
 // The app will try to discard buffers that aren't deemed essential (individual
 // modules will implement their own policy).
 
 #ifndef BASE_MEMORY_MEMORY_PRESSURE_LISTENER_H_
 #define BASE_MEMORY_MEMORY_PRESSURE_LISTENER_H_
 
 #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 {
 
 // To start listening, create a new instance, passing a callback to a
 // function that takes a MemoryPressureLevel parameter. To stop listening,
 // simply delete the listener object. The implementation guarantees
 // that the callback will always be called on the thread that created
 // the listener.
 // Note that even on the same thread, the callback is not guaranteed to be
 // called synchronously within the system memory pressure broadcast.
@@ skipping 12 matching lines @@
 //    MemoryPressureListener* my_listener =
 //        new MemoryPressureListener(base::Bind(&OnMemoryPressure));
 //
 //    ...
 //
 //    // Stop listening.
 //    delete my_listener;
 //
 class BASE_EXPORT MemoryPressureListener {
  public:
+  // ObserverListThreadSafe is RefCountedThreadSafe, this traits is needed

[esprehn, 2016/03/25 09:20:35]

Why does this all need to be moved into the header?

[hong.zheng, 2016/04/01 09:22:34]

According to Mark's comments

+  // 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;
+    }
+  };
+
+  struct MemoryPressureListenerObservers {
+    LazyInstance<ObserverListThreadSafe<MemoryPressureListener>,
+        LeakyLazyObserverListTraits> observers_;
+    LazyInstance<ObserverList<MemoryPressureListener>> sync_observers_;
+    base::LazyInstance<base::Lock>::Leaky sync_observers_lock_;
+  };
+
   // A Java counterpart will be generated for this enum.
   // GENERATED_JAVA_ENUM_PACKAGE: org.chromium.base
   enum MemoryPressureLevel {
     // 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,
 
     // Modules are advised to free buffers that are cheap to re-allocate and not
     // immediately needed.
     MEMORY_PRESSURE_LEVEL_MODERATE = 0,
 
     // 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,
   };
 
   typedef base::Callback<void(MemoryPressureLevel)> MemoryPressureCallback;
+  typedef base::Callback<void(MemoryPressureLevel)> SyncMemoryPressureCallback;
 
   explicit MemoryPressureListener(
       const MemoryPressureCallback& memory_pressure_callback);
+  explicit MemoryPressureListener(
+      const MemoryPressureCallback& memory_pressure_callback,
+      const SyncMemoryPressureCallback& sync_memory_pressure_callback);
+
   ~MemoryPressureListener();
 
   // Intended for use by the platform specific implementation.
   static void NotifyMemoryPressure(MemoryPressureLevel memory_pressure_level);
 
   // These methods should not be used anywhere else but in memory measurement
   // code, where they are intended to maintain stable conditions across
   // measurements.
   static bool AreNotificationsSuppressed();
   static void SetNotificationsSuppressed(bool suppressed);
   static void SimulatePressureNotification(
       MemoryPressureLevel memory_pressure_level);
 
  private:
   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_;
+
+  static MemoryPressureListenerObservers* g_observers;

[esprehn, 2016/03/25 09:20:35]

why does this need to be moved into the header?

[Mark Mentovai, 2016/03/25 16:59:31]

esprehn wrote:
I said in
https://codereview.chromium.org/1749073002/diff/20001/base/memory/memory_pres...
that I thought that it was gross that this singleton object kept some of its
state in member variables and some of its state in globals.

But what was done here is not what I meant at all. This just moved the global to
a static class member, which is the same thing (and private static data usually
doesn’t need to be a class member at all). So no, this is wrong.

I meant that this should stop being static. And when things like this move
around, it’s appropriate to fix the name: the g_ is no longer applicable, but a
trailing underscore is.

[hong.zheng, 2016/04/01 09:22:34]

I am sorry to misunderstand Mark's comments before. I have updated the CL
according to renewed understanding, 

 
   DISALLOW_COPY_AND_ASSIGN(MemoryPressureListener);
 };
 
 }  // namespace base
 
 #endif  // BASE_MEMORY_MEMORY_PRESSURE_LISTENER_H_