Revert of Reduce hit test on ShowPress by moving event targeting to WebViewImpl

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 52 matching lines @@
 #include "core/inspector/InspectorController.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/ChromeClient.h"
 #include "core/page/DragController.h"
 #include "core/page/DragState.h"
 #include "core/page/EditorClient.h"
+#include "core/page/EventWithHitTestResults.h"
 #include "core/page/FocusController.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/page/SpatialNavigation.h"
 #include "core/page/TouchAdjustment.h"
 #include "core/rendering/HitTestRequest.h"
 #include "core/rendering/HitTestResult.h"
 #include "core/rendering/RenderFlowThread.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderTextControlSingleLine.h"
@@ skipping 1970 matching lines @@
         ScrollableArea* sa = *it;
         ScrollAnimator* animator = sa->existingScrollAnimator();
         if (animator)
             animator->cancelAnimations();
     }
     return false;
 }
 
 bool EventHandler::handleGestureEvent(const PlatformGestureEvent& gestureEvent)
 {
-    // Propagation to inner frames is handled below this function.
-    ASSERT(m_frame == m_frame->localFrameRoot());
-
-    // 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 (gestureEvent.isScrollEvent())
-        return handleGestureScrollEvent(gestureEvent);
-
-    // Hit test across all frames and do touch adjustment as necessary for the event type.
-    GestureEventWithHitTestResults targetedEvent = targetGestureEvent(gestureEvent);
-
-    return handleGestureEvent(targetedEvent);
-}
-
-bool EventHandler::handleGestureEvent(const GestureEventWithHitTestResults& targetedEvent)
-{
     TRACE_EVENT0("input", "EventHandler::handleGestureEvent");
 
     // Propagation to inner frames is handled below this function.
     ASSERT(m_frame == m_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(!targetedEvent.event().isScrollEvent());
+    // Scrolling-related gesture events invoke EventHandler recursively for each frame down
+    // the chain, doing a single-frame hit-test per frame. This matches handleWheelEvent.
+    // Perhaps we could simplify things by rewriting scroll handling to work inner frame
+    // out, and then unify with other gesture events.
+    if (gestureEvent.isScrollEvent())
+        return handleGestureScrollEvent(gestureEvent);
+
+    // Non-scrolling related gesture events instead do a single cross-frame hit-test and
+    // jump directly to the inner most frame. This matches handleMousePressEvent etc.
+
+    // Hit test across all frames and do touch adjustment as necessary for the event type.
+    GestureEventWithHitTestResults targetedEvent = targetGestureEvent(gestureEvent);
 
     // Route to the correct frame.
     if (LocalFrame* innerFrame = targetedEvent.hitTestResult().innerNodeFrame())
         return innerFrame->eventHandler().handleGestureEventInFrame(targetedEvent);
 
     // No hit test result, handle in root instance. Perhaps we should just return false instead?
     return handleGestureEventInFrame(targetedEvent);
 }
 
 bool EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)
@@ skipping 35 matching lines @@
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
     return false;
 }
 
 bool EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureEvent)
 {
-    TRACE_EVENT0("input", "EventHandler::handleGestureScrollEvent");
-
     RefPtrWillBeRawPtr<Node> eventTarget = nullptr;
     RefPtr<Scrollbar> scrollbar;
     if (gestureEvent.type() != PlatformEvent::GestureScrollBegin) {
         scrollbar = m_scrollbarHandlingScrollGesture.get();
         eventTarget = m_scrollGestureHandlingNode.get();
     }
 
     if (!eventTarget) {
         Document* document = m_frame->document();
         if (!document->renderView())
@@ skipping 400 matching lines @@
     IntRect touchRect(touchCenter - touchRadius, touchRadius + touchRadius);
     WillBeHeapVector<RefPtrWillBeMember<Node>, 11> nodes;
     copyToVector(result.rectBasedTestResult(), nodes);
 
     // FIXME: the explicit Vector conversion copies into a temporary and is wasteful.
     return findBestZoomableArea(targetNode, targetArea, touchCenter, touchRect, WillBeHeapVector<RefPtrWillBeMember<Node> >(nodes));
 }
 
 GestureEventWithHitTestResults EventHandler::targetGestureEvent(const PlatformGestureEvent& gestureEvent, bool readOnly)
 {
-    TRACE_EVENT0("input", "EventHandler::targetGestureEvent");
-
     ASSERT(m_frame == m_frame->localFrameRoot());
     // Scrolling events get hit tested per frame (like wheel events do).
     ASSERT(!gestureEvent.isScrollEvent());
 
     HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
     double activeInterval = 0;
     bool shouldKeepActiveForMinInterval = false;
     if (readOnly) {
         hitType |= HitTestRequest::ReadOnly;
     } else if (gestureEvent.type() == PlatformEvent::GestureTap) {
@@ skipping 1302 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink