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

tools/gn/loader.h

 // 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.
 
 #ifndef TOOLS_GN_LOADER_H_
 #define TOOLS_GN_LOADER_H_
 
 #include <map>
 #include <memory>
 #include <set>
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
 #include "tools/gn/label.h"
 #include "tools/gn/scope.h"
 
-namespace base {
-class MessageLoop;
-}
-
 class BuildSettings;
 class LocationRange;
 class Settings;
 class SourceFile;
 class Toolchain;
 
 // The loader manages execution of the different build files. It receives
 // requests (normally from the Builder) when new references are found, and also
 // manages loading the build config files.
 //
@@ skipping 52 matching lines @@
   explicit LoaderImpl(const BuildSettings* build_settings);
 
   // Loader implementation.
   void Load(const SourceFile& file,
             const LocationRange& origin,
             const Label& toolchain_name) override;
   void ToolchainLoaded(const Toolchain* toolchain) override;
   Label GetDefaultToolchain() const override;
   const Settings* GetToolchainSettings(const Label& label) const override;
 
-  // Sets the message loop corresponding to the main thread. By default this
+  // Sets the task runner corresponding to the main thread. By default this
   // class will use the thread active during construction, but there is not
-  // a message loop active during construction all the time.
-  void set_main_loop(base::MessageLoop* loop) { main_loop_ = loop; }
+  // a task runner active during construction all the time.
+  void set_task_runner(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+    task_runner_ = task_runner;
+  }
 
   // The complete callback is called whenever there are no more pending loads.
   // Called on the main thread only. This may be called more than once if the
   // queue is drained, but then more stuff gets added.
   void set_complete_callback(const base::Closure& cb) {
     complete_callback_ = cb;
   }
 
   // This callback is used when the loader finds it wants to load a file.
   void set_async_load_file(const AsyncLoadFileCallback& cb) {
@@ skipping 45 matching lines @@
   // necessary.
   void DecrementPendingLoads();
 
   // Forwards to the appropriate location to load the file.
   bool AsyncLoadFile(const LocationRange& origin,
                      const BuildSettings* build_settings,
                      const SourceFile& file_name,
                      const base::Callback<void(const ParseNode*)>& callback,
                      Err* err);
 
-  base::MessageLoop* main_loop_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   int pending_loads_;
   base::Closure complete_callback_;
 
   // When non-null, use this callback instead of the InputFileManager for
   // mocking purposes.
   AsyncLoadFileCallback async_load_file_;
 
   typedef std::set<LoadID> LoadIDSet;
   LoadIDSet invocations_;
 
   const BuildSettings* build_settings_;
   Label default_toolchain_label_;
 
   // Records for the build config file loads.
   typedef std::map<Label, std::unique_ptr<ToolchainRecord>> ToolchainRecordMap;
   ToolchainRecordMap toolchain_records_;
 };
 
 #endif  // TOOLS_GN_LOADER_H_