Non passive touch end or touch cancel listeners should not block scroll.

third_party/WebKit/Source/core/frame/EventHandlerRegistry.cpp

 // Copyright 2014 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/frame/EventHandlerRegistry.h"
 
 #include "core/events/EventListenerOptions.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 
 namespace blink {
 
 namespace {
 
-inline bool isTouchEventType(const AtomicString& eventType)
-{
-    return eventType == EventTypeNames::touchstart
-        || eventType == EventTypeNames::touchmove
-        || eventType == EventTypeNames::touchend
-        || eventType == EventTypeNames::touchcancel;
-}
-
 inline bool isPointerEventType(const AtomicString& eventType)
 {
     return eventType == EventTypeNames::gotpointercapture
         || eventType == EventTypeNames::lostpointercapture
         || eventType == EventTypeNames::pointercancel
         || eventType == EventTypeNames::pointerdown
         || eventType == EventTypeNames::pointerenter
         || eventType == EventTypeNames::pointerleave
         || eventType == EventTypeNames::pointermove
         || eventType == EventTypeNames::pointerout
@@ skipping 23 matching lines @@
 {
     checkConsistency();
 }
 
 bool EventHandlerRegistry::eventTypeToClass(const AtomicString& eventType, const EventListenerOptions& options, EventHandlerClass* result)
 {
     if (eventType == EventTypeNames::scroll) {
         *result = ScrollEvent;
     } else if (eventType == EventTypeNames::wheel || eventType == EventTypeNames::mousewheel) {
         *result = options.passive() ? WheelEventPassive : WheelEventBlocking;
-    } else if (isTouchEventType(eventType)) {
-        *result = options.passive() ? TouchEventPassive : TouchEventBlocking;
+    } else if (eventType == EventTypeNames::touchend || eventType == EventTypeNames::touchcancel) {
+        *result = options.passive() ? TouchEndOrCancelEventPassive : TouchEndOrCancelEventBlocking;
+    } else if (eventType == EventTypeNames::touchstart || eventType == EventTypeNames::touchmove) {
+        *result = options.passive() ? TouchStartOrMoveEventPassive : TouchStartOrMoveEventBlocking;
     } else if (isPointerEventType(eventType)) {
-        // The EventHandlerClass is TouchEventPassive since the pointer events
-        // never block scrolling and the compositor only needs to know
-        // about the touch listeners.
-        *result = TouchEventPassive;
+        // The EventHandlerClass is TouchStartOrMoveEventPassive since
+        // the pointer events never block scrolling and the compositor
+        // only needs to know about the touch listeners.
+        *result = TouchStartOrMoveEventPassive;
 #if ENABLE(ASSERT)
     } else if (eventType == EventTypeNames::load || eventType == EventTypeNames::mousemove || eventType == EventTypeNames::touchstart) {
         *result = EventsForTesting;
 #endif
     } else {
         return false;
     }
     return true;
 }
 
@@ skipping 119 matching lines @@
     for (size_t i = 0; i < EventHandlerClassCount; ++i) {
         EventHandlerClass handlerClass = static_cast<EventHandlerClass>(i);
         updateEventHandlerInternal(RemoveAll, handlerClass, &target);
     }
 }
 
 void EventHandlerRegistry::notifyHasHandlersChanged(EventHandlerClass handlerClass, bool hasActiveHandlers)
 {
     switch (handlerClass) {
     case ScrollEvent:
-        m_frameHost->chromeClient().setHaveScrollEventHandlers(hasActiveHandlers);
+        m_frameHost->chromeClient().setHasScrollEventHandlers(hasActiveHandlers);
         break;
     case WheelEventBlocking:
     case WheelEventPassive:
         m_frameHost->chromeClient().setEventListenerProperties(WebEventListenerClass::MouseWheel, webEventListenerProperties(hasEventHandlers(WheelEventBlocking), hasEventHandlers(WheelEventPassive)));
         break;
-    case TouchEventBlocking:
-    case TouchEventPassive:
-        m_frameHost->chromeClient().setEventListenerProperties(WebEventListenerClass::Touch, webEventListenerProperties(hasEventHandlers(TouchEventBlocking), hasEventHandlers(TouchEventPassive)));
+    case TouchStartOrMoveEventBlocking:
+    case TouchStartOrMoveEventPassive:
+        m_frameHost->chromeClient().setEventListenerProperties(WebEventListenerClass::TouchStartOrMove, webEventListenerProperties(hasEventHandlers(TouchStartOrMoveEventBlocking), hasEventHandlers(TouchStartOrMoveEventPassive)));
+        break;
+    case TouchEndOrCancelEventBlocking:
+    case TouchEndOrCancelEventPassive:
+        m_frameHost->chromeClient().setEventListenerProperties(WebEventListenerClass::TouchEndOrCancel, webEventListenerProperties(hasEventHandlers(TouchEndOrCancelEventBlocking), hasEventHandlers(TouchEndOrCancelEventPassive)));
         break;
 #if ENABLE(ASSERT)
     case EventsForTesting:
         break;
 #endif
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
 void EventHandlerRegistry::notifyDidAddOrRemoveEventHandlerTarget(EventHandlerClass handlerClass)
 {
     ScrollingCoordinator* scrollingCoordinator = m_frameHost->page().scrollingCoordinator();
-    if (scrollingCoordinator && handlerClass == TouchEventBlocking)
+    if (scrollingCoordinator && handlerClass == TouchStartOrMoveEventBlocking)
         scrollingCoordinator->touchEventTargetRectsDidChange();
 }
 
 DEFINE_TRACE(EventHandlerRegistry)
 {
     visitor->trace(m_frameHost);
     visitor->template registerWeakMembers<EventHandlerRegistry, &EventHandlerRegistry::clearWeakMembers>(this);
 }
 
 void EventHandlerRegistry::clearWeakMembers(Visitor* visitor)
@@ skipping 60 matching lines @@
                 ASSERT(window->frame());
                 ASSERT(window->frame()->host());
                 ASSERT(window->frame()->host() == m_frameHost);
             }
         }
     }
 #endif // ENABLE(ASSERT)
 }
 
 } // namespace blink