Do V8 GC ASAP if system memory is pressured

content/renderer/render_thread_impl.cc

 // 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.
 
 #include "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 145 matching lines @@
 #include "third_party/WebKit/public/web/WebMemoryPressureListener.h"
 #include "third_party/WebKit/public/web/WebNetworkStateNotifier.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebScriptController.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/icu/source/i18n/unicode/timezone.h"
 #include "third_party/skia/include/core/SkGraphics.h"
 #include "ui/base/layout.h"
 #include "ui/base/ui_base_switches.h"
-#include "v8/include/v8.h"
 
 #if defined(OS_ANDROID)
 #include <cpu-features.h>
 #include "content/renderer/android/synchronous_compositor_external_begin_frame_source.h"
 #include "content/renderer/android/synchronous_compositor_factory.h"
 #include "content/renderer/android/synchronous_compositor_filter.h"
 #include "content/renderer/media/android/renderer_demuxer_android.h"
 #include "content/renderer/media/android/stream_texture_factory_impl.h"
 #include "media/base/android/media_codec_util.h"
 #endif
@@ skipping 634 matching lines @@
   media::InitializeMediaLibrary();
 
 #if defined(OS_ANDROID)
   if (!command_line.HasSwitch(switches::kDisableAcceleratedVideoDecode) &&
       media::MediaCodecUtil::IsMediaCodecAvailable()) {
     media::EnablePlatformDecoderSupport();
   }
 #endif
 
   memory_pressure_listener_.reset(new base::MemoryPressureListener(
-      base::Bind(&RenderThreadImpl::OnMemoryPressure, base::Unretained(this))));
+      base::Bind(&RenderThreadImpl::OnMemoryPressure, base::Unretained(this)),
+      base::Bind(&RenderThreadImpl::IsMemoryPressured,
+                 base::Unretained(this))));
 
   int num_raster_threads = 0;
   std::string string_value =
       command_line.GetSwitchValueASCII(switches::kNumRasterThreads);
   bool parsed_num_raster_threads =
       base::StringToInt(string_value, &num_raster_threads);
   DCHECK(parsed_num_raster_threads) << string_value;
   DCHECK_GT(num_raster_threads, 0);
 
 #if defined(OS_ANDROID)
@@ skipping 1175 matching lines @@
   new EmbeddedSharedWorkerStub(params.url,
                                params.name,
                                params.content_security_policy,
                                params.security_policy_type,
                                params.pause_on_start,
                                params.route_id);
 }
 
 void RenderThreadImpl::OnMemoryPressure(
     base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) {
+  TRACE_EVENT0("memory","RenderThreadImpl::OnMemoryPressure");
   ReleaseFreeMemory();
 
   // Do not call into blink if it is not initialized.
   if (blink_platform_impl_) {
     blink::WebMemoryPressureListener::onMemoryPressure(
         static_cast<blink::WebMemoryPressureLevel>(memory_pressure_level));
 
     if (blink::mainThreadIsolate()) {
       // Trigger full v8 garbage collection on memory pressure notifications.
       // This will potentially hang the renderer for a long time, however, when
       // we receive a memory pressure notification, we might be about to be
       // killed.
-      blink::mainThreadIsolate()->LowMemoryNotification();
+      if (is_v8_need_gc_) {
+        blink::mainThreadIsolate()->LowMemoryNotification();
+        is_v8_need_gc_ = false;
+      }
+
       RenderThread::Get()->PostTaskToAllWebWorkers(
           base::Bind(&LowMemoryNotificationOnThisThread));
     }
 
     if (memory_pressure_level ==
         base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
       // Purge Skia font cache, by setting it to 0 and then again to the
       // previous limit.
       size_t font_cache_limit = SkGraphics::SetFontCacheLimit(0);
       SkGraphics::SetFontCacheLimit(font_cache_limit);
@@ skipping 138 matching lines @@
 RenderThreadImpl::PendingRenderFrameConnect::~PendingRenderFrameConnect() {
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
+void RenderThreadImpl::OnV8InterruptCallback(v8::Isolate* isolate, void* data) {
+  RenderThreadImpl* pRenderThreadImpl =
+      reinterpret_cast<RenderThreadImpl*>(data);
+  if (!pRenderThreadImpl || !pRenderThreadImpl->is_v8_need_gc_)
+    return;
+  blink::mainThreadIsolate()->LowMemoryNotification();

[esprehn, 2016/03/01 22:15:07]

Is this safe? You're using the LowMemoryNotification method on Isolate from the
wrong thread, I don't think that's okay.

+  pRenderThreadImpl->is_v8_need_gc_ = false;
+}
+
+void RenderThreadImpl::IsMemoryPressured(bool memory_pressured) {
+  is_v8_need_gc_ = true;
+  blink::mainThreadIsolate()->RequestInterrupt(&OnV8InterruptCallback, this);

[jochen (gone - plz use gerrit), 2016/03/02 07:59:38]

the interrupt callback must not reenter V8.

+}
+
 }  // namespace content