Remove usage of FOR_EACH_OBSERVER macro in services/

services/ui/public/cpp/window_tree_client.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_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 74 matching lines @@
   // Allow for a null request in tests.
   if (request.is_pending())
     binding_.Bind(std::move(request));
   if (window_manager_delegate)
     window_manager_delegate->SetWindowManagerClient(this);
 }
 
 WindowTreeClient::~WindowTreeClient() {
   in_destructor_ = true;
 
-  FOR_EACH_OBSERVER(WindowTreeClientObserver, observers_,
-                    OnWillDestroyClient(this));
+  for (auto& observer : observers_)
+    observer.OnWillDestroyClient(this);
 
   std::vector<Window*> non_owned;
   WindowTracker tracker;
   while (!windows_.empty()) {
     IdToWindowMap::iterator it = windows_.begin();
     if (it->second->WasCreatedByThisClient()) {
       it->second->Destroy();
     } else {
       tracker.Add(it->second);
       windows_.erase(it);
     }
   }
 
   // Delete the non-owned windows last. In the typical case these are roots. The
   // exception is the window manager and embed roots, which may know about
   // other random windows that it doesn't own.
   // NOTE: we manually delete as we're a friend.
   while (!tracker.windows().empty())
     delete tracker.windows().front();
 
-  FOR_EACH_OBSERVER(WindowTreeClientObserver, observers_,
-                    OnDidDestroyClient(this));
+  for (auto& observer : observers_)
+    observer.OnDidDestroyClient(this);
 }
 
 void WindowTreeClient::ConnectViaWindowTreeFactory(
     shell::Connector* connector) {
   // The client id doesn't really matter, we use 101 purely for debugging.
   client_id_ = 101;
 
   mojom::WindowTreeFactoryPtr factory;
   connector->ConnectToInterface("service:ui", &factory);
   mojom::WindowTreePtr window_tree;
@@ skipping 234 matching lines @@
   DCHECK(tree_);
   tree_->OnWindowSurfaceDetached(window_id, sequence);
 }
 
 void WindowTreeClient::LocalSetCapture(Window* window) {
   if (capture_window_ == window)
     return;
   Window* lost_capture = capture_window_;
   capture_window_ = window;
   if (lost_capture) {
-    FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(lost_capture).observers(),
-                      OnWindowLostCapture(lost_capture));
+    for (auto& observer : *WindowPrivate(lost_capture).observers())
+      observer.OnWindowLostCapture(lost_capture);
   }
-  FOR_EACH_OBSERVER(WindowTreeClientObserver, observers_,
-                    OnWindowTreeCaptureChanged(window, lost_capture));
+  for (auto& observer : observers_)
+    observer.OnWindowTreeCaptureChanged(window, lost_capture);
 }
 
 void WindowTreeClient::LocalSetFocus(Window* focused) {
   Window* blurred = focused_window_;
   // Update |focused_window_| before calling any of the observers, so that the
   // observers get the correct result from calling |Window::HasFocus()|,
   // |WindowTreeClient::GetFocusedWindow()| etc.
   focused_window_ = focused;
   if (blurred) {
-    FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(blurred).observers(),
-                      OnWindowFocusChanged(focused, blurred));
+    for (auto& observer : *WindowPrivate(blurred).observers())
+      observer.OnWindowFocusChanged(focused, blurred);
   }
   if (focused) {
-    FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(focused).observers(),
-                      OnWindowFocusChanged(focused, blurred));
+    for (auto& observer : *WindowPrivate(focused).observers())
+      observer.OnWindowFocusChanged(focused, blurred);
   }
-  FOR_EACH_OBSERVER(WindowTreeClientObserver, observers_,
-                    OnWindowTreeFocusChanged(focused, blurred));
+  for (auto& observer : observers_)
+    observer.OnWindowTreeFocusChanged(focused, blurred);
 }
 
 void WindowTreeClient::AddWindow(Window* window) {
   DCHECK(windows_.find(server_id(window)) == windows_.end());
   windows_[server_id(window)] = window;
 }
 
 void WindowTreeClient::OnWindowDestroying(Window* window) {
   if (window == capture_window_) {
     // Normally the queue updates itself upon window destruction. However since
@@ skipping 157 matching lines @@
   WindowPrivate(root).LocalSetDisplay(display_id);
   roots_.insert(root);
 
   focused_window_ = GetWindowByServerId(focused_window_id);
 
   WindowPrivate(root).LocalSetParentDrawn(drawn);
 
   delegate_->OnEmbed(root);
 
   if (focused_window_) {
-    FOR_EACH_OBSERVER(WindowTreeClientObserver, observers_,
-                      OnWindowTreeFocusChanged(focused_window_, nullptr));
+    for (auto& observer : observers_)
+      observer.OnWindowTreeFocusChanged(focused_window_, nullptr);
   }
 }
 
 void WindowTreeClient::WmNewDisplayAddedImpl(const display::Display& display,
                                              mojom::WindowDataPtr root_data,
                                              bool parent_drawn) {
   DCHECK(window_manager_delegate_);
 
   Window* root = AddWindowToClient(this, nullptr, root_data);
   WindowPrivate(root).LocalSetDisplay(display.id());
@@ skipping 191 matching lines @@
                                                tree_ptr_.associated_group()));
   }
 
   OnEmbedImpl(tree_ptr_.get(), client_id, std::move(root_data), display_id,
               focused_window_id, drawn);
 }
 
 void WindowTreeClient::OnEmbeddedAppDisconnected(Id window_id) {
   Window* window = GetWindowByServerId(window_id);
   if (window) {
-    FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(window).observers(),
-                      OnWindowEmbeddedAppDisconnected(window));
+    for (auto& observer : *WindowPrivate(window).observers())
+      observer.OnWindowEmbeddedAppDisconnected(window);
   }
 }
 
 void WindowTreeClient::OnUnembed(Id window_id) {
   Window* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
   delegate_->OnUnembed(window);
   WindowPrivate(window).LocalDestroy();
@@ skipping 442 matching lines @@
   window_manager_internal_.reset(
       new mojo::AssociatedBinding<mojom::WindowManager>(this,
                                                         std::move(internal)));
 }
 
 void WindowTreeClient::RequestClose(uint32_t window_id) {
   Window* window = GetWindowByServerId(window_id);
   if (!window || !IsRoot(window))
     return;
 
-  FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(window).observers(),
-                    OnRequestClose(window));
+  for (auto& observer : *WindowPrivate(window).observers())
+    observer.OnRequestClose(window);
 }
 
 void WindowTreeClient::OnConnect(ClientSpecificId client_id) {
   client_id_ = client_id;
 }
 
 void WindowTreeClient::WmNewDisplayAdded(const display::Display& display,
                                          mojom::WindowDataPtr root_data,
                                          bool parent_drawn) {
   WmNewDisplayAddedImpl(display, std::move(root_data), parent_drawn);
@@ skipping 169 matching lines @@
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
         server_id(window), offset.x(), offset.y(), hit_area);
   }
 }
 
 }  // namespace ui