Do V8 GC ASAP if system memory is pressured

base/observer_list_threadsafe.h

 // Copyright (c) 2012 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.
 
 #ifndef BASE_OBSERVER_LIST_THREADSAFE_H_
 #define BASE_OBSERVER_LIST_THREADSAFE_H_
 
 #include <algorithm>
 #include <map>
 
@@ skipping 173 matching lines @@
     for (const auto& entry : observer_lists_) {
       ObserverListContext* context = entry.second;
       context->task_runner->PostTask(
           from_here,
           Bind(&ObserverListThreadSafe<ObserverType>::template NotifyWrapper<
                   Method, Tuple<Params...>>,
               this, context, method));
     }
   }
 
+  // SyncNotify methods.
+  // Make a thread-safe callback to each Observer in the list.
+  // Note, these calls are synchronous.

[Mark Mentovai, 2016/03/01 15:21:20]

…and happen on thread that calls SyncNotify, which does not match the expected
semantics of ObserverListThreadSafe. ObserverListThreadSafe callbacks run on the
threads that registered the observers.

The “synchronous” observer list implementation is ObserverList. If you need
something synchronous and can accept the caveat that callbacks run on the thread
that is calling Notify, not the threads that registered the observers, then you
should be using ObserverList instead. If you need these semantics in a
multi-threaded situation, use an ObserverList protected by suitable locking.

Refer to the comments at the top of observer_list_threadsafe.h for more details.

+  template <class Method, class... Params>
+  void SyncNotify(const tracked_objects::Location& from_here,
+                  Method m,
+                  const Params&... params) {
+    internal::UnboundMethod<ObserverType, Method, Tuple<Params...>> method(
+        m, MakeTuple(params...));
+
+    AutoLock lock(list_lock_);
+    for (const auto& entry : observer_lists_) {
+      ObserverListContext* context = entry.second;
+      typename ObserverList<ObserverType>::Iterator it(&context->list);
+      ObserverType* obs;
+      while ((obs = it.GetNext()) != nullptr)
+        method.Run(obs);
+    }
+  }
+
  private:
   // See comment above ObserverListThreadSafeTraits' definition.
   friend struct ObserverListThreadSafeTraits<ObserverType>;
 
   struct ObserverListContext {
     explicit ObserverListContext(NotificationType type)
         : task_runner(ThreadTaskRunnerHandle::Get()), list(type) {}
 
     scoped_refptr<SingleThreadTaskRunner> task_runner;
     ObserverList<ObserverType> list;
@@ skipping 59 matching lines @@
   mutable Lock list_lock_;  // Protects the observer_lists_.
   ObserversListMap observer_lists_;
   const NotificationType type_;
 
   DISALLOW_COPY_AND_ASSIGN(ObserverListThreadSafe);
 };
 
 }  // namespace base
 
 #endif  // BASE_OBSERVER_LIST_THREADSAFE_H_