Shut down all threads before the main thread shuts down

third_party/WebKit/Source/web/WebKit.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 123 matching lines @@
 static void callOnMainThreadFunction(WTF::MainThreadFunction function, void* context)
 {
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(function, AllowCrossThreadAccess(context)));
 }
 
 static void adjustAmountOfExternalAllocatedMemory(int size)
 {
     v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(size);
 }
 
+static ModulesInitializer& modulesInitializer()
+{
+    DEFINE_STATIC_LOCAL(OwnPtr<ModulesInitializer>, initializer, (adoptPtr(new ModulesInitializer)));
+    return *initializer;
+}
+
 void initializeWithoutV8(Platform* platform)
 {
     ASSERT(!s_webKitInitialized);
     s_webKitInitialized = true;
 
     WTF::Partitions::initialize(maxObservedSizeFunction);
     ASSERT(platform);
     Platform::initialize(platform);
 
     WTF::initialize(adjustAmountOfExternalAllocatedMemory);
     WTF::initializeMainThread(callOnMainThreadFunction);
     Heap::init();
 
     ThreadState::attachMainThread();
     // currentThread() is null if we are running on a thread without a message loop.
     if (WebThread* currentThread = platform->currentThread()) {
         ASSERT(!s_gcTaskRunner);
         s_gcTaskRunner = new GCTaskRunner(currentThread);
     }
 
-    DEFINE_STATIC_LOCAL(ModulesInitializer, initializer, ());
-    initializer.init();
+    modulesInitializer().init();
 
     setIndexedDBClientCreateFunction(IndexedDBClientImpl::create);
 }
 
 void shutdown()
 {
 #if defined(LEAK_SANITIZER)
     // If LSan is about to perform leak detection, release all the registered
     // static Persistent<> root references to global caches that Blink keeps,
     // followed by GCs to clear out all they referred to. A full v8 GC cycle
@@ skipping 11 matching lines @@
     // currentThread() is null if we are running on a thread without a message loop.
     if (Platform::current()->currentThread()) {
         Platform::current()->unregisterMemoryDumpProvider(WebCacheMemoryDumpProvider::instance());
         Platform::current()->unregisterMemoryDumpProvider(FontCacheMemoryDumpProvider::instance());
 
         // We don't need to (cannot) remove s_endOfTaskRunner from the current
         // message loop, because the message loop is already destructed before
         // the shutdown() is called.
         delete s_endOfTaskRunner;
         s_endOfTaskRunner = nullptr;
-
-        ASSERT(s_gcTaskRunner);
-        delete s_gcTaskRunner;
-        s_gcTaskRunner = nullptr;
     }
 
     // Shutdown V8-related background threads before V8 is ramped down. Note
     // that this will wait the thread to stop its operations.
     ScriptStreamerThread::shutdown();
 
+    ThreadState::current()->unregisterTraceDOMWrappers();

[sof, 2016/03/07 07:29:28]

Why is this needed now & here? (sorry, haven't followed the patchset updates
here.)

[haraken, 2016/03/07 07:33:56]

ThreadState::detachMainThread can trigger an Oilpan's GC. The Oilpan GC should
not trace V8 wrappers because the isolate is already existed at that point. Also
the Oilpan GC should assume that no V8 wrappers are reachable at that point. So
I added unregisterTraceDOMWrapper here to let Oilpan know about it before the
isolate gets destroyed.

[sof, 2016/03/07 07:54:03]

I see, and this "detach" of v8 from Oilpan needs to be handled separately from
detachMainThread(). Can detachMainThread() assert that the v8 detach has
happened?

[haraken, 2016/03/07 08:02:34]

Done.

+
     v8::Isolate* isolate = V8PerIsolateData::mainThreadIsolate();
     V8PerIsolateData::willBeDestroyed(isolate);
 
-    CoreInitializer::terminateThreads();
-
-    ModulesInitializer::terminateThreads();
-
-    // Detach the main thread before starting the shutdown sequence
-    // so that the main thread won't get involved in a GC during the shutdown.
-    ThreadState::detachMainThread();
-
     V8PerIsolateData::destroy(isolate);
 
     shutdownWithoutV8();
 }
 
 void shutdownWithoutV8()
 {
+    ASSERT(isMainThread());
+    modulesInitializer().shutdown();
+
+    // currentThread() is null if we are running on a thread without a message loop.
+    if (Platform::current()->currentThread()) {
+        ASSERT(s_gcTaskRunner);
+        delete s_gcTaskRunner;
+        s_gcTaskRunner = nullptr;
+    }
+
+    // Detach the main thread before starting the shutdown sequence
+    // so that the main thread won't get involved in a GC during the shutdown.
+    ThreadState::detachMainThread();
+
     ASSERT(!s_endOfTaskRunner);
-    CoreInitializer::shutdown();
     Heap::shutdown();
     WTF::shutdown();
     Platform::shutdown();
     WebPrerenderingSupport::shutdown();
     WTF::Partitions::shutdown();
 }
 
 // TODO(tkent): The following functions to wrap LayoutTestSupport should be
 // moved to public/platform/.
 
@@ skipping 46 matching lines @@
     ASSERT(!reloadPages);
     Page::refreshPlugins();
 }
 
 void decommitFreeableMemory()
 {
     WTF::Partitions::decommitFreeableMemory();
 }
 
 } // namespace blink