Remove usage of FOR_EACH_OBSERVER macro in services/

services/ui/public/cpp/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/public/cpp/window.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
@@ skipping 19 matching lines @@
 
 namespace {
 
 void NotifyWindowTreeChangeAtReceiver(
     Window* receiver,
     const WindowObserver::TreeChangeParams& params,
     bool change_applied) {
   WindowObserver::TreeChangeParams local_params = params;
   local_params.receiver = receiver;
   if (change_applied) {
-    FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(receiver).observers(),
-                      OnTreeChanged(local_params));
+    for (auto& observer : *WindowPrivate(receiver).observers())
+      observer.OnTreeChanged(local_params);
   } else {
-    FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(receiver).observers(),
-                      OnTreeChanging(local_params));
+    for (auto& observer : *WindowPrivate(receiver).observers())
+      observer.OnTreeChanging(local_params);
   }
 }
 
 void NotifyWindowTreeChangeUp(Window* start_at,
                               const WindowObserver::TreeChangeParams& params,
                               bool change_applied) {
   for (Window* current = start_at; current; current = current->parent())
     NotifyWindowTreeChangeAtReceiver(current, params, change_applied);
 }
 
@@ skipping 45 matching lines @@
   OrderChangedNotifier(Window* window,
                        Window* relative_window,
                        mojom::OrderDirection direction)
       : window_(window),
         relative_window_(relative_window),
         direction_(direction) {}
 
   ~OrderChangedNotifier() {}
 
   void NotifyWindowReordering() {
-    FOR_EACH_OBSERVER(
-        WindowObserver, *WindowPrivate(window_).observers(),
-        OnWindowReordering(window_, relative_window_, direction_));
+    for (auto& observer : *WindowPrivate(window_).observers())
+      observer.OnWindowReordering(window_, relative_window_, direction_);
   }
 
   void NotifyWindowReordered() {
-    FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(window_).observers(),
-                      OnWindowReordered(window_, relative_window_, direction_));
+    for (auto& observer : *WindowPrivate(window_).observers())
+      observer.OnWindowReordered(window_, relative_window_, direction_);
   }
 
  private:
   Window* window_;
   Window* relative_window_;
   mojom::OrderDirection direction_;
 
   DISALLOW_COPY_AND_ASSIGN(OrderChangedNotifier);
 };
 
 class ScopedSetBoundsNotifier {
  public:
   ScopedSetBoundsNotifier(Window* window,
                           const gfx::Rect& old_bounds,
                           const gfx::Rect& new_bounds)
       : window_(window), old_bounds_(old_bounds), new_bounds_(new_bounds) {
-    FOR_EACH_OBSERVER(
-        WindowObserver, *WindowPrivate(window_).observers(),
-        OnWindowBoundsChanging(window_, old_bounds_, new_bounds_));
+    for (auto& observer : *WindowPrivate(window_).observers())
+      observer.OnWindowBoundsChanging(window_, old_bounds_, new_bounds_);
   }
   ~ScopedSetBoundsNotifier() {
-    FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(window_).observers(),
-                      OnWindowBoundsChanged(window_, old_bounds_, new_bounds_));
+    for (auto& observer : *WindowPrivate(window_).observers())
+      observer.OnWindowBoundsChanged(window_, old_bounds_, new_bounds_);
   }
 
  private:
   Window* window_;
   const gfx::Rect old_bounds_;
   const gfx::Rect new_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedSetBoundsNotifier);
 };
 
@@ skipping 360 matching lines @@
 
   return std::string();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Window, protected:
 
 Window::Window() : Window(nullptr, static_cast<Id>(-1)) {}
 
 Window::~Window() {
-  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroying(this));
+  for (auto& observer : observers_)
+    observer.OnWindowDestroying(this);
   if (client_)
     client_->OnWindowDestroying(this);
 
   if (HasFocus()) {
     // The focused window is being removed. When this happens the server
     // advances focus. We don't want to randomly pick a Window to get focus, so
     // we update local state only, and wait for the next focus change from the
     // server.
     client_->LocalSetFocus(nullptr);
   }
@@ skipping 20 matching lines @@
 
   // We may still have children. This can happen if the embedder destroys the
   // root while we're still alive.
   while (!children_.empty()) {
     Window* child = children_.front();
     LocalRemoveChild(child);
     DCHECK(children_.empty() || children_.front() != child);
   }
 
   // Notify observers before clearing properties (order matches aura::Window).
-  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDestroyed(this));
+  for (auto& observer : observers_)
+    observer.OnWindowDestroyed(this);
 
   // Clear properties.
   for (auto& pair : prop_map_) {
     if (pair.second.deallocator)
       (*pair.second.deallocator)(pair.second.value);
   }
   prop_map_.clear();
 
   // Invoke after observers so that can clean up any internal state observers
   // may have changed.
@@ skipping 47 matching lines @@
   int64_t old = GetLocalPropertyInternal(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_,
-                    OnWindowLocalPropertyChanged(this, key, old));
+  for (auto& observer : observers_)
+    observer.OnWindowLocalPropertyChanged(this, key, old);
   return old;
 }
 
 int64_t Window::GetLocalPropertyInternal(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 22 matching lines @@
     RemoveTransientWindowImpl(transient_window);
   transient_children_.push_back(transient_window);
   transient_window->transient_parent_ = this;
 
   // Restack |transient_window| properly above its transient parent, if they
   // share the same parent.
   if (transient_window->parent() == parent())
     RestackTransientDescendants(this, &GetStackingTarget,
                                 &ReorderWithoutNotification);
 
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnTransientChildAdded(this, transient_window));
+  for (auto& observer : observers_)
+    observer.OnTransientChildAdded(this, transient_window);
 }
 
 void Window::LocalRemoveTransientWindow(Window* transient_window) {
   DCHECK_EQ(this, transient_window->transient_parent());
   RemoveTransientWindowImpl(transient_window);
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnTransientChildRemoved(this, transient_window));
+  for (auto& observer : observers_)
+    observer.OnTransientChildRemoved(this, transient_window);
 }
 
 void Window::LocalSetModal() {
   is_modal_ = true;
 }
 
 bool Window::LocalReorder(Window* relative, mojom::OrderDirection direction) {
   OrderChangedNotifier notifier(this, relative, direction);
   return ReorderImpl(this, relative, direction, &notifier);
 }
 
 void Window::LocalSetBounds(const gfx::Rect& old_bounds,
                             const gfx::Rect& new_bounds) {
   // If this client owns the window, then it should be the only one to change
   // the bounds.
   DCHECK(!WasCreatedByThisClient() || old_bounds == bounds_);
   ScopedSetBoundsNotifier notifier(this, old_bounds, new_bounds);
   bounds_ = new_bounds;
 }
 
 void Window::LocalSetClientArea(
     const gfx::Insets& new_client_area,
     const std::vector<gfx::Rect>& additional_client_areas) {
   const std::vector<gfx::Rect> old_additional_client_areas =
       additional_client_areas_;
   const gfx::Insets old_client_area = client_area_;
   client_area_ = new_client_area;
   additional_client_areas_ = additional_client_areas;
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowClientAreaChanged(this, old_client_area,
-                                              old_additional_client_areas));
+  for (auto& observer : observers_) {
+    observer.OnWindowClientAreaChanged(this, old_client_area,
+                                       old_additional_client_areas);
+  }
 }
 
 void Window::LocalSetDisplay(int64_t display_id) {
   display_id_ = display_id;
   // TODO(sad): Notify observers (of this window, and of the descendant windows)
   // when a window moves from one display into another. https://crbug.com/614887
 }
 
 void Window::LocalSetParentDrawn(bool value) {
   if (parent_drawn_ == value)
     return;
 
   // As IsDrawn() is derived from |visible_| and |parent_drawn_|, only send
   // drawn notification is the value of IsDrawn() is really changing.
   if (IsDrawn() == value) {
     parent_drawn_ = value;
     return;
   }
-  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDrawnChanging(this));
+  for (auto& observer : observers_)
+    observer.OnWindowDrawnChanging(this);
   parent_drawn_ = value;
-  FOR_EACH_OBSERVER(WindowObserver, observers_, OnWindowDrawnChanged(this));
+  for (auto& observer : observers_)
+    observer.OnWindowDrawnChanged(this);
 }
 
 void Window::LocalSetVisible(bool visible) {
   if (visible_ == visible)
     return;
 
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowVisibilityChanging(this, visible));
+  for (auto& observer : observers_)
+    observer.OnWindowVisibilityChanging(this, visible);
   visible_ = visible;
   if (parent_) {
-    FOR_EACH_OBSERVER(WindowObserver, parent_->observers_,
-                      OnChildWindowVisibilityChanged(this, visible));
+    for (auto& observer : parent_->observers_)
+      observer.OnChildWindowVisibilityChanged(this, visible);
   }
 
   NotifyWindowVisibilityChanged(this, visible);
 }
 
 void Window::LocalSetOpacity(float opacity) {
   if (opacity_ == opacity)
     return;
 
   float old_opacity = opacity_;
   opacity_ = opacity;
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowOpacityChanged(this, old_opacity, opacity_));
+  for (auto& observer : observers_)
+    observer.OnWindowOpacityChanged(this, old_opacity, opacity_);
 }
 
 void Window::LocalSetPredefinedCursor(mojom::Cursor cursor_id) {
   if (cursor_id_ == cursor_id)
     return;
 
   cursor_id_ = cursor_id;
-  FOR_EACH_OBSERVER(WindowObserver, observers_,
-                    OnWindowPredefinedCursorChanged(this, cursor_id));
+  for (auto& observer : observers_)
+    observer.OnWindowPredefinedCursorChanged(this, cursor_id);
 }
 
 void Window::LocalSetSharedProperty(const std::string& name,
                                     const std::vector<uint8_t>* value) {
   std::vector<uint8_t> old_value;
   std::vector<uint8_t>* old_value_ptr = nullptr;
   auto it = properties_.find(name);
   if (it != properties_.end()) {
     old_value = it->second;
     old_value_ptr = &old_value;
 
     if (value && old_value == *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(
-      WindowObserver, observers_,
-      OnWindowSharedPropertyChanged(this, name, old_value_ptr, value));
+  for (auto& observer : observers_)
+    observer.OnWindowSharedPropertyChanged(this, name, old_value_ptr, value);
 }
 
 void Window::LocalSetSurfaceId(std::unique_ptr<SurfaceInfo> surface_info) {
   if (surface_info_) {
     const cc::SurfaceId& existing_surface_id = surface_info_->surface_id;
     if (!existing_surface_id.is_null() &&
         existing_surface_id != surface_info->surface_id) {
       // Return the existing surface sequence.
       if (client_) {
         client_->OnWindowSurfaceDetached(server_id_,
@@ skipping 28 matching lines @@
   NotifyWindowVisibilityChangedUp(target, visible);
 }
 
 bool Window::NotifyWindowVisibilityChangedAtReceiver(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 (auto& observer : observers_)
+    observer.OnWindowVisibilityChanged(target, visible);
   return tracker.Contains(this);
 }
 
 bool Window::NotifyWindowVisibilityChangedDown(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 {
     child_destroyed = false;
@@ skipping 97 matching lines @@
     notifier->NotifyWindowReordered();
 
   return true;
 }
 
 // static
 Window** Window::GetStackingTarget(Window* window) {
   return &window->stacking_target_;
 }
 }  // namespace ui