Remove usage of FOR_EACH_OBSERVER macro in content/renderer

content/renderer/render_view_impl.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_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 
@@ skipping 863 matching lines @@
   // Make sure we are no longer referenced by the ViewMap or RoutingIDViewMap.
   ViewMap* views = g_view_map.Pointer();
   for (ViewMap::iterator it = views->begin(); it != views->end(); ++it)
     DCHECK_NE(this, it->second) << "Failed to call Close?";
   RoutingIDViewMap* routing_id_views = g_routing_id_view_map.Pointer();
   for (RoutingIDViewMap::iterator it = routing_id_views->begin();
        it != routing_id_views->end(); ++it)
     DCHECK_NE(this, it->second) << "Failed to call Close?";
 #endif
 
-  FOR_EACH_OBSERVER(RenderViewObserver, observers_, RenderViewGone());
-  FOR_EACH_OBSERVER(RenderViewObserver, observers_, OnDestruct());
+  for (auto& observer : observers_)
+    observer.RenderViewGone();
+  for (auto& observer : observers_)
+    observer.OnDestruct();
 }
 
 /*static*/
 RenderViewImpl* RenderViewImpl::FromWebView(WebView* webview) {
   ViewMap* views = g_view_map.Pointer();
   ViewMap::iterator it = views->find(webview);
   return it == views->end() ? NULL : it->second;
 }
 
 /*static*/
@@ skipping 353 matching lines @@
 
 void RenderViewImpl::TransferActiveWheelFlingAnimation(
     const blink::WebActiveWheelFlingParameters& params) {
   if (webview())
     webview()->transferActiveWheelFlingAnimation(params);
 }
 
 // RenderWidgetInputHandlerDelegate -----------------------------------------
 
 void RenderViewImpl::RenderWidgetFocusChangeComplete() {
-  FOR_EACH_OBSERVER(RenderViewObserver, observers_, FocusChangeComplete());
+  for (auto& observer : observers_)
+    observer.FocusChangeComplete();
 }
 
 bool RenderViewImpl::DoesRenderWidgetHaveTouchEventHandlersAt(
     const gfx::Point& point) const {
   if (!webview())
     return false;
   return webview()->hasTouchEventHandlersAt(point);
 }
 
 bool RenderViewImpl::RenderWidgetWillHandleGestureEvent(
@@ skipping 351 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("PrintPreview.InitiatedByScript",
                         frame->top() == frame);
 
   // Logging whether the top frame is remote is sufficient in this case. If
   // the top frame is local, the printing code will function correctly and
   // the frame itself will be printed, so the cases this histogram tracks is
   // where printing of a subframe will fail as of now.
   UMA_HISTOGRAM_BOOLEAN("PrintPreview.OutOfProcessSubframe",
                         frame->top()->isWebRemoteFrame());
 
-  FOR_EACH_OBSERVER(RenderViewObserver, observers_,
-                    PrintPage(frame, input_handler().handling_input_event()));
+  for (auto& observer : observers_)
+    observer.PrintPage(frame, input_handler().handling_input_event());
 }
 
 bool RenderViewImpl::enumerateChosenDirectory(
     const WebString& path,
     WebFileChooserCompletion* chooser_completion) {
   int id = enumeration_completion_id_++;
   enumeration_completions_[id] = chooser_completion;
   return Send(new ViewHostMsg_EnumerateDirectory(
       GetRoutingID(), id, blink::WebStringToFilePath(path)));
 }
 
 void RenderViewImpl::FrameDidStartLoading(WebFrame* frame) {
   DCHECK_GE(frames_in_progress_, 0);
-  if (frames_in_progress_ == 0)
-    FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidStartLoading());
+  if (frames_in_progress_ == 0) {
+    for (auto& observer : observers_)
+      observer.DidStartLoading();
+  }
   frames_in_progress_++;
 }
 
 void RenderViewImpl::FrameDidStopLoading(WebFrame* frame) {
   // TODO(japhet): This should be a DCHECK, but the pdf plugin sometimes
   // calls DidStopLoading() without a matching DidStartLoading().
   if (frames_in_progress_ == 0)
     return;
   frames_in_progress_--;
   if (frames_in_progress_ == 0) {
     DidStopLoadingIcons();
-    FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidStopLoading());
+    for (auto& observer : observers_)
+      observer.DidStopLoading();
   }
 }
 
 void RenderViewImpl::AttachWebFrameWidget(blink::WebFrameWidget* frame_widget) {
   // The previous WebFrameWidget must already be detached by CloseForFrame().
   DCHECK(!frame_widget_);
   frame_widget_ = frame_widget;
 }
 
 void RenderViewImpl::SetZoomLevel(double zoom_level) {
   // If we change the zoom level for the view, make sure any subsequent subframe
   // loads reflect the current zoom level.
   page_zoom_level_ = zoom_level;
 
   webview()->setZoomLevel(zoom_level);
-  FOR_EACH_OBSERVER(RenderViewObserver, observers_, OnZoomLevelChanged());
+  for (auto& observer : observers_)
+    observer.OnZoomLevelChanged();
 }
 
 void RenderViewImpl::didCancelCompositionOnSelectionChange() {
   Send(new InputHostMsg_ImeCancelComposition(GetRoutingID()));
 }
 
 void RenderViewImpl::SetValidationMessageDirection(
     base::string16* wrapped_main_text,
     blink::WebTextDirection main_text_hint,
     base::string16* wrapped_sub_text,
@@ skipping 159 matching lines @@
     WebElement element = const_cast<WebNode&>(toNode).to<WebElement>();
     blink::WebRect rect = element.boundsInViewport();
     ConvertViewportToWindowViaWidget(&rect);
     node_bounds = gfx::Rect(rect);
     is_editable = element.isEditable();
   }
   Send(new ViewHostMsg_FocusedNodeChanged(GetRoutingID(), is_editable,
                                           node_bounds));
 
   // TODO(estade): remove.
-  FOR_EACH_OBSERVER(RenderViewObserver, observers_, FocusedNodeChanged(toNode));
+  for (auto& observer : observers_)
+    observer.FocusedNodeChanged(toNode);
 
   RenderFrameImpl* previous_frame = nullptr;
   if (!fromNode.isNull())
     previous_frame = RenderFrameImpl::FromWebFrame(fromNode.document().frame());
   RenderFrameImpl* new_frame = nullptr;
   if (!toNode.isNull())
     new_frame = RenderFrameImpl::FromWebFrame(toNode.document().frame());
 
   if (previous_frame && previous_frame != new_frame)
     previous_frame->FocusedNodeChanged(WebNode());
   if (new_frame)
     new_frame->FocusedNodeChanged(toNode);
 
   // TODO(dmazzoni): remove once there's a separate a11y tree per frame.
   if (main_render_frame_)
     main_render_frame_->FocusedNodeChangedForAccessibility(toNode);
 }
 
 void RenderViewImpl::didUpdateLayout() {
-  FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidUpdateLayout());
+  for (auto& observer : observers_)
+    observer.DidUpdateLayout();
 
   // We don't always want to set up a timer, only if we've been put in that
   // mode by getting a |ViewMsg_EnablePreferredSizeChangedMode|
   // message.
   if (!send_preferred_size_changes_ || !webview())
     return;
 
   if (check_preferred_size_timer_.IsRunning())
     return;
   check_preferred_size_timer_.Start(FROM_HERE,
@@ skipping 47 matching lines @@
   // NOTE: initial_rect_ may still have its default values at this point, but
   // that's okay.  It'll be ignored if disposition is not NEW_POPUP, or the
   // browser process will impose a default position otherwise.
   Send(new ViewHostMsg_ShowView(opener_id_, GetRoutingID(),
                                 NavigationPolicyToDisposition(policy),
                                 initial_rect_, opened_by_user_gesture_));
   SetPendingWindowRect(initial_rect_);
 }
 
 void RenderViewImpl::onMouseDown(const WebNode& mouse_down_node) {
-  FOR_EACH_OBSERVER(
-      RenderViewObserver, observers_, OnMouseDown(mouse_down_node));
+  for (auto& observer : observers_)
+    observer.OnMouseDown(mouse_down_node);
 }
 
 void RenderViewImpl::didHandleGestureEvent(
     const WebGestureEvent& event,
     bool event_cancelled) {
   RenderWidget::didHandleGestureEvent(event, event_cancelled);
 
   if (!event_cancelled) {
-    FOR_EACH_OBSERVER(
-        RenderViewObserver, observers_, DidHandleGestureEvent(event));
+    for (auto& observer : observers_)
+      observer.DidHandleGestureEvent(event);
   }
 
   // TODO(ananta): Piggyback off existing IPCs to communicate this information,
   // crbug/420130.
 #if defined(OS_WIN)
   if (event.type != blink::WebGestureEvent::GestureTap)
     return;
 
   // TODO(estade): hit test the event against focused node to make sure
   // the tap actually hit the focused node.
@@ skipping 487 matching lines @@
     webview()->mainFrame()->toWebLocalFrame()->sendOrientationChangeEvent();
 }
 
 void RenderViewImpl::OnPluginActionAt(const gfx::Point& location,
                                       const WebPluginAction& action) {
   if (webview())
     webview()->performPluginAction(action, location);
 }
 
 void RenderViewImpl::OnClosePage() {
-  FOR_EACH_OBSERVER(RenderViewObserver, observers_, ClosePage());
+  for (auto& observer : observers_)
+    observer.ClosePage();
   // TODO(creis): We'd rather use webview()->Close() here, but that currently
   // sets the WebView's delegate_ to NULL, preventing any JavaScript dialogs
   // in the onunload handler from appearing.  For now, we're bypassing that and
   // calling the FrameLoader's CloseURL method directly.  This should be
   // revisited to avoid having two ways to close a page.  Having a single way
   // to close that can run onunload is also useful for fixing
   // http://b/issue?id=753080.
   webview()->mainFrame()->dispatchUnloadEvent();
 
   Send(new ViewHostMsg_ClosePage_ACK(GetRoutingID()));
@@ skipping 260 matching lines @@
 
 double RenderViewImpl::zoomLevelToZoomFactor(double zoom_level) const {
   return ZoomLevelToZoomFactor(zoom_level);
 }
 
 double RenderViewImpl::zoomFactorToZoomLevel(double factor) const {
   return ZoomFactorToZoomLevel(factor);
 }
 
 void RenderViewImpl::draggableRegionsChanged() {
-  FOR_EACH_OBSERVER(
-      RenderViewObserver,
-      observers_,
-      DraggableRegionsChanged(webview()->mainFrame()));
+  for (auto& observer : observers_)
+    observer.DraggableRegionsChanged(webview()->mainFrame());
 }
 
 void RenderViewImpl::pageImportanceSignalsChanged() {
   if (!webview() || !main_render_frame_)
     return;
 
   auto* web_signals = webview()->pageImportanceSignals();
 
   PageImportanceSignals signals;
   signals.had_form_interaction = web_signals->hadFormInteraction();
@@ skipping 217 matching lines @@
 void RenderViewImpl::OnReleaseDisambiguationPopupBitmap(
     const cc::SharedBitmapId& id) {
   BitmapMap::iterator it = disambiguation_bitmaps_.find(id);
   DCHECK(it != disambiguation_bitmaps_.end());
   delete it->second;
   disambiguation_bitmaps_.erase(it);
 }
 
 void RenderViewImpl::DidCommitCompositorFrame() {
   RenderWidget::DidCommitCompositorFrame();
-  FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidCommitCompositorFrame());
+  for (auto& observer : observers_)
+    observer.DidCommitCompositorFrame();
 }
 
 void RenderViewImpl::SendUpdateFaviconURL(const std::vector<FaviconURL>& urls) {
   if (!urls.empty())
     Send(new ViewHostMsg_UpdateFaviconURL(GetRoutingID(), urls));
 }
 
 void RenderViewImpl::DidStopLoadingIcons() {
   int icon_types = WebIconURL::TypeFavicon | WebIconURL::TypeTouchPrecomposed |
       WebIconURL::TypeTouch;
@@ skipping 24 matching lines @@
   if (IsUseZoomForDSFEnabled()) {
     webview()->setZoomFactorForDeviceScaleFactor(device_scale_factor_);
   } else {
     webview()->setDeviceScaleFactor(device_scale_factor_);
   }
   webview()->settings()->setPreferCompositingToLCDTextEnabled(
       PreferCompositingToLCDText(compositor_deps_, device_scale_factor_));
 }
 
 }  // namespace content