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"
 #include "core/frame/FrameView.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/input/EventHandler.h"
 #include "core/input/EventHandlingUtil.h"
 #include "core/input/MouseEventManager.h"
 #include "core/input/TouchActionUtil.h"
 #include "core/layout/HitTestCanvasResult.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "public/platform/WebTouchEvent.h"
+#include "wtf/AutoReset.h"
 
 namespace blink {
 
 namespace {
 
 size_t toPointerTypeIndex(WebPointerProperties::PointerType t) {
   return static_cast<size_t>(t);
 }
 
 bool isInDocument(EventTarget* n) {
@@ skipping 27 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);
+    AutoReset<int> dispatchHolder(&m_dispatchingPointerId, pointerId);
     DispatchEventResult dispatchResult = target->dispatchEvent(pointerEvent);
     return EventHandlingUtil::toWebInputEventResult(dispatchResult);
   }
   return WebInputEventResult::NotHandled;
 }
 
 EventTarget* PointerEventManager::getEffectiveTargetForPointerEvent(
     EventTarget* target,
     int pointerId) {
   if (EventTarget* capturingTarget = getCapturingNode(pointerId))
@@ skipping 445 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);
+    }
     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