Remove usage of FOR_EACH_OBSERVER macro in content/renderer

content/renderer/render_widget.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 "content/renderer/render_widget.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 628 matching lines @@
 }
 
 void RenderWidget::OnDisableDeviceEmulation() {
   screen_metrics_emulator_.reset();
 }
 
 void RenderWidget::OnWasHidden() {
   TRACE_EVENT0("renderer", "RenderWidget::OnWasHidden");
   // Go into a mode where we stop generating paint and scrolling events.
   SetHidden(true);
-  FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
-                    WasHidden());
+  for (auto& observer : render_frames_)
+    observer.WasHidden();
 }
 
 void RenderWidget::OnWasShown(bool needs_repainting,
                               const ui::LatencyInfo& latency_info) {
   TRACE_EVENT0("renderer", "RenderWidget::OnWasShown");
   // During shutdown we can just ignore this message.
   if (!GetWebWidget())
     return;
 
   // See OnWasHidden
   SetHidden(false);
-  FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
-                    WasShown());
+  for (auto& observer : render_frames_)
+    observer.WasShown();
 
   if (!needs_repainting)
     return;
 
   // Generate a full repaint.
   if (compositor_) {
     ui::LatencyInfo swap_latency_info(latency_info);
     std::unique_ptr<cc::SwapPromiseMonitor> latency_info_swap_promise_monitor(
         compositor_->CreateLatencyInfoSwapPromiseMonitor(&swap_latency_info));
     compositor_->SetNeedsForcedRedraw();
@@ skipping 32 matching lines @@
     const EditCommands& edit_commands) {
   edit_commands_ = edit_commands;
 }
 
 void RenderWidget::OnSetFocus(bool enable) {
   has_focus_ = enable;
 
   if (GetWebWidget())
     GetWebWidget()->setFocus(enable);
 
-  FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
-                    RenderWidgetSetFocus(enable));
+  for (auto& observer : render_frames_)
+    observer.RenderWidgetSetFocus(enable);
 }
 
 void RenderWidget::SetNeedsMainFrame() {
   RenderWidgetCompositor* rwc = compositor();
   if (!rwc)
     return;
   rwc->setNeedsBeginFrame();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 30 matching lines @@
   return RenderThreadImpl::current()->CreateCompositorFrameSink(
       fallback, routing_id_, frame_swap_message_queue_,
       GetURLForGraphicsContext3D());
 }
 
 void RenderWidget::DidCommitAndDrawCompositorFrame() {
   // NOTE: Tests may break if this event is renamed or moved. See
   // tab_capture_performancetest.cc.
   TRACE_EVENT0("gpu", "RenderWidget::DidCommitAndDrawCompositorFrame");
 
-  FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
-                    DidCommitAndDrawCompositorFrame());
+  for (auto& observer : render_frames_)
+    observer.DidCommitAndDrawCompositorFrame();
 
   // Notify subclasses that we initiated the paint operation.
   DidInitiatePaint();
 }
 
 void RenderWidget::DidCommitCompositorFrame() {
-  FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
-                    DidCommitCompositorFrame());
-  FOR_EACH_OBSERVER(RenderFrameProxy, render_frame_proxies_,
-                    DidCommitCompositorFrame());
+  for (auto& observer : render_frames_)
+    observer.DidCommitCompositorFrame();
+  for (auto& observer : render_frame_proxies_)
+    observer.DidCommitCompositorFrame();
   input_handler_->FlushPendingInputEventAck();
 }
 
 void RenderWidget::DidCompletePageScaleAnimation() {}
 
 void RenderWidget::DidCompleteSwapBuffers() {
   TRACE_EVENT0("renderer", "RenderWidget::DidCompleteSwapBuffers");
 
   // Notify subclasses threaded composited rendering was flushed to the screen.
   DidFlushPaint();
@@ skipping 46 matching lines @@
 
 void RenderWidget::WillBeginCompositorFrame() {
   TRACE_EVENT0("gpu", "RenderWidget::willBeginCompositorFrame");
 
   // The UpdateTextInputState can result in further layout and possibly
   // enable GPU acceleration so they need to be called before any painting
   // is done.
   UpdateTextInputState(ShowIme::HIDE_IME, ChangeSource::FROM_NON_IME);
   UpdateSelectionBounds();
 
-  FOR_EACH_OBSERVER(RenderFrameProxy, render_frame_proxies_,
-                    WillBeginCompositorFrame());
+  for (auto& observer : render_frame_proxies_)
+    observer.WillBeginCompositorFrame();
 }
 
 std::unique_ptr<cc::SwapPromise> RenderWidget::RequestCopyOfOutputForLayoutTest(
     std::unique_ptr<cc::CopyOutputRequest> request) {
   return RenderThreadImpl::current()->RequestCopyOfOutputForLayoutTest(
       routing_id_, std::move(request));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetInputHandlerDelegate
@@ skipping 136 matching lines @@
 }
 
 bool RenderWidget::WillHandleGestureEvent(const blink::WebGestureEvent& event) {
   if (owner_delegate_)
     return owner_delegate_->RenderWidgetWillHandleGestureEvent(event);
 
   return false;
 }
 
 bool RenderWidget::WillHandleMouseEvent(const blink::WebMouseEvent& event) {
-  FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
-                    RenderWidgetWillHandleMouseEvent());
+  for (auto& observer : render_frames_)
+    observer.RenderWidgetWillHandleMouseEvent();
 
   if (owner_delegate_)
     return owner_delegate_->RenderWidgetWillHandleMouseEvent(event);
 
   return false;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetScreenMetricsDelegate
 
@@ skipping 147 matching lines @@
 blink::WebLayerTreeView* RenderWidget::layerTreeView() {
   return compositor_.get();
 }
 
 void RenderWidget::didMeaningfulLayout(blink::WebMeaningfulLayout layout_type) {
   if (layout_type == blink::WebMeaningfulLayout::VisuallyNonEmpty) {
     QueueMessage(new ViewHostMsg_DidFirstVisuallyNonEmptyPaint(routing_id_),
                  MESSAGE_DELIVERY_POLICY_WITH_VISUAL_STATE);
   }
 
-  FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_,
-                    DidMeaningfulLayout(layout_type));
+  for (auto& observer : render_frames_)
+    observer.DidMeaningfulLayout(layout_type);
 }
 
 void RenderWidget::ScheduleComposite() {
   if (compositor_ &&
       compositor_deps_->GetCompositorImplThreadTaskRunner().get()) {
     compositor_->setNeedsCompositorUpdate();
   }
 }
 
 void RenderWidget::ScheduleCompositeWithForcedRedraw() {
@@ skipping 84 matching lines @@
   Send(new ViewHostMsg_ShowWidget(opener_id_, routing_id_, initial_rect_));
   SetPendingWindowRect(initial_rect_);
 }
 
 void RenderWidget::DoDeferredClose() {
   WillCloseLayerTreeView();
   Send(new ViewHostMsg_Close(routing_id_));
 }
 
 void RenderWidget::NotifyOnClose() {
-  FOR_EACH_OBSERVER(RenderFrameImpl, render_frames_, WidgetWillClose());
+  for (auto& observer : render_frames_)
+    observer.WidgetWillClose();
 }
 
 void RenderWidget::closeWidgetSoon() {
   DCHECK(content::RenderThread::Get());
   if (is_swapped_out_) {
     // This widget is currently swapped out, and the active widget is in a
     // different process.  Have the browser route the close request to the
     // active widget instead, so that the correct unload handlers are run.
     Send(new ViewHostMsg_RouteCloseEvent(routing_id_));
     return;
@@ skipping 887 matching lines @@
 bool RenderWidget::isPointerLocked() {
   return mouse_lock_dispatcher_->IsMouseLockedTo(
       webwidget_mouse_lock_target_.get());
 }
 
 blink::WebWidget* RenderWidget::GetWebWidget() const {
   return webwidget_internal_;
 }
 
 }  // namespace content