Move EventHandler timers to per-frame task queues.

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 17 matching lines @@
 
 #include "core/input/EventHandler.h"
 
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/HTMLNames.h"
 #include "core/InputTypeNames.h"
 #include "core/clipboard/DataTransfer.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentUserGestureToken.h"
+#include "core/dom/TaskRunnerHelper.h"
 #include "core/dom/TouchList.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/SelectionController.h"
 #include "core/events/EventPath.h"
 #include "core/events/GestureEvent.h"
 #include "core/events/KeyboardEvent.h"
@@ skipping 105 matching lines @@
   const Cursor& cursor() const {
     ASSERT(m_isCursorChange);
     return m_cursor;
   }
 
  private:
   bool m_isCursorChange;
   Cursor m_cursor;
 };
 
-EventHandler::EventHandler(LocalFrame* frame)
+EventHandler::EventHandler(LocalFrame& frame)
     : m_frame(frame),
-      m_selectionController(SelectionController::create(*frame)),
-      m_hoverTimer(this, &EventHandler::hoverTimerFired),
-      m_cursorUpdateTimer(this, &EventHandler::cursorUpdateTimerFired),
+      m_selectionController(SelectionController::create(frame)),
+      m_hoverTimer(TaskRunnerHelper::get(TaskType::UserInteraction, &frame),
+                   this,
+                   &EventHandler::hoverTimerFired),
+      m_cursorUpdateTimer(TaskRunnerHelper::get(TaskType::Internal, &frame),
+                          this,
+                          &EventHandler::cursorUpdateTimerFired),
       m_eventHandlerWillResetCapturingMouseEventsNode(0),
       m_shouldOnlyFireDragOverEvent(false),
       m_scrollManager(new ScrollManager(frame)),
-      m_mouseEventManager(new MouseEventManager(frame, m_scrollManager)),
-      m_keyboardEventManager(new KeyboardEventManager(frame, m_scrollManager)),
+      m_mouseEventManager(new MouseEventManager(frame, *m_scrollManager)),
+      m_keyboardEventManager(new KeyboardEventManager(frame, *m_scrollManager)),
       m_pointerEventManager(
-          new PointerEventManager(frame, m_mouseEventManager)),
+          new PointerEventManager(frame, *m_mouseEventManager)),
       m_gestureManager(new GestureManager(frame,
-                                          m_scrollManager,
-                                          m_mouseEventManager,
-                                          m_pointerEventManager,
-                                          m_selectionController)),
-      m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired) {}
+                                          *m_scrollManager,
+                                          *m_mouseEventManager,
+                                          *m_pointerEventManager,
+                                          *m_selectionController)),
+      m_activeIntervalTimer(
+          TaskRunnerHelper::get(TaskType::UserInteraction, &frame),
+          this,
+          &EventHandler::activeIntervalTimerFired) {}
 
 DEFINE_TRACE(EventHandler) {
   visitor->trace(m_frame);
   visitor->trace(m_selectionController);
   visitor->trace(m_capturingMouseEventsNode);
   visitor->trace(m_lastMouseMoveEventSubframe);
   visitor->trace(m_lastScrollbarUnderMouse);
   visitor->trace(m_dragTarget);
   visitor->trace(m_frameSetBeingResized);
   visitor->trace(m_scrollManager);
@@ skipping 1470 matching lines @@
       hitTestResultForGestureEvent(gestureEvent, hitType);
   // Now apply hover/active state to the final target.
   HitTestRequest request(hitType | HitTestRequest::AllowChildFrameContent);
   if (!request.readOnly())
     updateGestureHoverActiveState(
         request, eventWithHitTestResults.hitTestResult().innerElement());
 
   if (shouldKeepActiveForMinInterval) {
     m_lastDeferredTapElement =
         eventWithHitTestResults.hitTestResult().innerElement();
+    // TODO(https://crbug.com/668758): Use a normal BeginFrame update for this.
     m_activeIntervalTimer.startOneShot(minimumActiveInterval - activeInterval,
                                        BLINK_FROM_HERE);
   }
 
   return eventWithHitTestResults;
 }
 
 GestureEventWithHitTestResults EventHandler::hitTestResultForGestureEvent(
     const PlatformGestureEvent& gestureEvent,
     HitTestRequest::HitTestRequestType hitType) {
@@ skipping 190 matching lines @@
       locationInRootFrame, globalPosition,
       WebPointerProperties::Button::NoButton, eventType, /* clickCount */ 0,
       PlatformEvent::NoModifiers, PlatformMouseEvent::RealOrIndistinguishable,
       WTF::monotonicallyIncreasingTime(),
       WebPointerProperties::PointerType::Mouse);
 
   return sendContextMenuEvent(mouseEvent, overrideTargetElement);
 }
 
 void EventHandler::scheduleHoverStateUpdate() {
+  // TODO(https://crbug.com/668758): Use a normal BeginFrame update for this.
   if (!m_hoverTimer.isActive())
     m_hoverTimer.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(m_frame == m_frame->localFrameRoot());
 
+  // TODO(https://crbug.com/668758): Use a normal BeginFrame update for this.
   if (!m_cursorUpdateTimer.isActive())
     m_cursorUpdateTimer.startOneShot(cursorUpdateInterval, BLINK_FROM_HERE);
 }
 
 bool EventHandler::cursorUpdatePending() {
   return m_cursorUpdateTimer.isActive();
 }
 
 void EventHandler::dispatchFakeMouseMoveEventSoon() {
   m_mouseEventManager->dispatchFakeMouseMoveEventSoon();
 }
 
 void EventHandler::dispatchFakeMouseMoveEventSoonInQuad(const FloatQuad& quad) {
   m_mouseEventManager->dispatchFakeMouseMoveEventSoonInQuad(quad);
 }
 
 void EventHandler::setResizingFrameSet(HTMLFrameSetElement* frameSet) {
   m_frameSetBeingResized = frameSet;
 }
 
 void EventHandler::resizeScrollableAreaDestroyed() {
   m_scrollManager->clearResizeScrollableArea(true);
 }
 
 void EventHandler::hoverTimerFired(TimerBase*) {
   TRACE_EVENT0("input", "EventHandler::hoverTimerFired");
-  m_hoverTimer.stop();
 
   ASSERT(m_frame);
   ASSERT(m_frame->document());
 
   if (LayoutViewItem layoutItem = m_frame->contentLayoutItem()) {
     if (FrameView* view = m_frame->view()) {
       HitTestRequest request(HitTestRequest::Move);
       HitTestResult result(request,
                            view->rootFrameToContents(
                                m_mouseEventManager->lastKnownMousePosition()));
       layoutItem.hitTest(result);
       m_frame->document()->updateHoverActiveState(
           request, result.innerElement(), result.scrollbar());
     }
   }
 }
 
 void EventHandler::activeIntervalTimerFired(TimerBase*) {
   TRACE_EVENT0("input", "EventHandler::activeIntervalTimerFired");
-  m_activeIntervalTimer.stop();
 
   if (m_frame && m_frame->document() && m_lastDeferredTapElement) {
     // FIXME: Enable condition when http://crbug.com/226842 lands
     // m_lastDeferredTapElement.get() == m_frame->document()->activeElement()
     HitTestRequest request(HitTestRequest::TouchEvent |
                            HitTestRequest::Release);
     m_frame->document()->updateHoverActiveState(
         request, m_lastDeferredTapElement.get(), nullptr);
   }
   m_lastDeferredTapElement = nullptr;
@@ skipping 155 matching lines @@
 }
 
 FrameHost* EventHandler::frameHost() const {
   if (!m_frame->page())
     return nullptr;
 
   return &m_frame->page()->frameHost();
 }
 
 }  // namespace blink