Remove usage of FOR_EACH_OBSERVER macro in services/

services/ui/ws/server_window.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 "services/ui/ws/server_window.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 #include "base/strings/stringprintf.h"
@@ skipping 28 matching lines @@
       properties_(properties),
       // Don't notify newly added observers during notification. This causes
       // problems for code that adds an observer as part of an observer
       // notification (such as ServerWindowDrawTracker).
       observers_(
           base::ObserverList<ServerWindowObserver>::NOTIFY_EXISTING_ONLY) {
   DCHECK(delegate);  // Must provide a delegate.
 }
 
 ServerWindow::~ServerWindow() {
-  FOR_EACH_OBSERVER(ServerWindowObserver, observers_, OnWindowDestroying(this));
+  for (auto& observer : observers_)
+    observer.OnWindowDestroying(this);
 
   if (transient_parent_)
     transient_parent_->RemoveTransientWindow(this);
 
   // Destroy transient children, only after we've removed ourselves from our
   // parent, as destroying an active transient child may otherwise attempt to
   // refocus us.
   Windows transient_children(transient_children_);
   for (auto window : transient_children)
     delete window;
   DCHECK(transient_children_.empty());
 
   while (!children_.empty())
     children_.front()->parent()->Remove(children_.front());
 
   if (parent_)
     parent_->Remove(this);
 
-  FOR_EACH_OBSERVER(ServerWindowObserver, observers_, OnWindowDestroyed(this));
+  for (auto& observer : observers_)
+    observer.OnWindowDestroyed(this);
 }
 
 void ServerWindow::AddObserver(ServerWindowObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ServerWindow::RemoveObserver(ServerWindowObserver* observer) {
   DCHECK(observers_.HasObserver(observer));
   observers_.RemoveObserver(observer);
 }
@@ skipping 15 matching lines @@
   DCHECK(child != this);
   DCHECK(!child->Contains(this));
   if (child->parent() == this) {
     if (children_.size() == 1)
       return;  // Already in the right position.
     child->Reorder(children_.back(), mojom::OrderDirection::ABOVE);
     return;
   }
 
   ServerWindow* old_parent = child->parent();
-  FOR_EACH_OBSERVER(ServerWindowObserver, child->observers_,
-                    OnWillChangeWindowHierarchy(child, this, old_parent));
+  for (auto& observer : child->observers_)
+    observer.OnWillChangeWindowHierarchy(child, this, old_parent);
 
   if (child->parent())
     child->parent()->RemoveImpl(child);
 
   child->parent_ = this;
   children_.push_back(child);
 
   // Stack the child properly if it is a transient child of a sibling.
   if (child->transient_parent_ && child->transient_parent_->parent() == this)
     RestackTransientDescendants(child->transient_parent_, &GetStackingTarget,
                                 &ReorderImpl);
 
-  FOR_EACH_OBSERVER(ServerWindowObserver, child->observers_,
-                    OnWindowHierarchyChanged(child, this, old_parent));
+  for (auto& observer : child->observers_)
+    observer.OnWindowHierarchyChanged(child, this, old_parent);
 }
 
 void ServerWindow::Remove(ServerWindow* child) {
   // We assume validation checks happened else where.
   DCHECK(child);
   DCHECK(child != this);
   DCHECK(child->parent() == this);
 
-  FOR_EACH_OBSERVER(ServerWindowObserver, child->observers_,
-                    OnWillChangeWindowHierarchy(child, nullptr, this));
+  for (auto& observer : child->observers_)
+    observer.OnWillChangeWindowHierarchy(child, nullptr, this);
   RemoveImpl(child);
 
   // Stack the child properly if it is a transient child of a sibling.
   if (child->transient_parent_ && child->transient_parent_->parent() == this)
     RestackTransientDescendants(child->transient_parent_, &GetStackingTarget,
                                 &ReorderImpl);
 
-  FOR_EACH_OBSERVER(ServerWindowObserver, child->observers_,
-                    OnWindowHierarchyChanged(child, nullptr, this));
+  for (auto& observer : child->observers_)
+    observer.OnWindowHierarchyChanged(child, nullptr, this);
 }
 
 void ServerWindow::Reorder(ServerWindow* relative,
                            mojom::OrderDirection direction) {
   ReorderImpl(this, relative, direction);
 }
 
 void ServerWindow::StackChildAtBottom(ServerWindow* child) {
   // There's nothing to do if the child is already at the bottom.
   if (children_.size() <= 1 || child == children_.front())
     return;
   child->Reorder(children_.front(), mojom::OrderDirection::BELOW);
 }
 
 void ServerWindow::StackChildAtTop(ServerWindow* child) {
   // There's nothing to do if the child is already at the top.
   if (children_.size() <= 1 || child == children_.back())
     return;
   child->Reorder(children_.back(), mojom::OrderDirection::ABOVE);
 }
 
 void ServerWindow::SetBounds(const gfx::Rect& bounds) {
   if (bounds_ == bounds)
     return;
 
   // TODO(fsamuel): figure out how will this work with CompositorFrames.
 
   const gfx::Rect old_bounds = bounds_;
   bounds_ = bounds;
-  FOR_EACH_OBSERVER(ServerWindowObserver, observers_,
-                    OnWindowBoundsChanged(this, old_bounds, bounds));
+  for (auto& observer : observers_)
+    observer.OnWindowBoundsChanged(this, old_bounds, bounds);
 }
 
 void ServerWindow::SetClientArea(
     const gfx::Insets& insets,
     const std::vector<gfx::Rect>& additional_client_areas) {
   if (client_area_ == insets &&
       additional_client_areas == additional_client_areas_) {
     return;
   }
 
   additional_client_areas_ = additional_client_areas;
   client_area_ = insets;
-  FOR_EACH_OBSERVER(
-      ServerWindowObserver, observers_,
-      OnWindowClientAreaChanged(this, insets, additional_client_areas));
+  for (auto& observer : observers_)
+    observer.OnWindowClientAreaChanged(this, insets, additional_client_areas);
 }
 
 void ServerWindow::SetHitTestMask(const gfx::Rect& mask) {
   hit_test_mask_ = base::MakeUnique<gfx::Rect>(mask);
 }
 
 void ServerWindow::ClearHitTestMask() {
   hit_test_mask_.reset();
 }
 
@@ skipping 29 matching lines @@
   DCHECK(std::find(transient_children_.begin(), transient_children_.end(),
                    child) == transient_children_.end());
   transient_children_.push_back(child);
   child->transient_parent_ = this;
 
   // Restack |child| properly above its transient parent, if they share the same
   // parent.
   if (child->parent() == parent())
     RestackTransientDescendants(this, &GetStackingTarget, &ReorderImpl);
 
-  FOR_EACH_OBSERVER(ServerWindowObserver, observers_,
-                    OnTransientWindowAdded(this, child));
+  for (auto& observer : observers_)
+    observer.OnTransientWindowAdded(this, child);
   return true;
 }
 
 void ServerWindow::RemoveTransientWindow(ServerWindow* child) {
   Windows::iterator i =
       std::find(transient_children_.begin(), transient_children_.end(), child);
   DCHECK(i != transient_children_.end());
   transient_children_.erase(i);
   DCHECK_EQ(this, child->transient_parent());
   child->transient_parent_ = nullptr;
 
   // If |child| and its former transient parent share the same parent, |child|
   // should be restacked properly so it is not among transient children of its
   // former parent, anymore.
   if (parent() == child->parent())
     RestackTransientDescendants(this, &GetStackingTarget, &ReorderImpl);
 
-  FOR_EACH_OBSERVER(ServerWindowObserver, observers_,
-                    OnTransientWindowRemoved(this, child));
+  for (auto& observer : observers_)
+    observer.OnTransientWindowRemoved(this, child);
 }
 
 void ServerWindow::SetModal() {
   is_modal_ = true;
 }
 
 bool ServerWindow::Contains(const ServerWindow* window) const {
   for (const ServerWindow* parent = window; parent; parent = parent->parent_) {
     if (parent == this)
       return true;
   }
   return false;
 }
 
 void ServerWindow::SetVisible(bool value) {
   if (visible_ == value)
     return;
 
-  FOR_EACH_OBSERVER(ServerWindowObserver, observers_,
-                    OnWillChangeWindowVisibility(this));
+  for (auto& observer : observers_)
+    observer.OnWillChangeWindowVisibility(this);
   visible_ = value;
-  FOR_EACH_OBSERVER(ServerWindowObserver, observers_,
-                    OnWindowVisibilityChanged(this));
+  for (auto& observer : observers_)
+    observer.OnWindowVisibilityChanged(this);
 }
 
 void ServerWindow::SetOpacity(float value) {
   if (value == opacity_)
     return;
   float old_opacity = opacity_;
   opacity_ = value;
   delegate_->OnScheduleWindowPaint(this);
-  FOR_EACH_OBSERVER(ServerWindowObserver, observers_,
-                    OnWindowOpacityChanged(this, old_opacity, opacity_));
+  for (auto& observer : observers_)
+    observer.OnWindowOpacityChanged(this, old_opacity, opacity_);
 }
 
 void ServerWindow::SetPredefinedCursor(ui::mojom::Cursor value) {
   if (value == cursor_id_)
     return;
   cursor_id_ = value;
-  FOR_EACH_OBSERVER(
-      ServerWindowObserver, observers_,
-      OnWindowPredefinedCursorChanged(this, value));
+  for (auto& observer : observers_)
+    observer.OnWindowPredefinedCursorChanged(this, value);
 }
 
 void ServerWindow::SetNonClientCursor(ui::mojom::Cursor value) {
   if (value == non_client_cursor_id_)
     return;
   non_client_cursor_id_ = value;
-  FOR_EACH_OBSERVER(
-      ServerWindowObserver, observers_,
-      OnWindowNonClientCursorChanged(this, value));
+  for (auto& observer : observers_)
+    observer.OnWindowNonClientCursorChanged(this, value);
 }
 
 void ServerWindow::SetTransform(const gfx::Transform& transform) {
   if (transform_ == transform)
     return;
 
   transform_ = transform;
   delegate_->OnScheduleWindowPaint(this);
 }
 
 void ServerWindow::SetProperty(const std::string& name,
                                const std::vector<uint8_t>* value) {
   auto it = properties_.find(name);
   if (it != properties_.end()) {
     if (value && it->second == *value)
       return;
   } else if (!value) {
     // This property isn't set in |properties_| and |value| is nullptr, so
     // there's
     // no change.
     return;
   }
 
   if (value) {
     properties_[name] = *value;
   } else if (it != properties_.end()) {
     properties_.erase(it);
   }
 
-  FOR_EACH_OBSERVER(ServerWindowObserver, observers_,
-                    OnWindowSharedPropertyChanged(this, name, value));
+  for (auto& observer : observers_)
+    observer.OnWindowSharedPropertyChanged(this, name, value);
 }
 
 std::string ServerWindow::GetName() const {
   auto it = properties_.find(mojom::WindowManager::kName_Property);
   if (it == properties_.end())
     return std::string();
   return std::string(it->second.begin(), it->second.end());
 }
 
 void ServerWindow::SetTextInputState(const ui::TextInputState& state) {
   const bool changed = !(text_input_state_ == state);
   if (changed) {
     text_input_state_ = state;
     // keyboard even if the state is not changed. So we have to notify
     // |observers_|.
-    FOR_EACH_OBSERVER(ServerWindowObserver, observers_,
-                      OnWindowTextInputStateChanged(this, state));
+    for (auto& observer : observers_)
+      observer.OnWindowTextInputStateChanged(this, state);
   }
 }
 
 bool ServerWindow::IsDrawn() const {
   const ServerWindow* root = delegate_->GetRootWindow(this);
   if (!root || !root->visible())
     return false;
   const ServerWindow* window = this;
   while (window && window != root && window->visible())
     window = window->parent();
   return root == window;
 }
 
 ServerWindowSurfaceManager* ServerWindow::GetOrCreateSurfaceManager() {
   if (!surface_manager_.get())
     surface_manager_ = base::MakeUnique<ServerWindowSurfaceManager>(this);
   return surface_manager_.get();
 }
 
 void ServerWindow::SetUnderlayOffset(const gfx::Vector2d& offset) {
   if (offset == underlay_offset_)
     return;
 
   underlay_offset_ = offset;
   delegate_->OnScheduleWindowPaint(this);
 }
 
 void ServerWindow::OnEmbeddedAppDisconnected() {
-  FOR_EACH_OBSERVER(ServerWindowObserver, observers_,
-                    OnWindowEmbeddedAppDisconnected(this));
+  for (auto& observer : observers_)
+    observer.OnWindowEmbeddedAppDisconnected(this);
 }
 
 #if !defined(NDEBUG) || defined(DCHECK_ALWAYS_ON)
 std::string ServerWindow::GetDebugWindowHierarchy() const {
   std::string result;
   BuildDebugInfo(std::string(), &result);
   return result;
 }
 
 std::string ServerWindow::GetDebugWindowInfo() const {
@@ skipping 48 matching lines @@
                                              window));
   Windows::iterator i = std::find(window->parent_->children_.begin(),
                                   window->parent_->children_.end(), relative);
   if (direction == mojom::OrderDirection::ABOVE) {
     DCHECK(i != window->parent_->children_.end());
     window->parent_->children_.insert(++i, window);
   } else if (direction == mojom::OrderDirection::BELOW) {
     DCHECK(i != window->parent_->children_.end());
     window->parent_->children_.insert(i, window);
   }
-  FOR_EACH_OBSERVER(ServerWindowObserver, window->observers_,
-                    OnWindowReordered(window, relative, direction));
+  for (auto& observer : window->observers_)
+    observer.OnWindowReordered(window, relative, direction);
   window->OnStackingChanged();
 }
 
 // static
 ServerWindow** ServerWindow::GetStackingTarget(ServerWindow* window) {
   return &window->stacking_target_;
 }
 
 }  // namespace ws
 
 }  // namespace ui