Remove usage of FOR_EACH_OBSERVER macro in ui/compositor/.

ui/compositor/compositor.cc

 // Copyright (c) 2012 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 "ui/compositor/compositor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <deque>
@@ skipping 196 matching lines @@
   host_->SetFrameSinkId(frame_sink_id_);
   host_->SetVisible(true);
 }
 
 Compositor::~Compositor() {
   TRACE_EVENT0("shutdown", "Compositor::destructor");
 
   CancelCompositorLock();
   DCHECK(!compositor_lock_);
 
-  FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
-                    OnCompositingShuttingDown(this));
+  for (auto& observer : observer_list_)
+    observer.OnCompositingShuttingDown(this);
 
-  FOR_EACH_OBSERVER(CompositorAnimationObserver, animation_observer_list_,
-                    OnCompositingShuttingDown(this));
+  for (auto& observer : animation_observer_list_)
+    observer.OnCompositingShuttingDown(this);
 
   if (root_layer_)
     root_layer_->ResetCompositor();
 
   if (animation_timeline_)
     host_->GetLayerTree()->animation_host()->RemoveAnimationTimeline(
         animation_timeline_.get());
 
   // Stop all outstanding draws before telling the ContextFactory to tear
   // down any contexts that the |host_| may rely upon.
@@ skipping 204 matching lines @@
     CompositorAnimationObserver* observer) {
   animation_observer_list_.RemoveObserver(observer);
 }
 
 bool Compositor::HasAnimationObserver(
     const CompositorAnimationObserver* observer) const {
   return animation_observer_list_.HasObserver(observer);
 }
 
 void Compositor::BeginMainFrame(const cc::BeginFrameArgs& args) {
-  FOR_EACH_OBSERVER(CompositorAnimationObserver,
-                    animation_observer_list_,
-                    OnAnimationStep(args.frame_time));
+  for (auto& observer : animation_observer_list_)
+    observer.OnAnimationStep(args.frame_time);
   if (animation_observer_list_.might_have_observers())
     host_->SetNeedsAnimate();
 }
 
 void Compositor::BeginMainFrameNotExpectedSoon() {
 }
 
 static void SendDamagedRectsRecursive(ui::Layer* layer) {
   layer->SendDamagedRects();
   for (auto* child : layer->children())
@@ skipping 17 matching lines @@
 
 void Compositor::DidFailToInitializeCompositorFrameSink() {
   // The CompositorFrameSink should already be bound/initialized before being
   // given to
   // the Compositor.
   NOTREACHED();
 }
 
 void Compositor::DidCommit() {
   DCHECK(!IsLocked());
-  FOR_EACH_OBSERVER(CompositorObserver,
-                    observer_list_,
-                    OnCompositingDidCommit(this));
+  for (auto& observer : observer_list_)
+    observer.OnCompositingDidCommit(this);
 }
 
 void Compositor::DidCommitAndDrawFrame() {
 }
 
 void Compositor::DidCompleteSwapBuffers() {
-  FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
-                    OnCompositingEnded(this));
+  for (auto& observer : observer_list_)
+    observer.OnCompositingEnded(this);
 }
 
 void Compositor::DidPostSwapBuffers() {
   base::TimeTicks start_time = base::TimeTicks::Now();
-  FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
-                    OnCompositingStarted(this, start_time));
+  for (auto& observer : observer_list_)
+    observer.OnCompositingStarted(this, start_time);
 }
 
 void Compositor::DidAbortSwapBuffers() {
-  FOR_EACH_OBSERVER(CompositorObserver,
-                    observer_list_,
-                    OnCompositingAborted(this));
+  for (auto& observer : observer_list_)
+    observer.OnCompositingAborted(this);
 }
 
 void Compositor::SetOutputIsSecure(bool output_is_secure) {
   context_factory_->SetOutputIsSecure(this, output_is_secure);
 }
 
 const cc::LayerTreeDebugState& Compositor::GetLayerTreeDebugState() const {
   return host_->GetDebugState();
 }
 
 void Compositor::SetLayerTreeDebugState(
     const cc::LayerTreeDebugState& debug_state) {
   host_->SetDebugState(debug_state);
 }
 
 const cc::RendererSettings& Compositor::GetRendererSettings() const {
   return host_->GetSettings().renderer_settings;
 }
 
 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {
   if (!compositor_lock_) {
     compositor_lock_ = new CompositorLock(this);
     host_->SetDeferCommits(true);
-    FOR_EACH_OBSERVER(CompositorObserver,
-                      observer_list_,
-                      OnCompositingLockStateChanged(this));
+    for (auto& observer : observer_list_)
+      observer.OnCompositingLockStateChanged(this);
   }
   return compositor_lock_;
 }
 
 void Compositor::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   host_->SetDeferCommits(false);
-  FOR_EACH_OBSERVER(CompositorObserver,
-                    observer_list_,
-                    OnCompositingLockStateChanged(this));
+  for (auto& observer : observer_list_)
+    observer.OnCompositingLockStateChanged(this);
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui