Remove calls to MessageLoop::current() 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"
@@ skipping 79 matching lines @@
     local_is_failed = is_failed();
     has_been_shutdown_ = true;
   }
   // Don't do this inside the lock since it will block on the workers, which
   // may be in turn waiting on the lock.
   pool_->Shutdown();
   return !local_is_failed;
 }
 
 void Scheduler::Log(const std::string& verb, const std::string& msg) {
-  if (base::MessageLoop::current() == &main_loop_) {
+  if (task_runner()->BelongsToCurrentThread()) {
     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_.task_runner()->PostTask(
-        FROM_HERE, base::Bind(&Scheduler::LogOnMainThread,
-                              base::Unretained(this), verb, msg));
+    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_) {
+  if (task_runner()->BelongsToCurrentThread()) {
     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_.task_runner()->PostTask(
-        FROM_HERE, base::Bind(&Scheduler::FailWithErrorOnMainThread,
-                              base::Unretained(this), err));
+    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 62 matching lines @@
   unknown_generated_inputs_.clear();
   written_files_.clear();
 }
 
 void Scheduler::IncrementWorkCount() {
   base::AtomicRefCountInc(&work_count_);
 }
 
 void Scheduler::DecrementWorkCount() {
   if (!base::AtomicRefCountDec(&work_count_)) {
-    if (base::MessageLoop::current() == &main_loop_) {
+    if (task_runner()->BelongsToCurrentThread()) {
       OnComplete();
     } else {
-      main_loop_.task_runner()->PostTask(
-          FROM_HERE,
-          base::Bind(&Scheduler::OnComplete, base::Unretained(this)));
+      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());
+  DCHECK(task_runner()->BelongsToCurrentThread());
   runner_.Quit();
 }