Reduce FOR_EACH_OBSERVER usage in ui/

ui/aura/window.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/aura/window.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 91 matching lines @@
 }
 
 Window::~Window() {
   if (layer()->owner() == this)
     layer()->CompleteAllAnimations();
   layer()->SuppressPaint();
 
   // Let the delegate know we're in the processing of destroying.
   if (delegate_)
     delegate_->OnWindowDestroying(this);
-  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroying(this));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowDestroying(this);
 
   // While we are being destroyed, our target handler may also be in the
   // process of destruction or already destroyed, so do not forward any
   // input events at the ui::EP_TARGET phase.
   SetTargetHandler(nullptr);
 
   // TODO(beng): See comment in window_event_dispatcher.h. This shouldn't be
   //             necessary but unfortunately is right now due to ordering
   //             peculiarities. WED must be notified _after_ other observers
   //             are notified of pending teardown but before the hierarchy
@@ skipping 63 matching lines @@
 void Window::SetName(const std::string& name) {
   name_ = name;
   if (layer())
     UpdateLayerName();
 }
 
 void Window::SetTitle(const base::string16& title) {
   if (title == title_)
     return;
   title_ = title;
-  FOR_EACH_OBSERVER(WindowObserver,
-                    observers_,
-                    OnWindowTitleChanged(this));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowTitleChanged(this);
 }
 
 void Window::SetTransparent(bool transparent) {
   transparent_ = transparent;
   if (layer())
     layer()->SetFillsBoundsOpaquely(!transparent_);
 }
 
 void Window::SetFillsBoundsCompletely(bool fills_bounds) {
   layer()->SetFillsBoundsCompletely(fills_bounds);
@@ skipping 60 matching lines @@
     if (screen_position_client) {
       gfx::Point origin = bounds.origin();
       screen_position_client->ConvertPointToScreen(root, &origin);
       bounds.set_origin(origin);
     }
   }
   return bounds;
 }
 
 void Window::SetTransform(const gfx::Transform& transform) {
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowTransforming(this));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowTransforming(this);
   layer()->SetTransform(transform);
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowTransformed(this));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowTransformed(this);
   NotifyAncestorWindowTransformed(this);
 }
 
 void Window::SetLayoutManager(LayoutManager* layout_manager) {
   if (layout_manager == layout_manager_.get())
     return;
   layout_manager_.reset(layout_manager);
   if (!layout_manager)
     return;
   // If we're changing to a new layout manager, ensure it is aware of all the
@@ skipping 83 matching lines @@
       children_.end());
   if (child->parent())
     child->parent()->RemoveChildImpl(child, this);
 
   child->parent_ = this;
   layer()->Add(child->layer());
 
   children_.push_back(child);
   if (layout_manager_)
     layout_manager_->OnWindowAddedToLayout(child);
-  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowAdded(child));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowAdded(child);
   child->OnParentChanged();
 
   Window* root_window = GetRootWindow();
   if (root_window && old_root != root_window) {
     root_window->GetHost()->dispatcher()->OnWindowAddedToRootWindow(child);
     child->NotifyAddedToRootWindow();
   }
 
   params.phase = WindowObserver::HierarchyChangeParams::HIERARCHY_CHANGED;
   NotifyWindowHierarchyChange(params);
@@ skipping 272 matching lines @@
   int64_t old = GetPropertyInternal(key, default_value);
   if (value == default_value) {
     prop_map_.erase(key);
   } else {
     Value prop_value;
     prop_value.name = name;
     prop_value.value = value;
     prop_value.deallocator = deallocator;
     prop_map_[key] = prop_value;
   }
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowPropertyChanged(this, key, old));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowPropertyChanged(this, key, old);
   return old;
 }
 
 int64_t Window::GetPropertyInternal(const void* key,
                                     int64_t default_value) const {
   std::map<const void*, Value>::const_iterator iter = prop_map_.find(key);
   if (iter == prop_map_.end())
     return default_value;
   return iter->second.value;
 }
@@ skipping 25 matching lines @@
   // changed notification from the layer (this typically happens after animating
   // hidden). We must notify ourselves.
   if (layer()->delegate() != this)
     OnLayerBoundsChanged(old_bounds);
 }
 
 void Window::SetVisible(bool visible) {
   if (visible == layer()->GetTargetVisibility())
     return;  // No change.
 
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowVisibilityChanging(this, visible));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowVisibilityChanging(this, visible);
 
   client::VisibilityClient* visibility_client =
       client::GetVisibilityClient(this);
   if (visibility_client)
     visibility_client->UpdateLayerVisibility(this, visible);
   else
     layer()->SetVisible(visible);
   visible_ = visible;
   SchedulePaint();
   if (parent_ && parent_->layout_manager_)
@@ skipping 65 matching lines @@
     if (match)
       return match;
   }
 
   return delegate_ ? this : NULL;
 }
 
 void Window::RemoveChildImpl(Window* child, Window* new_parent) {
   if (layout_manager_)
     layout_manager_->OnWillRemoveWindowFromLayout(child);
-  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWillRemoveWindow(child));
+  for (WindowObserver& observer : observers_)
+    observer.OnWillRemoveWindow(child);
   Window* root_window = child->GetRootWindow();
   Window* new_root_window = new_parent ? new_parent->GetRootWindow() : NULL;
   if (root_window && root_window != new_root_window)
     child->NotifyRemovingFromRootWindow(new_root_window);
 
   if (child->OwnsLayer())
     layer()->Remove(child->layer());
   child->parent_ = NULL;
   Windows::iterator i = std::find(children_.begin(), children_.end(), child);
   DCHECK(i != children_.end());
   children_.erase(i);
   child->OnParentChanged();
   if (layout_manager_)
     layout_manager_->OnWindowRemovedFromLayout(child);
 }
 
 void Window::OnParentChanged() {
-  FOR_EACH_OBSERVER(
-      WindowObserver, observers_, OnWindowParentChanged(this, parent_));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowParentChanged(this, parent_);
 }
 
 void Window::StackChildRelativeTo(Window* child,
                                   Window* target,
                                   StackDirection direction) {
   DCHECK_NE(child, target);
   DCHECK(child);
   DCHECK(target);
   DCHECK_EQ(this, child->parent());
   DCHECK_EQ(this, target->parent());
@@ skipping 30 matching lines @@
                                        Window* target,
                                        StackDirection direction) {
   DCHECK(layer() && child->layer() && target->layer());
   if (direction == STACK_ABOVE)
     layer()->StackAbove(child->layer(), target->layer());
   else
     layer()->StackBelow(child->layer(), target->layer());
 }
 
 void Window::OnStackingChanged() {
-  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowStackingChanged(this));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowStackingChanged(this);
 }
 
 void Window::NotifyRemovingFromRootWindow(Window* new_root) {
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowRemovingFromRootWindow(this, new_root));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowRemovingFromRootWindow(this, new_root);
   for (Window::Windows::const_iterator it = children_.begin();
        it != children_.end(); ++it) {
     (*it)->NotifyRemovingFromRootWindow(new_root);
   }
 }
 
 void Window::NotifyAddedToRootWindow() {
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowAddedToRootWindow(this));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowAddedToRootWindow(this);
   for (Window::Windows::const_iterator it = children_.begin();
        it != children_.end(); ++it) {
     (*it)->NotifyAddedToRootWindow();
   }
 }
 
 void Window::NotifyWindowHierarchyChange(
     const WindowObserver::HierarchyChangeParams& params) {
   params.target->NotifyWindowHierarchyChangeDown(params);
   switch (params.phase) {
@@ skipping 47 matching lines @@
   NotifyWindowVisibilityChangedUp(target, visible);
 }
 
 bool Window::NotifyWindowVisibilityChangedAtReceiver(aura::Window* target,
                                                      bool visible) {
   // |this| may be deleted during a call to OnWindowVisibilityChanged() on one
   // of the observers. We create an local observer for that. In that case we
   // exit without further access to any members.
   WindowTracker tracker;
   tracker.Add(this);
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowVisibilityChanged(target, visible));
+  for (WindowObserver& observer : observers_)
+    observer.OnWindowVisibilityChanged(target, visible);
   return tracker.Contains(this);
 }
 
 bool Window::NotifyWindowVisibilityChangedDown(aura::Window* target,
                                                bool visible) {
   if (!NotifyWindowVisibilityChangedAtReceiver(target, visible))
     return false; // |this| was deleted.
   std::set<const Window*> child_already_processed;
   bool child_destroyed = false;
   do {
@@ skipping 17 matching lines @@
                                              bool visible) {
   // Start with the parent as we already notified |this|
   // in NotifyWindowVisibilityChangedDown.
   for (Window* window = parent(); window; window = window->parent()) {
     bool ret = window->NotifyWindowVisibilityChangedAtReceiver(target, visible);
     DCHECK(ret);
   }
 }
 
 void Window::NotifyAncestorWindowTransformed(Window* source) {
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnAncestorWindowTransformed(source, this));
+  for (WindowObserver& observer : observers_)
+    observer.OnAncestorWindowTransformed(source, this);
   for (Window::Windows::const_iterator it = children_.begin();
        it != children_.end(); ++it) {
     (*it)->NotifyAncestorWindowTransformed(source);
   }
 }
 
 bool Window::CleanupGestureState() {
   bool state_modified = false;
   state_modified |= ui::GestureRecognizer::Get()->CancelActiveTouches(this);
   state_modified |=
       ui::GestureRecognizer::Get()->CleanupStateForConsumer(this);
   for (Window::Windows::iterator iter = children_.begin();
        iter != children_.end();
        ++iter) {
     state_modified |= (*iter)->CleanupGestureState();
   }
   return state_modified;
 }
 
 void Window::OnPaintLayer(const ui::PaintContext& context) {
   Paint(context);
 }
 
 void Window::OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) {
   DCHECK(layer());
-  FOR_EACH_OBSERVER(WindowObserver,
-                    observers_,
-                    OnDelegatedFrameDamage(this, damage_rect_in_dip));
+  for (WindowObserver& observer : observers_)
+    observer.OnDelegatedFrameDamage(this, damage_rect_in_dip);
 }
 
 void Window::OnLayerBoundsChanged(const gfx::Rect& old_bounds) {
   bounds_ = layer()->bounds();
   if (layout_manager_)
     layout_manager_->OnWindowResized();
   if (delegate_)
     delegate_->OnBoundsChanged(old_bounds, bounds_);
   for (auto& observer : observers_)
     observer.OnWindowBoundsChanged(this, old_bounds, bounds_);
@@ skipping 58 matching lines @@
     layer_name = "Unnamed Window";
 
   if (id_ != -1)
     layer_name += " " + base::IntToString(id_);
 
   layer()->set_name(layer_name);
 #endif
 }
 
 }  // namespace aura