Reduce usage of FOR_EACH_OBSERVER macro in base

base/message_loop/message_loop.cc

 // Copyright 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 "base/message_loop/message_loop.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 106 matching lines @@
     DeletePendingTasks();
     ReloadWorkQueue();
     // If we end up with empty queues, then break out of the loop.
     did_work = DeletePendingTasks();
     if (!did_work)
       break;
   }
   DCHECK(!did_work);
 
   // Let interested parties have one last shot at accessing this.
-  FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_,
-                    WillDestroyCurrentMessageLoop());
+  for (auto& observer : destruction_observers_)
+    observer.WillDestroyCurrentMessageLoop();
 
   thread_task_runner_handle_.reset();
 
   // Tell the incoming queue that we are dying.
   incoming_task_queue_->WillDestroyCurrentMessageLoop();
   incoming_task_queue_ = NULL;
   unbound_task_runner_ = NULL;
   task_runner_ = NULL;
 
   // OK, now make it so that no one can find us.
@@ skipping 262 matching lines @@
     pending_high_res_tasks_--;
     CHECK_GE(pending_high_res_tasks_, 0);
   }
 #endif
 
   // Execute the task and assume the worst: It is probably not reentrant.
   nestable_tasks_allowed_ = false;
 
   TRACE_TASK_EXECUTION("MessageLoop::RunTask", *pending_task);
 
-  FOR_EACH_OBSERVER(TaskObserver, task_observers_,
-                    WillProcessTask(*pending_task));
+  for (auto& observer : task_observers_)
+    observer.WillProcessTask(*pending_task);
   task_annotator_.RunTask("MessageLoop::PostTask", pending_task);
-  FOR_EACH_OBSERVER(TaskObserver, task_observers_,
-                    DidProcessTask(*pending_task));
+  for (auto& observer : task_observers_)
+    observer.DidProcessTask(*pending_task);
 
   nestable_tasks_allowed_ = true;
 }
 
 bool MessageLoop::DeferOrRunPendingTask(PendingTask pending_task) {
   if (pending_task.nestable || run_loop_->run_depth_ == 1) {
     RunTask(&pending_task);
     // Show that we ran a task (Note: a new one might arrive as a
     // consequence!).
     return true;
@@ skipping 52 matching lines @@
     incoming_task_queue_->ReloadWorkQueue(&work_queue_);
 #endif
   }
 }
 
 void MessageLoop::ScheduleWork() {
   pump_->ScheduleWork();
 }
 
 void MessageLoop::NotifyBeginNestedLoop() {
-  FOR_EACH_OBSERVER(NestingObserver, nesting_observers_,
-                    OnBeginNestedMessageLoop());
+  for (auto& observer : nesting_observers_)
+    observer.OnBeginNestedMessageLoop();
 }
 
 bool MessageLoop::DoWork() {
   if (!nestable_tasks_allowed_) {
     // Task can't be executed right now.
     return false;
   }
 
   for (;;) {
     ReloadWorkQueue();
@@ skipping 154 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL_SFI)
 
 }  // namespace base