Do V8 GC ASAP if system memory is pressured

base/memory/memory_pressure_listener.cc

 // 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.
 
 #include "base/memory/memory_pressure_listener.h"
 
-#include "base/lazy_instance.h"
-#include "base/observer_list_threadsafe.h"
 #include "base/trace_event/trace_event.h"
 
 namespace base {
 
 namespace {
 
-// 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;
-  }
-};
-
-LazyInstance<
-    ObserverListThreadSafe<MemoryPressureListener>,
-    LeakyLazyObserverListTraits> g_observers = LAZY_INSTANCE_INITIALIZER;
-
-// All memory pressure notifications within this process will be suppressed if
-// this variable is set to 1.
 subtle::Atomic32 g_notifications_suppressed = 0;
 
 }  // namespace
 
+//static
+MemoryPressureListener* MemoryPressureListener::g_listener =
+    new MemoryPressureListener();

[Mark Mentovai, 2016/04/20 13:21:33]

This results in a module initializer. Can’t do that.

[hong.zheng, 2016/04/21 12:18:04]

Done.

+
+MemoryPressureListener::MemoryPressureListener()
+    : observers_(LAZY_INSTANCE_INITIALIZER),
+      sync_observers_(LAZY_INSTANCE_INITIALIZER),
+      sync_observers_lock_(LAZY_INSTANCE_INITIALIZER) {}
+
 MemoryPressureListener::MemoryPressureListener(
     const MemoryPressureListener::MemoryPressureCallback& callback)
     : callback_(callback) {
-  g_observers.Get().AddObserver(this);
+  g_listener->observers_.Get().AddObserver(this);
+}
+
+MemoryPressureListener::MemoryPressureListener(
+    const MemoryPressureListener::MemoryPressureCallback& callback,
+    const MemoryPressureListener::SyncMemoryPressureCallback&
+        sync_memory_pressure_callback)
+    : callback_(callback),
+      sync_memory_pressure_callback_(sync_memory_pressure_callback) {
+  g_listener->observers_.Get().AddObserver(this);
+  base::AutoLock lock(g_listener->sync_observers_lock_.Get());
+  g_listener->sync_observers_.Get().AddObserver(this);
 }
 
 MemoryPressureListener::~MemoryPressureListener() {
-  g_observers.Get().RemoveObserver(this);
+  g_listener->observers_.Get().RemoveObserver(this);
+  base::AutoLock lock(g_listener->sync_observers_lock_.Get());
+  g_listener->sync_observers_.Get().RemoveObserver(this);
 }
 
 void MemoryPressureListener::Notify(MemoryPressureLevel memory_pressure_level) {
   callback_.Run(memory_pressure_level);
 }
 
+void MemoryPressureListener::SyncNotify(
+    MemoryPressureLevel memory_pressure_level) {
+  if (!sync_memory_pressure_callback_.is_null()) {
+    sync_memory_pressure_callback_.Run(memory_pressure_level);
+  }
+}
+
 // static
 void MemoryPressureListener::NotifyMemoryPressure(
     MemoryPressureLevel memory_pressure_level) {
   DCHECK_NE(memory_pressure_level, MEMORY_PRESSURE_LEVEL_NONE);
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("memory-infra"),
                        "MemoryPressureListener::NotifyMemoryPressure",
                        TRACE_EVENT_SCOPE_THREAD, "level",
                        memory_pressure_level);
   if (AreNotificationsSuppressed())
     return;
@@ skipping 14 matching lines @@
 void MemoryPressureListener::SimulatePressureNotification(
     MemoryPressureLevel memory_pressure_level) {
   // Notify all listeners even if regular pressure notifications are suppressed.
   DoNotifyMemoryPressure(memory_pressure_level);
 }
 
 // static
 void MemoryPressureListener::DoNotifyMemoryPressure(
     MemoryPressureLevel memory_pressure_level) {
   DCHECK_NE(memory_pressure_level, MEMORY_PRESSURE_LEVEL_NONE);
-  g_observers.Get().Notify(FROM_HERE, &MemoryPressureListener::Notify,
-                           memory_pressure_level);
+
+  g_listener->observers_.Get().Notify(FROM_HERE,
+      &MemoryPressureListener::Notify, memory_pressure_level);
+  base::AutoLock lock(g_listener->sync_observers_lock_.Get());
+  FOR_EACH_OBSERVER(
+      MemoryPressureListener, g_listener->sync_observers_.Get(),
+      SyncNotify(memory_pressure_level));
 }
 
 }  // namespace base