Remove calls to MessageLoop::current() in tools.

tools/gn/loader.cc

 // Copyright (c) 2013 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 "tools/gn/loader.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
-#include "base/single_thread_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "tools/gn/build_settings.h"
 #include "tools/gn/err.h"
 #include "tools/gn/filesystem_utils.h"
 #include "tools/gn/input_file_manager.h"
 #include "tools/gn/parse_tree.h"
 #include "tools/gn/scheduler.h"
 #include "tools/gn/scope_per_file_provider.h"
 #include "tools/gn/settings.h"
 #include "tools/gn/source_dir.h"
 #include "tools/gn/source_file.h"
@@ skipping 72 matching lines @@
 }
 
 // static
 SourceFile Loader::BuildFileForLabel(const Label& label) {
   return SourceFile(label.dir().value() + "BUILD.gn");
 }
 
 // -----------------------------------------------------------------------------
 
 LoaderImpl::LoaderImpl(const BuildSettings* build_settings)
-    : main_loop_(base::MessageLoop::current()),
-      pending_loads_(0),
-      build_settings_(build_settings) {
+    : pending_loads_(0), build_settings_(build_settings) {
+  // There may not be an active TaskRunner at this point. When that's the case,
+  // the calling code is expected to call set_task_runner().
+  if (base::ThreadTaskRunnerHandle::IsSet())
+    task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 LoaderImpl::~LoaderImpl() {
 }
 
 void LoaderImpl::Load(const SourceFile& file,
                       const LocationRange& origin,
                       const Label& in_toolchain_name) {
   const Label& toolchain_name = in_toolchain_name.is_null()
       ? default_toolchain_label_ : in_toolchain_name;
@@ skipping 116 matching lines @@
     g_scheduler->FailWithError(err);
     DecrementPendingLoads();
   }
 }
 
 void LoaderImpl::BackgroundLoadFile(const Settings* settings,
                                     const SourceFile& file_name,
                                     const LocationRange& origin,
                                     const ParseNode* root) {
   if (!root) {
-    main_loop_->task_runner()->PostTask(
+    task_runner_->PostTask(
         FROM_HERE, base::Bind(&LoaderImpl::DecrementPendingLoads, this));
     return;
   }
 
   if (g_scheduler->verbose_logging()) {
     g_scheduler->Log("Running", file_name.value() + " with toolchain " +
                      settings->toolchain_label().GetUserVisibleName(false));
   }
 
   Scope our_scope(settings->base_config());
@@ skipping 20 matching lines @@
 
 
   // Pass all of the items that were defined off to the builder.
   for (auto& item : collected_items) {
     settings->build_settings()->ItemDefined(base::WrapUnique(item));
     item = nullptr;
   }
 
   trace.Done();
 
-  main_loop_->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&LoaderImpl::DidLoadFile, this));
+  task_runner_->PostTask(FROM_HERE, base::Bind(&LoaderImpl::DidLoadFile, this));
 }
 
 void LoaderImpl::BackgroundLoadBuildConfig(
     Settings* settings,
     const Scope::KeyValueMap& toolchain_overrides,
     const ParseNode* root) {
   if (!root) {
-    main_loop_->task_runner()->PostTask(
+    task_runner_->PostTask(
         FROM_HERE, base::Bind(&LoaderImpl::DecrementPendingLoads, this));
     return;
   }
 
   Scope* base_config = settings->base_config();
   base_config->set_source_dir(SourceDir("//"));
 
   settings->build_settings()->build_args().SetupRootScope(
       base_config, toolchain_overrides);
 
@@ skipping 29 matching lines @@
       g_scheduler->FailWithError(Err(Location(),
           "The default build config file did not call set_default_toolchain()",
           "If you don't call this, I can't figure out what toolchain to use\n"
           "for all of this code."));
     } else {
       DCHECK(settings->toolchain_label().is_null());
       settings->set_toolchain_label(default_toolchain_label);
     }
   }
 
-  main_loop_->task_runner()->PostTask(
-      FROM_HERE, base::Bind(&LoaderImpl::DidLoadBuildConfig, this,
-                            settings->toolchain_label()));
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&LoaderImpl::DidLoadBuildConfig, this,
+                                    settings->toolchain_label()));
 }
 
 void LoaderImpl::DidLoadFile() {
   DecrementPendingLoads();
 }
 
 void LoaderImpl::DidLoadBuildConfig(const Label& label) {
   // Do not return early, we must call DecrementPendingLoads() at the bottom.
 
   ToolchainRecordMap::iterator found_toolchain = toolchain_records_.find(label);
@@ skipping 66 matching lines @@
     const SourceFile& file_name,
     const base::Callback<void(const ParseNode*)>& callback,
     Err* err) {
   if (async_load_file_.is_null()) {
     return g_scheduler->input_file_manager()->AsyncLoadFile(
         origin, build_settings, file_name, callback, err);
   }
   return async_load_file_.Run(
       origin, build_settings, file_name, callback, err);
 }