Removed main-thread one dimensional scrolling paths.

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
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 582 matching lines @@
 
     return result;
 }
 
 void EventHandler::stopAutoscroll()
 {
     if (AutoscrollController* controller = autoscrollController())
         controller->stopAutoscroll();
 }
 
-ScrollResultOneDimensional EventHandler::scroll(ScrollDirection direction, ScrollGranularity granularity, Node* startNode, Node** stopNode, float delta)
+ScrollResult EventHandler::physicalScroll(ScrollGranularity granularity, const FloatSize& delta, Node* startNode, Node** stopNode)
 {
-    if (!delta)
-        return ScrollResultOneDimensional(false);
+    if (delta.isZero())
+        return ScrollResult();
 
     Node* node = startNode;
+    ASSERT(node && node->layoutObject());
+
+    m_frame->document()->updateLayoutIgnorePendingStylesheets();
+
+    ScrollResult result;
+
+    LayoutBox* curBox = node->layoutObject()->enclosingBox();
+    while (curBox && !curBox->isLayoutView()) {
+        // If we're at the stopNode, we should try to scroll it but we shouldn't
+        // chain past it.
+        bool shouldStopChaining =
+            stopNode && *stopNode && curBox->node() == *stopNode;
+        result = curBox->scroll(granularity, delta);
+
+        if (result.didScroll() && stopNode)
+            *stopNode = curBox->node();
+
+        if (result.didScroll() || shouldStopChaining) {
+            setFrameWasScrolledByUser();
+            if (!result.didScroll()) {
+                // TODO(bokan): We should probably add a "shouldPropagate" bit
+                // on the result rather than lying to the caller.
+                result.didScrollX = true;
+                result.didScrollY = true;
+            }
+            return result;
+        }
+
+        curBox = curBox->containingBlock();
+    }
+
+    return result;
+}
+
+bool EventHandler::logicalScroll(ScrollDirection direction, ScrollGranularity granularity, Node* startNode)
+{
+    Node* node = startNode;
 
     if (!node)
         node = m_frame->document()->focusedElement();
 
     if (!node)
         node = m_mousePressNode.get();
 
     if (!node || !node->layoutObject())
-        return ScrollResultOneDimensional(false, delta);
+        return false;
 
     m_frame->document()->updateLayoutIgnorePendingStylesheets();
 
     LayoutBox* curBox = node->layoutObject()->enclosingBox();
     while (curBox && !curBox->isLayoutView()) {
         ScrollDirectionPhysical physicalDirection = toPhysicalDirection(
             direction, curBox->isHorizontalWritingMode(), curBox->style()->isFlippedBlocksWritingMode());
 
-        // If we're at the stopNode, we should try to scroll it but we shouldn't bubble past it
-        bool shouldStopBubbling = stopNode && *stopNode && curBox->node() == *stopNode;
-        ScrollResultOneDimensional result = curBox->scroll(physicalDirection, granularity, delta);
+        ScrollResult result = curBox->scroll(granularity, toScrollDelta(physicalDirection, 1));
 
-        if (result.didScroll && stopNode)
-            *stopNode = curBox->node();
-
-        if (result.didScroll || shouldStopBubbling) {
+        if (result.didScroll()) {
             setFrameWasScrolledByUser();
-            result.didScroll = true;
-            return result;
+            return true;
         }
 
         curBox = curBox->containingBlock();
     }
 
-    return ScrollResultOneDimensional(false, delta);
+    return false;
 }
 
 void EventHandler::customizedScroll(const Node& startNode, ScrollState& scrollState)
 {
     if (scrollState.fullyConsumed())
         return;
 
     if (scrollState.deltaX() || scrollState.deltaY())
         m_frame->document()->updateLayoutIgnorePendingStylesheets();
 
     if (m_currentScrollChain.empty())
         recomputeScrollChain(*m_frame, startNode, m_currentScrollChain);
     scrollState.setScrollChain(m_currentScrollChain);
 
     scrollState.distributeToScrollChainDescendant();
 }
 
+// TODO(bokan): This should be merged with logicalScroll assuming
+// defaultSpaceEventHandler's chaining scroll can be done crossing frames.
 bool EventHandler::bubblingScroll(ScrollDirection direction, ScrollGranularity granularity, Node* startingNode)
 {
     // The layout needs to be up to date to determine if we can scroll. We may be
     // here because of an onLoad event, in which case the final layout hasn't been performed yet.
     m_frame->document()->updateLayoutIgnorePendingStylesheets();
     // FIXME: enable scroll customization in this case. See crbug.com/410974.
-    if (scroll(direction, granularity, startingNode).didScroll)
+    if (logicalScroll(direction, granularity, startingNode))
         return true;
     LocalFrame* frame = m_frame;
     FrameView* view = frame->view();
     if (view) {
         ScrollDirectionPhysical physicalDirection =
             toPhysicalDirection(direction, view->isVerticalDocument(), view->isFlippedDocument());
-        if (view->scrollableArea()->userScroll(physicalDirection, granularity).didScroll) {
+        if (view->scrollableArea()->userScroll(granularity, toScrollDelta(physicalDirection, 1)).didScroll()) {
             setFrameWasScrolledByUser();
             return true;
         }
     }
 
     Frame* parentFrame = frame->tree().parent();
     if (!parentFrame || !parentFrame->isLocalFrame())
         return false;
     // FIXME: Broken for OOPI.
     return toLocalFrame(parentFrame)->eventHandler().bubblingScroll(direction, granularity, m_frame->deprecatedLocalOwner());
@@ skipping 1061 matching lines @@
 
     // If the event is a "PageWheelEvent" we should disregard the delta and
     // scroll by *one* page length per event.
     if (event.granularity() == ScrollByPageWheelEvent) {
         if (deltaX)
             deltaX = deltaX > 0 ? 1 : -1;
         if (deltaY)
             deltaY = deltaY > 0 ? 1 : -1;
     }
 
-    // Positive delta is up and left.
-    ScrollResultOneDimensional resultY = scrollableArea.userScroll(ScrollUp, granularity, deltaY);
-    ScrollResultOneDimensional resultX = scrollableArea.userScroll(ScrollLeft, granularity, deltaX);
-
-    ScrollResult result;
-    result.didScrollY = resultY.didScroll;
-    result.didScrollX = resultX.didScroll;
-    result.unusedScrollDeltaY = resultY.unusedScrollDelta;
-    result.unusedScrollDeltaX = resultX.unusedScrollDelta;
-    return result;
+    // On a wheel event, positive delta is meant to scroll up and left, which
+    // is the opposite of deltas in the scrolling system.
+    return scrollableArea.userScroll(granularity, FloatSize(-deltaX, -deltaY));
 }
 
 } // namespace
 
 WebInputEventResult EventHandler::handleWheelEvent(const PlatformWheelEvent& event)
 {
     Document* doc = m_frame->document();
 
     if (!doc->layoutView())
         return WebInputEventResult::NotHandled;
@@ skipping 66 matching lines @@
     if (!startNode || !wheelEvent)
         return;
 
     // When the wheelEvent do not scroll, we trigger zoom in/out instead.
     if (!wheelEvent->canScroll())
         return;
 
     ScrollGranularity granularity = wheelGranularityToScrollGranularity(wheelEvent);
     Node* node = nullptr;
 
-    // Break up into two scrolls if we need to.  Diagonal movement on
-    // a MacBook pro is an example of a 2-dimensional mouse wheel event (where both deltaX and deltaY can be set).
+    // Diagonal movement on a MacBook pro is an example of a 2-dimensional
+    // mouse wheel event (where both deltaX and deltaY can be set).
+    FloatSize delta;
+
+    if (wheelEvent->getRailsMode() != Event::RailsModeVertical)
+        delta.setWidth(wheelEvent->deltaX());
+
+    if (wheelEvent->getRailsMode() != Event::RailsModeHorizontal)
+        delta.setHeight(wheelEvent->deltaY());
 
     // FIXME: enable scroll customization in this case. See crbug.com/410974.
-    if (wheelEvent->getRailsMode() != Event::RailsModeVertical
-        && scroll(ScrollRightIgnoringWritingMode, granularity, startNode, &node, wheelEvent->deltaX()).didScroll)
-        wheelEvent->setDefaultHandled();
+    ScrollResult result = physicalScroll(granularity, delta, startNode, &node);
 
-    if (wheelEvent->getRailsMode() != Event::RailsModeHorizontal
-        && scroll(ScrollDownIgnoringWritingMode, granularity, startNode, &node, wheelEvent->deltaY()).didScroll)
+    if (result.didScroll())
         wheelEvent->setDefaultHandled();
 }
 
 WebInputEventResult EventHandler::handleGestureShowPress()
 {
     m_lastShowPressTimestamp = WTF::monotonicallyIncreasingTime();
 
     FrameView* view = m_frame->view();
     if (!view)
         return WebInputEventResult::NotHandled;
@@ skipping 472 matching lines @@
     if (unusedDelta != FloatSize()) {
         m_accumulatedRootOverscroll += unusedDelta;
         m_frame->chromeClient().didOverscroll(unusedDelta, m_accumulatedRootOverscroll, position, velocity);
     }
 }
 
 WebInputEventResult EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
 {
     ASSERT(gestureEvent.type() == PlatformEvent::GestureScrollUpdate);
 
+    // TODO(bokan): This delta is specific to the event which is positive up and
+    // to the left. Since we're passing it into a bunch of scrolling code below,
+    // it should probably be inverted here.
     FloatSize delta(gestureEvent.deltaX(), gestureEvent.deltaY());
     if (delta.isZero())
         return WebInputEventResult::NotHandled;
 
     ScrollGranularity granularity = gestureEvent.deltaUnits();
     Node* node = m_scrollGestureHandlingNode.get();
 
     // Scroll customization is only available for touch.
     bool handleScrollCustomization = RuntimeEnabledFeatures::scrollCustomizationEnabled() && gestureEvent.source() == PlatformGestureSourceTouchscreen;
     if (node) {
         LayoutObject* layoutObject = node->layoutObject();
         if (!layoutObject)
             return WebInputEventResult::NotHandled;
 
         RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
 
-        Node* stopNode = nullptr;
-
         // Try to send the event to the correct view.
         WebInputEventResult result = passScrollGestureEventToWidget(gestureEvent, layoutObject);
         if (result != WebInputEventResult::NotHandled) {
             if (gestureEvent.preventPropagation()
                 && !RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
                 // This is an optimization which doesn't apply with
                 // scroll customization enabled.
                 m_previousGestureScrolledNode = m_scrollGestureHandlingNode;
             }
             // FIXME: we should allow simultaneous scrolling of nested
@@ skipping 21 matching lines @@
                 // currently scrolling element responds.
                 ASSERT(m_previousGestureScrolledNode->isElementNode());
                 scrollState->setCurrentNativeScrollingElement(toElement(m_previousGestureScrolledNode.get()));
             }
             customizedScroll(*node, *scrollState);
             m_previousGestureScrolledNode = scrollState->currentNativeScrollingElement();
             m_deltaConsumedForScrollSequence = scrollState->deltaConsumedForScrollSequence();
             scrolled = scrollState->deltaX() != gestureEvent.deltaX()
                 || scrollState->deltaY() != gestureEvent.deltaY();
         } else {
+            Node* stopNode = nullptr;
             if (gestureEvent.preventPropagation())
                 stopNode = m_previousGestureScrolledNode.get();
 
-            // First try to scroll the closest scrollable LayoutBox ancestor of |node|.
-            ScrollResultOneDimensional result = scroll(ScrollLeftIgnoringWritingMode, granularity, node, &stopNode, delta.width());
-            bool horizontalScroll = result.didScroll;
-            if (!gestureEvent.preventPropagation())
-                stopNode = nullptr;
-            result = scroll(ScrollUpIgnoringWritingMode, granularity, node, &stopNode, delta.height());
-            bool verticalScroll = result.didScroll;
-            scrolled = horizontalScroll || verticalScroll;
+            // Scale by -1 because the delta is the GestureEvent delta (see TODO at top of function).
+            ScrollResult result = physicalScroll(granularity, delta.scaledBy(-1), node, &stopNode);
+
+            scrolled = result.didScroll();
 
             if (gestureEvent.preventPropagation())
                 m_previousGestureScrolledNode = stopNode;
 
-            resetOverscroll(horizontalScroll, verticalScroll);
+            resetOverscroll(result.didScrollX, result.didScrollY);
         }
         if (scrolled) {
             setFrameWasScrolledByUser();
             return WebInputEventResult::HandledSystem;
         }
     }
 
     if (handleScrollCustomization)
         return WebInputEventResult::NotHandled;
 
@@ skipping 957 matching lines @@
 void EventHandler::defaultSpaceEventHandler(KeyboardEvent* event)
 {
     ASSERT(event->type() == EventTypeNames::keypress);
 
     if (event->ctrlKey() || event->metaKey() || event->altKey())
         return;
 
     ScrollDirection direction = event->shiftKey() ? ScrollBlockDirectionBackward : ScrollBlockDirectionForward;
 
     // FIXME: enable scroll customization in this case. See crbug.com/410974.
-    if (scroll(direction, ScrollByPage).didScroll) {
+    if (logicalScroll(direction, ScrollByPage)) {
         event->setDefaultHandled();
         return;
     }
 
     FrameView* view = m_frame->view();
     if (!view)
         return;
 
     ScrollDirectionPhysical physicalDirection =
         toPhysicalDirection(direction, view->isVerticalDocument(), view->isFlippedDocument());
 
-    if (view->scrollableArea()->userScroll(physicalDirection, ScrollByPage).didScroll)
+    if (view->scrollableArea()->userScroll(ScrollByPage, toScrollDelta(physicalDirection, 1)).didScroll())
         event->setDefaultHandled();
 }
 
 void EventHandler::defaultBackspaceEventHandler(KeyboardEvent* event)
 {
     ASSERT(event->type() == EventTypeNames::keydown);
 
     if (event->ctrlKey() || event->metaKey() || event->altKey())
         return;
 
@@ skipping 538 matching lines @@
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink