Shutdown renderer main message loop before blink::shutdown()

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 959 matching lines @@
   ChildThreadImpl::Shutdown();
 
   // Shut down the message loop (if provided when the RenderThreadImpl was
   // constructed) and the renderer scheduler before shutting down Blink. This
   // prevents a scenario where a pending task in the message loop accesses Blink
   // objects after Blink shuts down.
   renderer_scheduler_->SetRAILModeObserver(nullptr);
   renderer_scheduler_->Shutdown();
   if (main_message_loop_)
     base::RunLoop().RunUntilIdle();
+  main_message_loop_ = nullptr;
 
   if (blink_platform_impl_) {
     blink_platform_impl_->Shutdown();
     // This must be at the very end of the shutdown sequence.
     // blink::shutdown() must be called after all strong references from
     // Chromium to Blink are cleared.
     blink::shutdown();
   }
 
   // Delay shutting down DiscardableSharedMemoryManager until blink::shutdown
   // is complete, because blink::shutdown destructs Blink Resources and they
   // may try to unlock their underlying discardable memory.
   ChildThreadImpl::ShutdownDiscardableSharedMemoryManager();
 
-  // The message loop must be cleared after shutting down
-  // the DiscardableSharedMemoryManager, which needs to send messages
-  // to the browser process.

[esprehn, 2016/07/19 16:42:54]

You're doing the opposite of what the comment says we have to do now, why is
that correct? You now destroy the message loop before the discardable memory
manager shuts down which means the IPCs won't make it out.

[tzik, 2016/07/19 17:26:52]

The comment looks inaccurate to me.
ChildDiscardableSharedMemoryManager spins the message loop only for a sync IPC
for allocation, and doesn't use it for shutdown.
Though it uses the main thread task runner to check if the current thread is the
main thread, the message loop itself is not needed for it.

-  main_message_loop_.reset();
-
   lazy_tls.Pointer()->Set(nullptr);
 }
 
 bool RenderThreadImpl::Send(IPC::Message* msg) {
   // There are cases where we want to pump asynchronous messages while waiting
   // synchronously for the replies to the message to be sent here. However, this
   // may create an opportunity for re-entrancy into WebKit and other subsystems,
   // so we need to take care to disable callbacks, timers, and pending network
   // loads that could trigger such callbacks.
   bool pumping_events = false;
@@ skipping 1220 matching lines @@
       v8_memory_pressure_level == v8::MemoryPressureLevel::kCritical)
     v8_memory_pressure_level = v8::MemoryPressureLevel::kModerate;
 
   blink::mainThreadIsolate()->MemoryPressureNotification(
       v8_memory_pressure_level);
   blink::MemoryPressureNotificationToWorkerThreadIsolates(
       v8_memory_pressure_level);
 }
 
 }  // namespace content