Bookkeep the pointer event listeners added to page

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/events/EventUtil.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
@@ skipping 38 matching lines @@
     *result = options.passive() ? kWheelEventPassive : kWheelEventBlocking;
   } else if (event_type == EventTypeNames::touchend ||
              event_type == EventTypeNames::touchcancel) {
     *result = options.passive() ? kTouchEndOrCancelEventPassive
                                 : kTouchEndOrCancelEventBlocking;
   } else if (event_type == EventTypeNames::touchstart ||
              event_type == EventTypeNames::touchmove) {
     *result = options.passive() ? kTouchStartOrMoveEventPassive
                                 : kTouchStartOrMoveEventBlocking;
   } else if (EventUtil::IsPointerEventType(event_type)) {
-    // The EventHandlerClass is TouchStartOrMoveEventPassive since
-    // the pointer events never block scrolling and the compositor
+    // The pointer events never block scrolling and the compositor
     // only needs to know about the touch listeners.
-    *result = kTouchStartOrMoveEventPassive;
+    *result = kPointerEvent;
 #if DCHECK_IS_ON()
   } else if (event_type == EventTypeNames::load ||
              event_type == EventTypeNames::mousemove ||
              event_type == EventTypeNames::touchstart) {
     *result = kEventsForTesting;
 #endif
   } else {
     return false;
   }
   return true;
@@ skipping 32 matching lines @@
     } else {
       if (!targets->erase(target)) {
         // Just decremented refcount, no real update.
         return false;
       }
     }
   }
   return true;
 }
 
-void EventHandlerRegistry::UpdateEventHandlerInternal(
+bool EventHandlerRegistry::UpdateEventHandlerInternal(
     ChangeOperation op,
     EventHandlerClass handler_class,
     EventTarget* target) {
   bool had_handlers = targets_[handler_class].size();
   bool target_set_changed =
       UpdateEventHandlerTargets(op, handler_class, target);
   bool has_handlers = targets_[handler_class].size();
 
-  if (had_handlers != has_handlers) {
-    LocalFrame* frame = nullptr;
-    if (Node* node = target->ToNode()) {
-      frame = node->GetDocument().GetFrame();
-    } else if (LocalDOMWindow* dom_window = target->ToLocalDOMWindow()) {
-      frame = dom_window->GetFrame();
-    } else {
-      NOTREACHED() << "Unexpected target type for event handler.";
-    }
+  bool handlers_changed = had_handlers != has_handlers;
 
-    NotifyHasHandlersChanged(frame, handler_class, has_handlers);
+  if (op != kRemoveAll) {
+    if (handlers_changed)
+      NotifyHasHandlersChanged(target, handler_class, has_handlers);
+
+    if (target_set_changed)
+      NotifyDidAddOrRemoveEventHandlerTarget(handler_class);
   }
-
-  if (target_set_changed)
-    NotifyDidAddOrRemoveEventHandlerTarget(handler_class);
+  return handlers_changed;
 }
 
 void EventHandlerRegistry::UpdateEventHandlerOfType(
     ChangeOperation op,
     const AtomicString& event_type,
     const AddEventListenerOptions& options,
     EventTarget* target) {
   EventHandlerClass handler_class;
   if (!EventTypeToClass(event_type, options, &handler_class))
     return;
@@ skipping 44 matching lines @@
       DidAddEventHandler(target, handler_class);
     }
   }
 }
 
 void EventHandlerRegistry::DidMoveOutOfPage(EventTarget& target) {
   DidRemoveAllEventHandlers(target);
 }
 
 void EventHandlerRegistry::DidRemoveAllEventHandlers(EventTarget& target) {
+  bool handlers_changed[kEventHandlerClassCount];
+  bool target_set_changed[kEventHandlerClassCount];
+
   for (size_t i = 0; i < kEventHandlerClassCount; ++i) {
     EventHandlerClass handler_class = static_cast<EventHandlerClass>(i);
-    UpdateEventHandlerInternal(kRemoveAll, handler_class, &target);
+
+    EventTargetSet* targets = &targets_[handler_class];
+    target_set_changed[i] = targets->Contains(&target);
+
+    handlers_changed[i] =
+        UpdateEventHandlerInternal(kRemoveAll, handler_class, &target);
+  }
+
+  for (size_t i = 0; i < kEventHandlerClassCount; ++i) {
+    EventHandlerClass handler_class = static_cast<EventHandlerClass>(i);
+    if (handlers_changed[i]) {
+      bool has_handlers = targets_[handler_class].size();
+      NotifyHasHandlersChanged(&target, handler_class, has_handlers);
+    }
+    if (target_set_changed[i])
+      NotifyDidAddOrRemoveEventHandlerTarget(handler_class);
   }
 }
 
 void EventHandlerRegistry::NotifyHasHandlersChanged(
-    LocalFrame* frame,
+    EventTarget* target,
     EventHandlerClass handler_class,
     bool has_active_handlers) {
+  LocalFrame* frame = nullptr;
+  if (Node* node = target->ToNode()) {
+    frame = node->GetDocument().GetFrame();
+  } else if (LocalDOMWindow* dom_window = target->ToLocalDOMWindow()) {
+    frame = dom_window->GetFrame();
+  } else {
+    NOTREACHED() << "Unexpected target type for event handler.";
+  }
+
   switch (handler_class) {
     case kScrollEvent:
       page_->GetChromeClient().SetHasScrollEventHandlers(frame,
                                                          has_active_handlers);
       break;
     case kWheelEventBlocking:
     case kWheelEventPassive:
       page_->GetChromeClient().SetEventListenerProperties(
           frame, WebEventListenerClass::kMouseWheel,
           GetWebEventListenerProperties(HasEventHandlers(kWheelEventBlocking),
                                         HasEventHandlers(kWheelEventPassive)));
       break;
     case kTouchStartOrMoveEventBlocking:
     case kTouchStartOrMoveEventPassive:
+    case kPointerEvent:
       page_->GetChromeClient().SetEventListenerProperties(
           frame, WebEventListenerClass::kTouchStartOrMove,
           GetWebEventListenerProperties(
               HasEventHandlers(kTouchStartOrMoveEventBlocking),
-              HasEventHandlers(kTouchStartOrMoveEventPassive)));
+              HasEventHandlers(kTouchStartOrMoveEventPassive) ||
+                  HasEventHandlers(kPointerEvent)));
       break;
     case kTouchEndOrCancelEventBlocking:
     case kTouchEndOrCancelEventPassive:
       page_->GetChromeClient().SetEventListenerProperties(
           frame, WebEventListenerClass::kTouchEndOrCancel,
           GetWebEventListenerProperties(
               HasEventHandlers(kTouchEndOrCancelEventBlocking),
               HasEventHandlers(kTouchEndOrCancelEventPassive)));
       break;
 #if DCHECK_IS_ON()
@@ skipping 84 matching lines @@
       // its handlers properly.
       DCHECK(window->GetFrame());
       DCHECK(window->GetFrame()->GetPage());
       DCHECK(window->GetFrame()->GetPage() == page_);
     }
   }
 #endif  // DCHECK_IS_ON()
 }
 
 }  // namespace blink