Use const ref for LocalFrame::LocalFrameRoot and FrameTree::Top

third_party/WebKit/Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 250 matching lines @@
     const LayoutPoint& point,
     HitTestRequest::HitTestRequestType hit_type,
     const LayoutSize& padding) {
   TRACE_EVENT0("blink", "EventHandler::hitTestResultAtPoint");
 
   ASSERT((hit_type & HitTestRequest::kListBased) || padding.IsEmpty());
 
   // We always send hitTestResultAtPoint to the main frame if we have one,
   // otherwise we might hit areas that are obscured by higher frames.
   if (frame_->GetPage()) {
-    LocalFrame* main_frame = frame_->LocalFrameRoot();
-    if (main_frame && frame_ != main_frame) {
+    LocalFrame& main_frame = frame_->LocalFrameRoot();
+    if (frame_ != &main_frame) {
       FrameView* frame_view = frame_->View();
-      FrameView* main_view = main_frame->View();
+      FrameView* main_view = main_frame.View();
       if (frame_view && main_view) {
         IntPoint main_frame_point = main_view->RootFrameToContents(
             frame_view->ContentsToRootFrame(RoundedIntPoint(point)));
-        return main_frame->GetEventHandler().HitTestResultAtPoint(
+        return main_frame.GetEventHandler().HitTestResultAtPoint(
             main_frame_point, hit_type, padding);
       }
     }
   }
 
   // hitTestResultAtPoint is specifically used to hitTest into all frames, thus
   // it always allows child frame content.
   HitTestRequest request(hit_type | HitTestRequest::kAllowChildFrameContent);
   HitTestResult result(request, point, padding.Height().ToUnsigned(),
                        padding.Width().ToUnsigned(),
@@ skipping 83 matching lines @@
   ASSERT(frame_->GetDocument());
 
   UpdateCursor();
 }
 
 void EventHandler::UpdateCursor() {
   TRACE_EVENT0("input", "EventHandler::updateCursor");
 
   // We must do a cross-frame hit test because the frame that triggered the
   // cursor update could be occluded by a different frame.
-  ASSERT(frame_ == frame_->LocalFrameRoot());
+  DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
 
   FrameView* view = frame_->View();
   if (!view || !view->ShouldSetCursor())
     return;
 
   LayoutViewItem layout_view_item = view->GetLayoutViewItem();
   if (layout_view_item.IsNull())
     return;
 
   frame_->GetDocument()->UpdateStyleAndLayout();
@@ skipping 238 matching lines @@
       capturing_mouse_events_node_ = mev.InnerNode();
       event_handler_will_reset_capturing_mouse_events_node_ = true;
     }
     mouse_event_manager_->InvalidateClick();
     return result;
   }
 
   UserGestureIndicator gesture_indicator(
       DocumentUserGestureToken::Create(frame_->GetDocument()));
   frame_->LocalFrameRoot()
-      ->GetEventHandler()
+      .GetEventHandler()
       .last_mouse_down_user_gesture_token_ =
       UserGestureIndicator::CurrentToken();
 
   if (RuntimeEnabledFeatures::middleClickAutoscrollEnabled()) {
     // We store whether middle click autoscroll is in progress before calling
     // stopAutoscroll() because it will set m_autoscrollType to NoAutoscroll on
     // return.
     bool is_middle_click_autoscroll_in_progress =
         scroll_manager_->MiddleClickAutoscrollInProgress();
     scroll_manager_->StopAutoscroll();
@@ skipping 322 matching lines @@
   if (subframe)
     return PassMouseReleaseEventToSubframe(mev, subframe);
 
   // Mouse events will be associated with the Document where mousedown
   // occurred. If, e.g., there is a mousedown, then a drag to a different
   // Document and mouseup there, the mouseup's gesture will be associated with
   // the mousedown's Document. It's not absolutely certain that this is the
   // correct behavior.
   std::unique_ptr<UserGestureIndicator> gesture_indicator;
   if (frame_->LocalFrameRoot()
-          ->GetEventHandler()
+          .GetEventHandler()
           .last_mouse_down_user_gesture_token_) {
     gesture_indicator = WTF::WrapUnique(new UserGestureIndicator(
         frame_->LocalFrameRoot()
-            ->GetEventHandler()
+            .GetEventHandler()
             .last_mouse_down_user_gesture_token_.Release()));
   } else {
     gesture_indicator = WTF::WrapUnique(new UserGestureIndicator(
         DocumentUserGestureToken::Create(frame_->GetDocument())));
   }
 
   WebInputEventResult event_result = UpdatePointerTargetAndDispatchEvents(
       EventTypeNames::mouseup, mev.InnerNode(), mev.CanvasRegionId(),
       mev.Event(), Vector<WebMouseEvent>());
 
@@ skipping 169 matching lines @@
     // If the target node is a text node, dispatch on the parent node -
     // rdar://4196646
     if (new_node_under_mouse && new_node_under_mouse->IsTextNode())
       new_node_under_mouse = FlatTreeTraversal::Parent(*new_node_under_mouse);
   }
   return new_node_under_mouse;
 }
 
 bool EventHandler::IsTouchPointerIdActiveOnFrame(int pointer_id,
                                                  LocalFrame* frame) const {
-  DCHECK_EQ(frame_, frame_->LocalFrameRoot());
+  DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
   return pointer_event_manager_->IsTouchPointerIdActiveOnFrame(pointer_id,
                                                                frame);
 }
 
 bool EventHandler::RootFrameTouchPointerActiveInCurrentFrame(
     int pointer_id) const {
-  return frame_ != frame_->LocalFrameRoot() &&
+  return frame_ != &frame_->LocalFrameRoot() &&
          frame_->LocalFrameRoot()
-             ->GetEventHandler()
+             .GetEventHandler()
              .IsTouchPointerIdActiveOnFrame(pointer_id, frame_);
 }
 
 bool EventHandler::IsPointerEventActive(int pointer_id) {
   return pointer_event_manager_->IsActive(pointer_id) ||
          RootFrameTouchPointerActiveInCurrentFrame(pointer_id);
 }
 
 void EventHandler::SetPointerCapture(int pointer_id, EventTarget* target) {
   // TODO(crbug.com/591387): This functionality should be per page not per
   // frame.
   if (RootFrameTouchPointerActiveInCurrentFrame(pointer_id)) {
-    frame_->LocalFrameRoot()->GetEventHandler().SetPointerCapture(pointer_id,
-                                                                  target);
+    frame_->LocalFrameRoot().GetEventHandler().SetPointerCapture(pointer_id,
+                                                                 target);
   } else {
     pointer_event_manager_->SetPointerCapture(pointer_id, target);
   }
 }
 
 void EventHandler::ReleasePointerCapture(int pointer_id, EventTarget* target) {
   if (RootFrameTouchPointerActiveInCurrentFrame(pointer_id)) {
-    frame_->LocalFrameRoot()->GetEventHandler().ReleasePointerCapture(
-        pointer_id, target);
+    frame_->LocalFrameRoot().GetEventHandler().ReleasePointerCapture(pointer_id,
+                                                                     target);
   } else {
     pointer_event_manager_->ReleasePointerCapture(pointer_id, target);
   }
 }
 
 bool EventHandler::HasPointerCapture(int pointer_id,
                                      const EventTarget* target) const {
   if (RootFrameTouchPointerActiveInCurrentFrame(pointer_id)) {
-    return frame_->LocalFrameRoot()->GetEventHandler().HasPointerCapture(
+    return frame_->LocalFrameRoot().GetEventHandler().HasPointerCapture(
         pointer_id, target);
   } else {
     return pointer_event_manager_->HasPointerCapture(pointer_id, target);
   }
 }
 
 bool EventHandler::HasProcessedPointerCapture(int pointer_id,
                                               const EventTarget* target) const {
   return pointer_event_manager_->HasProcessedPointerCapture(pointer_id, target);
 }
@@ skipping 74 matching lines @@
     if (dom_event_result != DispatchEventResult::kNotCanceled)
       return EventHandlingUtil::ToWebInputEventResult(dom_event_result);
   }
 
   return WebInputEventResult::kNotHandled;
 }
 
 WebInputEventResult EventHandler::HandleGestureEvent(
     const WebGestureEvent& gesture_event) {
   // Propagation to inner frames is handled below this function.
-  ASSERT(frame_ == frame_->LocalFrameRoot());
+  DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
   DCHECK_NE(0, gesture_event.FrameScale());
 
   // Scrolling-related gesture events invoke EventHandler recursively for each
   // frame down the chain, doing a single-frame hit-test per frame. This matches
   // handleWheelEvent.
   // FIXME: Add a test that traverses this path, e.g. for devtools overlay.
   if (gesture_event.IsScrollEvent())
     return HandleGestureScrollEvent(gesture_event);
 
   // Hit test across all frames and do touch adjustment as necessary for the
   // event type.
   GestureEventWithHitTestResults targeted_event =
       TargetGestureEvent(gesture_event);
 
   return HandleGestureEvent(targeted_event);
 }
 
 WebInputEventResult EventHandler::HandleGestureEvent(
     const GestureEventWithHitTestResults& targeted_event) {
   TRACE_EVENT0("input", "EventHandler::handleGestureEvent");
   if (!frame_->GetPage())
     return WebInputEventResult::kNotHandled;
 
   // Propagation to inner frames is handled below this function.
-  ASSERT(frame_ == frame_->LocalFrameRoot());
+  DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
 
   // Non-scrolling related gesture events do a single cross-frame hit-test and
   // jump directly to the inner most frame. This matches handleMousePressEvent
   // etc.
   ASSERT(!targeted_event.Event().IsScrollEvent());
 
   // Update mouseout/leave/over/enter events before jumping directly to the
   // inner most frame.
   if (targeted_event.Event().GetType() == WebInputEvent::kGestureTap)
     UpdateGestureTargetNodeForMouseEvent(targeted_event);
@@ skipping 123 matching lines @@
                               touch_rect, HeapVector<Member<Node>>(nodes));
 }
 
 // Update the hover and active state across all frames for this gesture.
 // This logic is different than the mouse case because mice send MouseLeave
 // events to frames as they're exited.  With gestures, a single event
 // conceptually both 'leaves' whatever frame currently had hover and enters a
 // new frame
 void EventHandler::UpdateGestureHoverActiveState(const HitTestRequest& request,
                                                  Element* inner_element) {
-  ASSERT(frame_ == frame_->LocalFrameRoot());
+  DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
 
   HeapVector<Member<LocalFrame>> new_hover_frame_chain;
   LocalFrame* new_hover_frame_in_document =
       inner_element ? inner_element->GetDocument().GetFrame() : nullptr;
   // Insert the ancestors of the frame having the new hovered element to the
   // frame chain.  The frame chain doesn't include the main frame to avoid the
   // redundant work that cleans the hover state because the hover state for the
   // main frame is updated by calling Document::updateHoverActiveState.
   while (new_hover_frame_in_document && new_hover_frame_in_document != frame_) {
     new_hover_frame_chain.push_back(new_hover_frame_in_document);
@@ skipping 40 matching lines @@
   // Recursively set the new active/hover states on every frame in the chain of
   // innerElement.
   frame_->GetDocument()->UpdateHoverActiveState(request, inner_element);
 }
 
 // Update the mouseover/mouseenter/mouseout/mouseleave events across all frames
 // for this gesture, before passing the targeted gesture event directly to a hit
 // frame.
 void EventHandler::UpdateGestureTargetNodeForMouseEvent(
     const GestureEventWithHitTestResults& targeted_event) {
-  ASSERT(frame_ == frame_->LocalFrameRoot());
+  DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
 
   // Behaviour of this function is as follows:
   // - Create the chain of all entered frames.
   // - Compare the last frame chain under the gesture to newly entered frame
   //   chain from the main frame one by one.
   // - If the last frame doesn't match with the entered frame, then create the
   //   chain of exited frames from the last frame chain.
   // - Dispatch mouseout/mouseleave events of the exited frames from the inside
   //   out.
   // - Dispatch mouseover/mouseenter events of the entered frames into the
@@ skipping 76 matching lines @@
               String(), fake_mouse_move);
     }
   }
 }
 
 GestureEventWithHitTestResults EventHandler::TargetGestureEvent(
     const WebGestureEvent& gesture_event,
     bool read_only) {
   TRACE_EVENT0("input", "EventHandler::targetGestureEvent");
 
-  ASSERT(frame_ == frame_->LocalFrameRoot());
+  DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
   // Scrolling events get hit tested per frame (like wheel events do).
   ASSERT(!gesture_event.IsScrollEvent());
 
   HitTestRequest::HitTestRequestType hit_type =
       gesture_manager_->GetHitTypeForGestureType(gesture_event.GetType());
   TimeDelta active_interval;
   bool should_keep_active_for_min_interval = false;
   if (read_only) {
     hit_type |= HitTestRequest::kReadOnly;
   } else if (gesture_event.GetType() == WebInputEvent::kGestureTap &&
@@ skipping 247 matching lines @@
 void EventHandler::ScheduleHoverStateUpdate() {
   // TODO(https://crbug.com/668758): Use a normal BeginFrame update for this.
   if (!hover_timer_.IsActive() &&
       !mouse_event_manager_->IsMousePositionUnknown())
     hover_timer_.StartOneShot(0, BLINK_FROM_HERE);
 }
 
 void EventHandler::ScheduleCursorUpdate() {
   // We only want one timer for the page, rather than each frame having it's own
   // timer competing which eachother (since there's only one mouse cursor).
-  ASSERT(frame_ == frame_->LocalFrameRoot());
+  DCHECK_EQ(frame_, &frame_->LocalFrameRoot());
 
   // TODO(https://crbug.com/668758): Use a normal BeginFrame update for this.
   if (!cursor_update_timer_.IsActive())
     cursor_update_timer_.StartOneShot(kCursorUpdateInterval, BLINK_FROM_HERE);
 }
 
 bool EventHandler::CursorUpdatePending() {
   return cursor_update_timer_.IsActive();
 }
 
@@ skipping 197 matching lines @@
     MouseEventWithHitTestResults& mev,
     LocalFrame* subframe) {
   WebInputEventResult result =
       subframe->GetEventHandler().HandleMouseReleaseEvent(mev.Event());
   if (result != WebInputEventResult::kNotHandled)
     return result;
   return WebInputEventResult::kHandledSystem;
 }
 
 }  // namespace blink