Replace "nested message loop" with "nested run loop" in comments.

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc

 // Copyright 2014 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 "platform/scheduler/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 155 matching lines @@
     if (time_domain == real_time_domain_.get()) {
       time_domain->WakeUpReadyDelayedQueues(lazy_now);
     } else {
       LazyNow time_domain_lazy_now = time_domain->CreateLazyNow();
       time_domain->WakeUpReadyDelayedQueues(&time_domain_lazy_now);
     }
   }
 }
 
 void TaskQueueManager::OnBeginNestedRunLoop() {
-  // We just entered a nested message loop, make sure there's a DoWork posted or
+  // We just entered a nested run loop, make sure there's a DoWork posted or
   // the system will grind to a halt.
   {
     base::AutoLock lock(any_thread_lock_);
     any_thread().immediate_do_work_posted_count++;
     any_thread().is_nested = true;
   }
 
-  // When a nested message loop starts, task time observers may want to ignore
+  // When a nested run loop starts, task time observers may want to ignore
   // the current task.
   for (auto& observer : task_time_observers_)
     observer.OnBeginNestedRunLoop();
 
   delegate_->PostTask(FROM_HERE, immediate_do_work_closure_);
 }
 
 void TaskQueueManager::OnQueueHasIncomingImmediateWork(
     internal::TaskQueueImpl* queue,
     internal::EnqueueOrder enqueue_order,
@@ skipping 86 matching lines @@
   DCHECK(main_thread_checker_.CalledOnValidThread());
   TRACE_EVENT1("renderer.scheduler", "TaskQueueManager::DoWork", "delayed",
                delayed);
 
   LazyNow lazy_now(real_time_domain()->CreateLazyNow());
   bool is_nested = delegate_->IsNested();
   if (!is_nested)
     queues_to_delete_.clear();
 
   // This must be done before running any tasks because they could invoke a
-  // nested message loop and we risk having a stale |next_delayed_do_work_|.
+  // nested run loop and we risk having a stale |next_delayed_do_work_|.
   if (delayed)
     next_delayed_do_work_.Clear();
 
   for (int i = 0; i < work_batch_size_; i++) {
     IncomingImmediateWorkMap queues_to_reload;
 
     {
       base::AutoLock lock(any_thread_lock_);
       if (i == 0) {
         any_thread().do_work_running_count++;
@@ skipping 402 matching lines @@
   for (const scoped_refptr<internal::TaskQueueImpl>& queue : queues_) {
     TimeDomain* time_domain = queue->GetTimeDomain();
     if (time_domain_now.find(time_domain) == time_domain_now.end())
       time_domain_now.insert(std::make_pair(time_domain, time_domain->Now()));
     queue->SweepCanceledDelayedTasks(time_domain_now[time_domain]);
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink