Switch AutoscrollController to use animation system instead of timer

Source/core/page/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 39 matching lines @@
 #include "core/events/ThreadLocalEventNames.h"
 #include "core/events/TouchEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/fetch/ImageResource.h"
 #include "core/html/HTMLDialogElement.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLFrameSetElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
+#include "core/page/AutoscrollController.h"
 #include "core/page/BackForwardClient.h"
 #include "core/page/Chrome.h"
 #include "core/page/DragController.h"
 #include "core/page/DragState.h"
 #include "core/page/EditorClient.h"
 #include "core/page/FocusController.h"
 #include "core/frame/Frame.h"
 #include "core/page/FrameTree.h"
 #include "core/frame/FrameView.h"
 #include "core/page/MouseEventWithHitTestResults.h"
@@ skipping 625 matching lines @@
             return false;
 
         renderer = parent->renderer();
         if (!renderer || !renderer->isListBox())
             return false;
     }
 
     m_mouseDownMayStartDrag = false;
 
     if (m_mouseDownMayStartAutoscroll && !panScrollInProgress()) {
-        if (Page* page = m_frame->page()) {
-            page->startAutoscrollForSelection(renderer);
+        if (AutoscrollController* controller = autoscrollController()) {
+            controller->startAutoscrollForSelection(renderer);
             m_mouseDownMayStartAutoscroll = false;
         }
     }
 
     if (m_selectionInitiationState != ExtendedSelection) {
         HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowShadowContent);
         HitTestResult result(m_mouseDownPos);
         m_frame->document()->renderView()->hitTest(request, result);
 
         updateSelectionForMouseDrag(result);
@@ skipping 76 matching lines @@
 
     if (m_frame->selection().granularity() != CharacterGranularity)
         newSelection.expandUsingGranularity(m_frame->selection().granularity());
 
     m_frame->selection().setNonDirectionalSelectionIfNeeded(newSelection, m_frame->selection().granularity(),
         FrameSelection::AdjustEndpointsAtBidiBoundary);
 }
 
 bool EventHandler::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event)
 {
-    Page* page = m_frame->page();
-    if (page && page->autoscrollInProgress())
-        stopAutoscrollTimer();
+    AutoscrollController* controller = autoscrollController();
+    if (controller && controller->autoscrollInProgress())
+        stopAutoscroll();
 
     // Used to prevent mouseMoveEvent from initiating a drag before
     // the mouse is pressed again.
     m_mousePressed = false;
     m_capturesDragging = false;
     m_mouseDownMayStartDrag = false;
     m_mouseDownMayStartSelect = false;
     m_mouseDownMayStartAutoscroll = false;
     m_mouseDownWasInSubframe = false;
 
@@ skipping 31 matching lines @@
 
     return handled;
 }
 
 #if OS(WIN)
 
 void EventHandler::startPanScrolling(RenderObject* renderer)
 {
     if (!renderer->isBox())
         return;
-    Page* page = m_frame->page();
-    if (!page)
+    AutoscrollController* controller = autoscrollController();
+    if (!controller)
         return;
-    page->startPanScrolling(toRenderBox(renderer), lastKnownMousePosition());
+    controller->startPanScrolling(toRenderBox(renderer), lastKnownMousePosition());
     invalidateClick();
 }
 
 #endif // OS(WIN)
 
+AutoscrollController* EventHandler::autoscrollController() const
+{
+    Page* page = m_frame->page();
+    if (!page)
+        return 0;
+    return &page->autoscrollController();

[esprehn, 2013/11/01 19:37:37]

We usually write:

if (Page* page = m_frame->page())
  return &page->autoscrollController();
return 0;

+}
+
 bool EventHandler::panScrollInProgress() const
 {
-    Page* page = m_frame->page();
-    return page && page->panScrollInProgress();
+    return autoscrollController() && autoscrollController()->panScrollInProgress();
 }
 
 HitTestResult EventHandler::hitTestResultAtPoint(const LayoutPoint& point, HitTestRequest::HitTestRequestType hitType, const LayoutSize& padding)
 {
     // We always send hitTestResultAtPoint to the main frame if we have one,
     // otherwise we might hit areas that are obscured by higher frames.
     if (Page* page = m_frame->page()) {
         Frame* mainFrame = page->mainFrame();
         if (m_frame != mainFrame) {
             FrameView* frameView = m_frame->view();
@@ skipping 21 matching lines @@
     m_frame->contentRenderer()->hitTest(request, result);
     if (!request.readOnly())
         m_frame->document()->updateHoverActiveState(request, result.innerElement());
 
     if (request.disallowsShadowContent())
         result.setToNodesInDocumentTreeScope();
 
     return result;
 }
 
-void EventHandler::stopAutoscrollTimer()
+void EventHandler::stopAutoscroll()
 {
-    Page* page = m_frame->page();
-    if (!page)
-        return;
-    page->stopAutoscrollTimer();
+    if (AutoscrollController* controller = autoscrollController())
+        controller->stopAutoscroll();
 }
 
 Node* EventHandler::mousePressNode() const
 {
     return m_mousePressNode.get();
 }
 
 bool EventHandler::scrollOverflow(ScrollDirection direction, ScrollGranularity granularity, Node* startingNode)
 {
     Node* node = startingNode;
@@ skipping 420 matching lines @@
         m_capturesDragging = subframe->eventHandler().capturesDragging();
         if (m_mousePressed && m_capturesDragging) {
             m_capturingMouseEventsNode = mev.targetNode();
             m_eventHandlerWillResetCapturingMouseEventsNode = true;
         }
         invalidateClick();
         return true;
     }
 
 #if OS(WIN)
-    // We store whether pan scrolling is in progress before calling stopAutoscrollTimer()
+    // We store whether pan scrolling is in progress before calling stopAutoscroll()
     // because it will set m_autoscrollType to NoAutoscroll on return.
     bool isPanScrollInProgress = panScrollInProgress();
-    stopAutoscrollTimer();
+    stopAutoscroll();
     if (isPanScrollInProgress) {
         // We invalidate the click when exiting pan scrolling so that we don't inadvertently navigate
         // away from the current page (e.g. the click was on a hyperlink). See <rdar://problem/6095023>.
         invalidateClick();
         return true;
     }
 #endif
 
     m_clickCount = mouseEvent.clickCount();
     m_clickNode = mev.targetNode();
@@ skipping 274 matching lines @@
 
     OwnPtr<UserGestureIndicator> gestureIndicator;
 
     if (m_frame->tree().top()->eventHandler().m_lastMouseDownUserGestureToken)
         gestureIndicator = adoptPtr(new UserGestureIndicator(m_frame->tree().top()->eventHandler().m_lastMouseDownUserGestureToken.release()));
     else
         gestureIndicator = adoptPtr(new UserGestureIndicator(DefinitelyProcessingUserGesture));
 
 #if OS(WIN)
     if (Page* page = m_frame->page())
-        page->handleMouseReleaseForPanScrolling(m_frame, mouseEvent);
+        page->autoscrollController().handleMouseReleaseForPanScrolling(m_frame, mouseEvent);
 #endif
 
     m_mousePressed = false;
     setLastKnownMousePosition(mouseEvent);
 
     if (m_svgPan) {
         m_svgPan = false;
         toSVGDocument(m_frame->document())->updatePan(m_frame->view()->windowToContents(m_lastKnownMousePosition));
         return true;
     }
@@ skipping 150 matching lines @@
         return false;
 
     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::DisallowShadowContent);
     MouseEventWithHitTestResults mev = prepareMouseEvent(request, event);
 
     // Drag events should never go to text nodes (following IE, and proper mouseover/out dispatch)
     RefPtr<Node> newTarget = mev.targetNode();
     if (newTarget && newTarget->isTextNode())
         newTarget = EventPath::parent(newTarget.get());
 
-    if (Page* page = m_frame->page())
-        page->updateDragAndDrop(newTarget.get(), event.position(), event.timestamp());
+    if (AutoscrollController* controller = autoscrollController())
+        controller->updateDragAndDrop(newTarget.get(), event.position(), event.timestamp());
 
     if (m_dragTarget != newTarget) {
         // FIXME: this ordering was explicitly chosen to match WinIE. However,
         // it is sometimes incorrect when dragging within subframes, as seen with
         // LayoutTests/fast/events/drag-in-frames.html.
         //
         // Moreover, this ordering conforms to section 7.9.4 of the HTML 5 spec. <http://dev.w3.org/html5/spec/Overview.html#drag-and-drop-processing-model>.
         Frame* targetFrame;
         if (targetIsFrame(newTarget.get(), targetFrame)) {
             if (targetFrame)
@@ skipping 64 matching lines @@
         if (targetFrame)
             preventedDefault = targetFrame->eventHandler().performDragAndDrop(event, clipboard);
     } else if (m_dragTarget.get())
         preventedDefault = dispatchDragEvent(EventTypeNames::drop, m_dragTarget.get(), event, clipboard);
     clearDragState();
     return preventedDefault;
 }
 
 void EventHandler::clearDragState()
 {
-    stopAutoscrollTimer();
+    stopAutoscroll();
     m_dragTarget = 0;
     m_capturingMouseEventsNode = 0;
     m_shouldOnlyFireDragOverEvent = false;
 }
 
 void EventHandler::setCapturingMouseEventsNode(PassRefPtr<Node> n)
 {
     m_capturingMouseEventsNode = n;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
 }
@@ skipping 1088 matching lines @@
             return false;
     }
 
     if (initialKeyEvent.windowsVirtualKeyCode() == VK_CAPITAL)
         capsLockStateMayHaveChanged();
 
 #if OS(WIN)
     if (panScrollInProgress()) {
         // If a key is pressed while the panScroll is in progress then we want to stop
         if (initialKeyEvent.type() == PlatformEvent::KeyDown || initialKeyEvent.type() == PlatformEvent::RawKeyDown)
-            stopAutoscrollTimer();
+            stopAutoscroll();
 
         // If we were in panscroll mode, we swallow the key event
         return true;
     }
 #endif
 
     // Check for cases where we are too early for events -- possible unmatched key up
     // from pressing return in the location bar.
     RefPtr<Node> node = eventTargetNodeForDocument(m_frame->document());
     if (!node)
@@ skipping 838 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace WebCore