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
 
+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);
+  GlobalListener()->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) {
+  GlobalListener()->observers_.Get().AddObserver(this);
+  base::AutoLock lock(GlobalListener()->sync_observers_lock_.Get());

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

Same here and on lines 59 and 111.

+  GlobalListener()->sync_observers_.Get().AddObserver(this);
+}
+
+//static
+MemoryPressureListener* MemoryPressureListener::Create(
+    const MemoryPressureCallback& memory_pressure_callback) {
+  if (!GlobalListener())

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

Why would there not be any GlobalListener()? You’re guarding it here and on line
51, but not 34 or 58.

+    return nullptr;
+  return new MemoryPressureListener(memory_pressure_callback);
+}
+
+//static
+MemoryPressureListener* MemoryPressureListener::Create(
+    const MemoryPressureCallback& memory_pressure_callback,
+    const SyncMemoryPressureCallback& sync_memory_pressure_callback) {
+  if (!GlobalListener())
+    return nullptr;
+  return new MemoryPressureListener(memory_pressure_callback,
+      sync_memory_pressure_callback);
 }
 
 MemoryPressureListener::~MemoryPressureListener() {
-  g_observers.Get().RemoveObserver(this);
+  GlobalListener()->observers_.Get().RemoveObserver(this);
+  base::AutoLock lock(GlobalListener()->sync_observers_lock_.Get());
+  GlobalListener()->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);
+
+  GlobalListener()->observers_.Get().Notify(FROM_HERE,
+      &MemoryPressureListener::Notify, memory_pressure_level);
+  base::AutoLock lock(GlobalListener()->sync_observers_lock_.Get());
+  FOR_EACH_OBSERVER(
+      MemoryPressureListener, GlobalListener()->sync_observers_.Get(),
+      SyncNotify(memory_pressure_level));
+}
+
+//static
+MemoryPressureListener* MemoryPressureListener::GlobalListener() {
+  static MemoryPressureListener* listener = new MemoryPressureListener();

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

This is the thing that should have been the lazy instance. The member variables
don’t need to be. This being lazy would protect those.

[hong.zheng, 2016/04/22 07:14:57]

Done.

+  return listener;

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

Which functions get called on the global listener? Which functions get called on
other listeners? It’s hard to tell, because everything’s all in one class. Whose
member variables are relevant in any given instantiation? Nobody knows! It seems
like those two concepts should be split into distinct classes.

[hong.zheng, 2016/04/22 07:14:57]

Done.

 }
 
 }  // namespace base