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

content/child/child_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/child/child_thread_impl.h"
 
 #include <signal.h>
 #include <string>
 #include <utility>
 
@@ skipping 386 matching lines @@
   VLOG(1) << "Mojo is disabled on child";
   channel_->Init(channel_name_, IPC::Channel::MODE_CLIENT, create_pipe_now);
 }
 
 void ChildThreadImpl::Init(const Options& options) {
   channel_name_ = options.channel_name;
 
   g_lazy_tls.Pointer()->Set(this);
   on_channel_error_called_ = false;
   message_loop_ = base::MessageLoop::current();
+  main_task_runner_ = message_loop_->task_runner();
 #ifdef IPC_MESSAGE_LOG_ENABLED
   // We must make sure to instantiate the IPC Logger *before* we create the
   // channel, otherwise we can get a callback on the IO thread which creates
   // the logger, and the logger does not like being created on the IO thread.
   IPC::Logging::GetInstance();
 #endif
 
   IPC::AttachmentBrokerUnprivileged::CreateBrokerIfNeeded();
 
   channel_ =
@@ skipping 42 matching lines @@
     // ConnectionFilter.
     mojo_shell_connection_->SetupInterfaceRequestProxies(
         GetInterfaceRegistry(), remote_interfaces);
 
     if (options.auto_start_mojo_shell_connection)
       StartMojoShellConnection();
   }
 
   sync_message_filter_ = channel_->CreateSyncMessageFilter();
   thread_safe_sender_ = new ThreadSafeSender(
-      message_loop_->task_runner(), sync_message_filter_.get());
+      main_task_runner_, sync_message_filter_.get());
 
   resource_dispatcher_.reset(new ResourceDispatcher(
       this, message_loop()->task_runner()));
   websocket_dispatcher_.reset(new WebSocketDispatcher);
   file_system_dispatcher_.reset(new FileSystemDispatcher());
 
   histogram_message_filter_ = new ChildHistogramMessageFilter();
   resource_message_filter_ =
       new ChildResourceMessageFilter(resource_dispatcher());
 
@@ skipping 57 matching lines @@
   int connection_timeout = kConnectionTimeoutS;
   std::string connection_override =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kIPCConnectionTimeout);
   if (!connection_override.empty()) {
     int temp;
     if (base::StringToInt(connection_override, &temp))
       connection_timeout = temp;
   }
 
-  message_loop_->task_runner()->PostDelayedTask(
+  main_task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&ChildThreadImpl::EnsureConnected,
                             channel_connected_factory_->GetWeakPtr()),
       base::TimeDelta::FromSeconds(connection_timeout));
 
 #if defined(OS_ANDROID)
   g_quit_closure.Get().BindToMainThread();
 #endif
 
   shared_bitmap_manager_.reset(
       new ChildSharedBitmapManager(thread_safe_sender()));
@@ skipping 28 matching lines @@
   channel_->ClearIPCTaskRunner();
   g_lazy_tls.Pointer()->Set(NULL);
 }
 
 void ChildThreadImpl::Shutdown() {
   // Delete objects that hold references to blink so derived classes can
   // safely shutdown blink in their Shutdown implementation.
   file_system_dispatcher_.reset();
   quota_dispatcher_.reset();
   WebFileSystemImpl::DeleteThreadSpecificInstance();
+  message_loop_ = nullptr;
 }
 
 void ChildThreadImpl::ShutdownDiscardableSharedMemoryManager() {
   discardable_shared_memory_manager_.reset();
 }
 
 void ChildThreadImpl::OnChannelConnected(int32_t peer_pid) {
   channel_connected_factory_.reset();
 }
 
 void ChildThreadImpl::OnChannelError() {
   on_channel_error_called_ = true;
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 bool ChildThreadImpl::Send(IPC::Message* msg) {
-  DCHECK(message_loop_->task_runner()->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (!channel_) {
     delete msg;
     return false;
   }
 
   return channel_->Send(msg);
 }
 
 #if defined(OS_WIN)
 void ChildThreadImpl::PreCacheFont(const LOGFONT& log_font) {
@@ skipping 26 matching lines @@
 shell::InterfaceProvider* ChildThreadImpl::GetRemoteInterfaces() {
   if (browser_connection_)
     return browser_connection_->GetRemoteInterfaces();
 
   if (!remote_interfaces_.get())
     remote_interfaces_.reset(new shell::InterfaceProvider);
   return remote_interfaces_.get();
 }
 
 IPC::MessageRouter* ChildThreadImpl::GetRouter() {
-  DCHECK(message_loop_->task_runner()->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   return &router_;
 }
 
 std::unique_ptr<base::SharedMemory> ChildThreadImpl::AllocateSharedMemory(
     size_t buf_size) {
-  DCHECK(message_loop_->task_runner()->BelongsToCurrentThread());
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
   return AllocateSharedMemory(buf_size, this, nullptr);
 }
 
 // static
 std::unique_ptr<base::SharedMemory> ChildThreadImpl::AllocateSharedMemory(
     size_t buf_size,
     IPC::Sender* sender,
     bool* out_of_memory) {
   std::unique_ptr<base::SharedMemory> shared_buf;
   // Ask the browser to create the shared memory, since this is blocked by the
@@ skipping 134 matching lines @@
 void ChildThreadImpl::EnsureConnected() {
   VLOG(0) << "ChildThreadImpl::EnsureConnected()";
   base::Process::Current().Terminate(0, false);
 }
 
 bool ChildThreadImpl::IsInBrowserProcess() const {
   return static_cast<bool>(browser_process_io_runner_);
 }
 
 }  // namespace content