Remove calls to deprecated MessageLoop methods in tools.

tools/gn/scheduler.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/scheduler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
 #include "tools/gn/standard_out.h"
 #include "tools/gn/switches.h"
 #include "tools/gn/target.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #else
 #include <unistd.h>
@@ skipping 73 matching lines @@
   pool_->Shutdown();
   return !local_is_failed;
 }
 
 void Scheduler::Log(const std::string& verb, const std::string& msg) {
   if (base::MessageLoop::current() == &main_loop_) {
     LogOnMainThread(verb, msg);
   } else {
     // The run loop always joins on the sub threads, so the lifetime of this
     // object outlives the invocations of this function, hence "unretained".
-    main_loop_.PostTask(FROM_HERE,
-                        base::Bind(&Scheduler::LogOnMainThread,
-                                   base::Unretained(this), verb, msg));
+    main_loop_.task_runner()->PostTask(
+        FROM_HERE, base::Bind(&Scheduler::LogOnMainThread,
+                              base::Unretained(this), verb, msg));
   }
 }
 
 void Scheduler::FailWithError(const Err& err) {
   DCHECK(err.has_error());
   {
     base::AutoLock lock(lock_);
 
     if (is_failed_ || has_been_shutdown_)
       return;  // Ignore errors once we see one.
     is_failed_ = true;
   }
 
   if (base::MessageLoop::current() == &main_loop_) {
     FailWithErrorOnMainThread(err);
   } else {
     // The run loop always joins on the sub threads, so the lifetime of this
     // object outlives the invocations of this function, hence "unretained".
-    main_loop_.PostTask(FROM_HERE,
-                        base::Bind(&Scheduler::FailWithErrorOnMainThread,
-                                   base::Unretained(this), err));
+    main_loop_.task_runner()->PostTask(
+        FROM_HERE, base::Bind(&Scheduler::FailWithErrorOnMainThread,
+                              base::Unretained(this), err));
   }
 }
 
 void Scheduler::ScheduleWork(const base::Closure& work) {
   IncrementWorkCount();
   pool_->PostWorkerTaskWithShutdownBehavior(
       FROM_HERE, base::Bind(&Scheduler::DoWork,
                             base::Unretained(this), work),
       base::SequencedWorkerPool::BLOCK_SHUTDOWN);
 }
@@ skipping 65 matching lines @@
 
 void Scheduler::IncrementWorkCount() {
   base::AtomicRefCountInc(&work_count_);
 }
 
 void Scheduler::DecrementWorkCount() {
   if (!base::AtomicRefCountDec(&work_count_)) {
     if (base::MessageLoop::current() == &main_loop_) {
       OnComplete();
     } else {
-      main_loop_.PostTask(FROM_HERE,
-                          base::Bind(&Scheduler::OnComplete,
-                                     base::Unretained(this)));
+      main_loop_.task_runner()->PostTask(
+          FROM_HERE,
+          base::Bind(&Scheduler::OnComplete, base::Unretained(this)));
     }
   }
 }
 
 void Scheduler::LogOnMainThread(const std::string& verb,
                                 const std::string& msg) {
   OutputString(verb, DECORATION_YELLOW);
   OutputString(" " + msg + "\n");
 }
 
 void Scheduler::FailWithErrorOnMainThread(const Err& err) {
   err.PrintToStdout();
   runner_.Quit();
 }
 
 void Scheduler::DoWork(const base::Closure& closure) {
   closure.Run();
   DecrementWorkCount();
 }
 
 void Scheduler::OnComplete() {
   // Should be called on the main thread.
   DCHECK(base::MessageLoop::current() == main_loop());
   runner_.Quit();
 }