Add UseCounter for setPointerCapture outside dispatch

third_party/WebKit/Source/core/input/PointerEventManager.cpp

 // Copyright 2016 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/input/PointerEventManager.h"
 
 #include "core/dom/DocumentUserGestureToken.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/events/MouseEvent.h"
@@ skipping 48 matching lines @@
 void PointerEventManager::clear() {
   for (auto& entry : m_preventMouseEventForPointerType)
     entry = false;
   m_touchEventManager->clear();
   m_inCanceledStateForPointerTypeTouch = false;
   m_pointerEventFactory.clear();
   m_touchIdsForCanceledPointerdowns.clear();
   m_nodeUnderPointer.clear();
   m_pointerCaptureTarget.clear();
   m_pendingPointerCaptureTarget.clear();
+  m_dispatchingPointerId = 0;
 }
 
 DEFINE_TRACE(PointerEventManager) {
   visitor->trace(m_frame);
   visitor->trace(m_nodeUnderPointer);
   visitor->trace(m_pointerCaptureTarget);
   visitor->trace(m_pendingPointerCaptureTarget);
   visitor->trace(m_touchEventManager);
   visitor->trace(m_mouseEventManager);
 }
@@ skipping 57 matching lines @@
 
 WebInputEventResult PointerEventManager::dispatchPointerEvent(
     EventTarget* target,
     PointerEvent* pointerEvent,
     bool checkForListener) {
   if (!target)
     return WebInputEventResult::NotHandled;
 
   // Set whether node under pointer has received pointerover or not.
   const int pointerId = pointerEvent->pointerId();
+
   const AtomicString& eventType = pointerEvent->type();
   if ((eventType == EventTypeNames::pointerout ||
        eventType == EventTypeNames::pointerover) &&
       m_nodeUnderPointer.contains(pointerId)) {
     EventTarget* targetUnderPointer = m_nodeUnderPointer.get(pointerId).target;
     if (targetUnderPointer == target) {
       m_nodeUnderPointer.set(
           pointerId,
           EventTargetAttributes(targetUnderPointer,
                                 eventType == EventTypeNames::pointerover));
     }
   }
 
   if (!RuntimeEnabledFeatures::pointerEventEnabled())
     return WebInputEventResult::NotHandled;
   if (!checkForListener || target->hasEventListeners(eventType)) {
-    UseCounter::count(m_frame->document(), UseCounter::PointerEventDispatch);
+    UseCounter::count(m_frame, UseCounter::PointerEventDispatch);
     if (eventType == EventTypeNames::pointerdown)
-      UseCounter::count(m_frame->document(),
-                        UseCounter::PointerEventDispatchPointerDown);
+      UseCounter::count(m_frame, UseCounter::PointerEventDispatchPointerDown);
 
+    DCHECK(!m_dispatchingPointerId);
+    m_dispatchingPointerId = pointerId;

[dtapuska, 2017/01/16 21:07:41]

You able to use an AutoReset here?

[Rick Byers, 2017/01/20 22:37:22]

Done.

     DispatchEventResult dispatchResult = target->dispatchEvent(pointerEvent);
+    m_dispatchingPointerId = 0;
+
     return EventHandlingUtil::toWebInputEventResult(dispatchResult);
   }
   return WebInputEventResult::NotHandled;
 }
 
 EventTarget* PointerEventManager::getEffectiveTargetForPointerEvent(
     EventTarget* target,
     int pointerId) {
   if (EventTarget* capturingTarget = getCapturingNode(pointerId))
     return capturingTarget;
@@ skipping 438 matching lines @@
   }
 }
 
 void PointerEventManager::elementRemoved(EventTarget* target) {
   removeTargetFromPointerCapturingMapping(m_pendingPointerCaptureTarget,
                                           target);
 }
 
 void PointerEventManager::setPointerCapture(int pointerId,
                                             EventTarget* target) {
-  UseCounter::count(m_frame->document(), UseCounter::PointerEventSetCapture);
-  if (m_pointerEventFactory.isActiveButtonsState(pointerId))
+  UseCounter::count(m_frame, UseCounter::PointerEventSetCapture);
+  if (m_pointerEventFactory.isActiveButtonsState(pointerId)) {
+    if (pointerId != m_dispatchingPointerId) {
+      UseCounter::count(m_frame,
+                        UseCounter::PointerEventSetCaptureOutsideDispatch);

[Navid Zolghadr, 2017/01/16 21:15:01]

There is one more place (as of a "temporary" hack) that we fire pointerevents:

https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/dom/Node....

This will mis-count the ones that are coming from the handler of those events.

[Rick Byers, 2017/01/20 22:37:22]

Whoa, that looks potentially bad - commented on the bug.  I don't see an easy
way to handle that weird case, so I think the right answer is just to depend on
the fix for that bug.  In those cases pointer capture is generally going to be
broken anyway because isActiveButtonsState above will return false since
PointerEventManager never saw the pointerdown event.  Even if I did get the
metric hacked into those cases, it'll still be an innacurate measure of the risk
due to setPointerCapture itself failing in some of those cases when it should be
succeeding.

So I suggest we just proceed with this code as-is with the understanding that
the metric may be off until crbug.com/665924 is fixed.  My hunch is that it
won't be off by much (since setPointerCapture is probably rare in
Flash/pointerlock/etc cases) - but I guess we'll find out...

+    }
     m_pendingPointerCaptureTarget.set(pointerId, target);
+  }
 }
 
 void PointerEventManager::releasePointerCapture(int pointerId,
                                                 EventTarget* target) {
   // Only the element that is going to get the next pointer event can release
   // the capture. Note that this might be different from
   // |m_pointercaptureTarget|. |m_pointercaptureTarget| holds the element
   // that had the capture until now and has been receiving the pointerevents
   // but |m_pendingPointerCaptureTarget| indicated the element that gets the
   // very next pointer event. They will be the same if there was no change in
@@ skipping 53 matching lines @@
     if (firstId > uniqueTouchEventId)
       return false;
     m_touchIdsForCanceledPointerdowns.takeFirst();
     if (firstId == uniqueTouchEventId)
       return true;
   }
   return false;
 }
 
 }  // namespace blink