Rename *isOverWidget* methods to ...isOverFrameViewBase...

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

 // Copyright 2016 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 "core/input/ScrollManager.h"
 
 #include <memory>
 #include "core/dom/DOMNodeIds.h"
 #include "core/events/GestureEvent.h"
 #include "core/frame/BrowserControls.h"
@@ skipping 15 matching lines @@
 #include "platform/RuntimeEnabledFeatures.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 ScrollManager::ScrollManager(LocalFrame& frame) : m_frame(frame) {
   clear();
 }
 
 void ScrollManager::clear() {
-  m_lastGestureScrollOverWidget = false;
+  m_lastGestureScrollOverFrameViewBase = false;
   m_scrollbarHandlingScrollGesture = nullptr;
   m_resizeScrollableArea = nullptr;
   m_offsetFromResizeCorner = LayoutSize();
   clearGestureScrollState();
 }
 
 DEFINE_TRACE(ScrollManager) {
   visitor->trace(m_frame);
   visitor->trace(m_scrollGestureHandlingNode);
   visitor->trace(m_previousGestureScrolledElement);
@@ skipping 165 matching lines @@
     m_scrollGestureHandlingNode =
         m_scrollGestureHandlingNode->parentOrShadowHostNode();
 
   if (!m_scrollGestureHandlingNode)
     m_scrollGestureHandlingNode = m_frame->document()->documentElement();
 
   if (!m_scrollGestureHandlingNode ||
       !m_scrollGestureHandlingNode->layoutObject())
     return WebInputEventResult::NotHandled;
 
-  passScrollGestureEventToWidget(gestureEvent,
-                                 m_scrollGestureHandlingNode->layoutObject());
+  passScrollGestureEvent(gestureEvent,
+                         m_scrollGestureHandlingNode->layoutObject());
 
   m_currentScrollChain.clear();
   std::unique_ptr<ScrollStateData> scrollStateData =
       WTF::makeUnique<ScrollStateData>();
   IntPoint position = flooredIntPoint(gestureEvent.positionInRootFrame());
   scrollStateData->position_x = position.x();
   scrollStateData->position_y = position.y();
   scrollStateData->is_beginning = true;
   scrollStateData->from_user_input = true;
   scrollStateData->is_direct_manipulation =
@@ skipping 22 matching lines @@
   FloatSize velocity(-gestureEvent.velocityX(), -gestureEvent.velocityY());
   FloatPoint position(gestureEvent.positionInRootFrame());
 
   if (delta.isZero())
     return WebInputEventResult::NotHandled;
 
   LayoutObject* layoutObject = node->layoutObject();
 
   // Try to send the event to the correct view.
   WebInputEventResult result =
-      passScrollGestureEventToWidget(gestureEvent, layoutObject);
+      passScrollGestureEvent(gestureEvent, layoutObject);
   if (result != WebInputEventResult::NotHandled) {
     // FIXME: we should allow simultaneous scrolling of nested
     // iframes along perpendicular axes. See crbug.com/466991.
     m_deltaConsumedForScrollSequence = true;
     return result;
   }
 
   std::unique_ptr<ScrollStateData> scrollStateData =
       WTF::makeUnique<ScrollStateData>();
   scrollStateData->delta_x = delta.width();
@@ skipping 42 matching lines @@
   }
 
   return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult ScrollManager::handleGestureScrollEnd(
     const WebGestureEvent& gestureEvent) {
   Node* node = m_scrollGestureHandlingNode;
 
   if (node && node->layoutObject()) {
-    passScrollGestureEventToWidget(gestureEvent, node->layoutObject());
+    passScrollGestureEvent(gestureEvent, node->layoutObject());
     std::unique_ptr<ScrollStateData> scrollStateData =
         WTF::makeUnique<ScrollStateData>();
     scrollStateData->is_ending = true;
     scrollStateData->is_in_inertial_phase =
         gestureEvent.inertialPhase() == WebGestureEvent::MomentumPhase;
     scrollStateData->from_user_input = true;
     scrollStateData->is_direct_manipulation =
         gestureEvent.sourceDevice == WebGestureDeviceTouchscreen;
     scrollStateData->delta_consumed_for_scroll_sequence =
         m_deltaConsumedForScrollSequence;
     ScrollState* scrollState = ScrollState::create(std::move(scrollStateData));
     customizedScroll(*node, *scrollState);
   }
 
   clearGestureScrollState();
   return WebInputEventResult::NotHandled;
 }
 
 FrameHost* ScrollManager::frameHost() const {
   if (!m_frame->page())
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
-WebInputEventResult ScrollManager::passScrollGestureEventToWidget(
+WebInputEventResult ScrollManager::passScrollGestureEvent(
     const WebGestureEvent& gestureEvent,
     LayoutObject* layoutObject) {
   DCHECK(gestureEvent.isScrollEvent());
 
-  if (!m_lastGestureScrollOverWidget || !layoutObject ||
+  if (!m_lastGestureScrollOverFrameViewBase || !layoutObject ||
       !layoutObject->isLayoutPart())
     return WebInputEventResult::NotHandled;
 
   FrameViewBase* frameViewBase = toLayoutPart(layoutObject)->frameViewBase();
 
   if (!frameViewBase || !frameViewBase->isFrameView())
     return WebInputEventResult::NotHandled;
 
   return toFrameView(frameViewBase)
       ->frame()
@@ skipping 32 matching lines @@
 
     FrameView* view = m_frame->view();
     LayoutPoint viewPoint = view->rootFrameToContents(
         flooredIntPoint(gestureEvent.positionInRootFrame()));
     HitTestRequest request(HitTestRequest::ReadOnly);
     HitTestResult result(request, viewPoint);
     document->layoutViewItem().hitTest(result);
 
     eventTarget = result.innerNode();
 
-    m_lastGestureScrollOverWidget = result.isOverWidget();
+    m_lastGestureScrollOverFrameViewBase = result.isOverFrameViewBase();
     m_scrollGestureHandlingNode = eventTarget;
     m_previousGestureScrolledElement = nullptr;
     m_deltaConsumedForScrollSequence = false;
 
     if (!scrollbar)
       scrollbar = result.scrollbar();
   }
 
   if (scrollbar) {
     bool shouldUpdateCapture = false;
@@ skipping 134 matching lines @@
     if (scrollbar->gestureEvent(targetedEvent.event(), &shouldUpdateCapture)) {
       if (shouldUpdateCapture)
         m_scrollbarHandlingScrollGesture = scrollbar;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace blink