Oilpan: Give a chance to schedule a precise GC after V8 minor and major GCs

Source/bindings/core/v8/V8GCController.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 317 matching lines @@
 {
     v8::HeapStatistics heapStatistics;
     isolate->GetHeapStatistics(&heapStatistics);
     return heapStatistics.used_heap_size();
 }
 
 void V8GCController::gcPrologue(v8::GCType type, v8::GCCallbackFlags flags)
 {
     // FIXME: It would be nice if the GC callbacks passed the Isolate directly....
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
-    if (type == v8::kGCTypeScavenge)
+    if (type == v8::kGCTypeScavenge) {
+        // Finish Oilpan's complete sweeping before running a V8 minor GC.
+        // This will let the minor GC collect more V8 objects.
+        ThreadState::current()->completeSweep();
         minorGCPrologue(isolate);
-    else if (type == v8::kGCTypeMarkSweepCompact)
+    } else if (type == v8::kGCTypeMarkSweepCompact) {
         majorGCPrologue(isolate, flags & v8::kGCCallbackFlagConstructRetainedObjectInfos);
+    }
 }
 
 void V8GCController::minorGCPrologue(v8::Isolate* isolate)
 {
     TRACE_EVENT_BEGIN1("devtools.timeline,v8", "MinorGC", "usedHeapSizeBefore", usedHeapSize(isolate));
     if (isMainThread()) {
         ScriptForbiddenScope::enter();
         {
             TRACE_EVENT_SCOPED_SAMPLING_STATE("blink", "DOMMinorGC");
             v8::HandleScope scope(isolate);
@@ skipping 27 matching lines @@
         visitor.notifyFinished();
     }
 }
 
 void V8GCController::gcEpilogue(v8::GCType type, v8::GCCallbackFlags flags)
 {
     // FIXME: It would be nice if the GC callbacks passed the Isolate directly....
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     if (type == v8::kGCTypeScavenge) {
         minorGCEpilogue(isolate);
+        ThreadState::current()->scheduleV8FollowupGCIfNeeded();
     } else if (type == v8::kGCTypeMarkSweepCompact) {
         majorGCEpilogue(isolate);
+    } else if (type == v8::kGCTypeProcessWeakCallbacks) {
+        ThreadState::current()->scheduleV8FollowupGCIfNeeded();
     }
 
     // v8::kGCCallbackFlagForced forces a Blink heap garbage collection
     // when a garbage collection was forced from V8. This is either used
     // for tests that force GCs from JavaScript to verify that objects die
     // when expected, or when handling memory pressure notifications.
     if (flags & v8::kGCCallbackFlagForced) {
         // This single GC is not enough for two reasons:
         //   (1) The GC is not precise because the GC scans on-stack pointers conservatively.
         //   (2) One GC is not enough to break a chain of persistent handles. It's possible that
@@ skipping 21 matching lines @@
         ScriptForbiddenScope::exit();
     }
 }
 
 void V8GCController::majorGCEpilogue(v8::Isolate* isolate)
 {
     TRACE_EVENT_END1("devtools.timeline,v8", "MajorGC", "usedHeapSizeAfter", usedHeapSize(isolate));
     if (isMainThread()) {
         TRACE_EVENT_SET_NONCONST_SAMPLING_STATE(V8PerIsolateData::from(isolate)->previousSamplingState());
         ScriptForbiddenScope::exit();
-
-        // Schedule an Oilpan GC to avoid the following scenario:
-        // (1) A DOM object X holds a v8::Persistent to a V8 object.
-        //     Assume that X is small but the V8 object is huge.
-        //     The v8::Persistent is released when X is destructed.
-        // (2) X's DOM wrapper is created.
-        // (3) The DOM wrapper becomes unreachable.
-        // (4) V8 triggers a GC. The V8's GC collects the DOM wrapper.
-        //     However, X is not collected until a next Oilpan's GC is
-        //     triggered.
-        // (5) If a lot of such DOM objects are created, we end up with
-        //     a situation where V8's GC collects the DOM wrappers but
-        //     the DOM objects are not collected forever. (Note that
-        //     Oilpan's GC is not triggered unless Oilpan's heap gets full.)
-        // (6) V8 hits OOM.
-        ThreadState::current()->scheduleGCIfNeeded();
     }
 }
 
 void V8GCController::collectGarbage(v8::Isolate* isolate)
 {
     v8::HandleScope handleScope(isolate);
     RefPtr<ScriptState> scriptState = ScriptState::create(v8::Context::New(isolate), DOMWrapperWorld::create(isolate));
     ScriptState::Scope scope(scriptState.get());
     V8ScriptRunner::compileAndRunInternalScript(v8String(isolate, "if (gc) gc();"), isolate);
     scriptState->disposePerContextData();
@@ skipping 35 matching lines @@
     Visitor* m_visitor;
 };
 
 void V8GCController::traceDOMWrappers(v8::Isolate* isolate, Visitor* visitor)
 {
     DOMWrapperTracer tracer(visitor);
     v8::V8::VisitHandlesWithClassIds(isolate, &tracer);
 }
 
 } // namespace blink