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 679 matching lines @@
   peer_connection_tracker_.reset(new PeerConnectionTracker());
   AddObserver(peer_connection_tracker_.get());
 
   p2p_socket_dispatcher_ = new P2PSocketDispatcher(GetIOTaskRunner().get());
   AddFilter(p2p_socket_dispatcher_.get());
 
   peer_connection_factory_.reset(
       new PeerConnectionDependencyFactory(p2p_socket_dispatcher_.get()));
 
   aec_dump_message_filter_ = new AecDumpMessageFilter(
-      GetIOTaskRunner(), message_loop()->task_runner());
+      GetIOTaskRunner(), main_task_runner());
 
   AddFilter(aec_dump_message_filter_.get());
 
 #endif  // defined(ENABLE_WEBRTC)
 
   audio_input_message_filter_ = new AudioInputMessageFilter(GetIOTaskRunner());
   AddFilter(audio_input_message_filter_.get());
 
   audio_message_filter_ = new AudioMessageFilter(GetIOTaskRunner());
   AddFilter(audio_message_filter_.get());
@@ skipping 269 matching lines @@
   renderer_scheduler_->Shutdown();
   if (main_message_loop_)
     base::RunLoop().RunUntilIdle();
 
   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();
+
+    // Clear the message loop here because pending tasks can hold Persintent
+    // handle to GCed object, which can not outlive Oilpan heap.
+    if (main_message_loop_)
+      base::RunLoop().RunUntilIdle();

[kinuko, 2016/08/09 14:12:18]

Hmm, I feel uneasy calling this in production code. Do we really have a
guarantee that this finishes? In browser process we prefer just dropping tasks
at least after processing limited # of tasks.

How frequently does the crash happen?

[haraken, 2016/08/09 15:46:58]

Note that we're already calling RunUntilIdle at line 982. So this RunUntileIdle
won't make things that worse.

On the other hand, I totally agree with your point and that's why I want to
entirely remove the graceful shutdown sequence.

[kinuko, 2016/08/11 06:10:55]

I see that we're already calling it... thanks.  Another question is if we are
sure that running message loop until idle runs tasks that need to run (e.g. no
delayed tasks would hold persistent handles)-- if not making this change as a
stop-gap doesn't feel very convincing to me (depending on the severity of the
original crash).

+    main_message_loop_ = nullptr;
+
+    blink::Platform::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.
-  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 166 matching lines @@
 #ifdef ENABLE_VTUNE_JIT_INTERFACE
   if (command_line.HasSwitch(switches::kEnableVtune))
     gin::Debug::SetJitCodeEventHandler(vTune::GetVtuneCodeEventHandler());
 #endif
 
   SetRuntimeFeaturesDefaultsAndUpdateFromArgs(command_line);
 
   blink_platform_impl_.reset(new RendererBlinkPlatformImpl(
       renderer_scheduler_.get(),
       GetRemoteInterfaces()->GetWeakPtr()));
-  blink::initialize(blink_platform_impl_.get());
+  blink::Platform::initialize(blink_platform_impl_.get());
+  blink::initialize();
 
   v8::Isolate* isolate = blink::mainThreadIsolate();
   isolate->SetCreateHistogramFunction(CreateHistogram);
   isolate->SetAddHistogramSampleFunction(AddHistogramSample);
   renderer_scheduler_->SetRAILModeObserver(this);
 
   main_thread_compositor_task_runner_ =
       renderer_scheduler_->CompositorTaskRunner();
 
   main_input_callback_.Reset(
@@ skipping 863 matching lines @@
       // 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);
     }
   }
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RenderThreadImpl::GetFileThreadTaskRunner() {
-  DCHECK(message_loop()->task_runner()->BelongsToCurrentThread());
+  DCHECK(main_task_runner()->BelongsToCurrentThread());
   if (!file_thread_) {
     file_thread_.reset(new base::Thread("Renderer::FILE"));
     file_thread_->Start();
   }
   return file_thread_->task_runner();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 RenderThreadImpl::GetMediaThreadTaskRunner() {
-  DCHECK(message_loop()->task_runner()->BelongsToCurrentThread());
+  DCHECK(main_task_runner()->BelongsToCurrentThread());
   if (!media_thread_) {
     media_thread_.reset(new base::Thread("Media"));
     media_thread_->Start();
 
 #if defined(OS_ANDROID)
     renderer_demuxer_ = new RendererDemuxerAndroid();
     AddFilter(renderer_demuxer_.get());
 #endif
   }
   return media_thread_->task_runner();
@@ skipping 142 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