Add UMA metric for tracking root level listeners for blocking touch.

third_party/WebKit/Source/core/input/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 69 matching lines @@
 #include "core/page/DragState.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/page/scrolling/ScrollState.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ComputedStyle.h"
 #include "core/svg/SVGDocumentExtensions.h"
+#include "platform/Histogram.h"
 #include "platform/PlatformGestureEvent.h"
 #include "platform/PlatformKeyboardEvent.h"
 #include "platform/PlatformTouchEvent.h"
 #include "platform/PlatformWheelEvent.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/WindowsKeyboardCodes.h"
 #include "platform/geometry/FloatPoint.h"
 #include "platform/graphics/Image.h"
 #include "platform/heap/Handle.h"
@@ skipping 100 matching lines @@
         curBox = curBox->containingBlock();
     }
     // TODO(tdresser): this should sometimes be excluded, as part of crbug.com/410974.
     // We need to ensure that the scrollingElement is always part of
     // the scroll chain. In quirks mode, when the scrollingElement is
     // the body, some elements may use the documentElement as their
     // containingBlock, so we ensure the scrollingElement is added
     // here.
     scrollChain.push_front(DOMNodeIds::idForNode(frame.document()->scrollingElement()));
 }
 

[tdresser, 2016/04/19 20:49:58]

Could we factor all this logic out into a separate file? EventHandler is a bit
of a dumping ground.

[dtapuska, 2016/04/21 01:18:49]

I think this is all going to change when Navid lands his EventHandler changes. I
wanted to land this first before he re-organizes everything in change
https://codereview.chromium.org/1892653003/ so that we can integrate this into
51 easily. 

+// These offsets change indicies into the ListenerHistogram
+// enumeration. The addition of a series of offsets then
+// produces the resulting ListenerHistogram value.
+const size_t kTouchTargetHistogramRootScrollerOffset = 4;
+const size_t kTouchTargetHistogramScrollableDocumentOffset = 2;
+const size_t kTouchTargetHistogramHandledOffset = 1;
+
+enum TouchTargetAndDispatchResultTypeHistogram {

[tdresser, 2016/04/19 20:49:58]

I don't think we need "Histogram" in the type here.

[dtapuska, 2016/04/21 01:18:49]

Done.

+    NonRootScrollerNonScrollableNotHandled, // Non-root-scroller, non-scrollable document, not handled.
+    NonRootScrollerNonScrollableHandled, // Non-root-scroller, non-scrollable document, handled application.
+    NonRootScrollerScrollableDocumentNotHandled, // Non-root-scroller, scrollable document, not handled.
+    NonRootScrollerScrollableDocumentHandled, // Non-root-scroller, scrollable document, handled application.
+    RootScrollerNonScrollableNotHandled, // Root-scroller, non-scrollable document, not handled.
+    RootScrollerNonScrollableHandled, // Root-scroller, non-scrollable document, handled.
+    RootScrollerScrollableDocumentNotHandled, // Root-scroller, scrollable document, not handled.
+    RootScrollerScrollableDocumentHandled, // Root-scroller, scrollable document, handled.
+    ListenerHistogramMax,
+};
+
+TouchTargetAndDispatchResultTypeHistogram toTouchTargetHistogramValue(EventTarget* eventTarget, DispatchEventResult dispatchResult)
+{
+    int result = 0;
+    Document* document = nullptr;
+
+    if (const LocalDOMWindow* domWindow = eventTarget->toDOMWindow()) {
+        // Treat the window as a root scroller as well.
+        document = domWindow->document();
+        result += kTouchTargetHistogramRootScrollerOffset;
+    } else if (Node* node = eventTarget->toNode()) {
+        // Report if the target node is the document or body.
+        if (node->isDocumentNode() || static_cast<Node*>(node->document().documentElement()) == node || static_cast<Node*>(node->document().body()) == node) {
+            result += kTouchTargetHistogramRootScrollerOffset;
+        }
+        document = &node->document();
+    }
+
+    if (document) {
+        FrameView* view = document->view();
+        if (view && view->isScrollable())
+            result += kTouchTargetHistogramScrollableDocumentOffset;
+    }
+
+    if (dispatchResult != DispatchEventResult::NotCanceled)
+        result += kTouchTargetHistogramHandledOffset;
+    return static_cast<TouchTargetAndDispatchResultTypeHistogram>(result);
+}
+
 } // namespace
 
 using namespace HTMLNames;
 
 // The link drag hysteresis is much larger than the others because there
 // needs to be enough space to cancel the link press without starting a link drag,
 // and because dragging links is rare.
 static const int LinkDragHysteresis = 40;
 static const int ImageDragHysteresis = 5;
 static const int TextDragHysteresis = 3;
@@ skipping 64 matching lines @@
     , m_mousePositionIsUnknown(true)
     , m_mouseDownTimestamp(0)
     , m_touchPressed(false)
     , m_inPointerCanceledState(false)
     , m_scrollGestureHandlingNode(nullptr)
     , m_lastGestureScrollOverWidget(false)
     , m_longTapShouldInvokeContextMenu(false)
     , m_activeIntervalTimer(this, &EventHandler::activeIntervalTimerFired)
     , m_lastShowPressTimestamp(0)
     , m_deltaConsumedForScrollSequence(false)
+    , m_waitingForFirstTouchMove(false)
 {
 }
 
 EventHandler::~EventHandler()
 {
     ASSERT(!m_fakeMouseMoveEventTimer.isActive());
 }
 
 DEFINE_TRACE(EventHandler)
 {
@@ skipping 3466 matching lines @@
     using EventTargetSet = HeapHashSet<Member<EventTarget>>;
     // Set of targets involved in m_touches.
     EventTargetSet m_targets;
 };
 
 } // namespace
 
 WebInputEventResult EventHandler::dispatchTouchEvents(const PlatformTouchEvent& event,
     HeapVector<TouchInfo>& touchInfos, bool freshTouchEvents, bool allTouchReleased)
 {
+    bool touchStartOrFirstTouchMove = false;
+    if (event.type() == PlatformEvent::TouchStart) {
+        m_waitingForFirstTouchMove = true;
+        touchStartOrFirstTouchMove = true;
+    } else if (event.type() == PlatformEvent::TouchMove) {
+        touchStartOrFirstTouchMove = m_waitingForFirstTouchMove;
+        m_waitingForFirstTouchMove = false;
+    }
+
     // Build up the lists to use for the 'touches', 'targetTouches' and
     // 'changedTouches' attributes in the JS event. See
     // http://www.w3.org/TR/touch-events/#touchevent-interface for how these
     // lists fit together.
 
     // Holds the complete set of touches on the screen.
     TouchList* touches = TouchList::create();
 
     // A different view on the 'touches' list above, filtered and grouped by
     // event target. Used for the 'targetTouches' list in the JS event.
@@ skipping 66 matching lines @@
             continue;
 
         const AtomicString& eventName(touchEventNameForTouchPointState(static_cast<PlatformTouchPoint::TouchState>(state)));
         for (const auto& eventTarget : changedTouches[state].m_targets) {
             EventTarget* touchEventTarget = eventTarget;
             TouchEvent* touchEvent = TouchEvent::create(
                 touches, touchesByTarget.get(touchEventTarget), changedTouches[state].m_touches.get(),
                 eventName, touchEventTarget->toNode()->document().domWindow(),
                 event.getModifiers(), event.cancelable(), event.causesScrollingIfUncanceled(), event.timestamp());
 
-            eventResult = mergeEventResult(eventResult, toWebInputEventResult(touchEventTarget->dispatchEvent(touchEvent)));
+            DispatchEventResult domDispatchResult = touchEventTarget->dispatchEvent(touchEvent);
+
+            // Only report for top level documents with a single touch on
+            // touch-start or the first touch-move.
+            if (touchStartOrFirstTouchMove && touchInfos.size() == 1 && event.cancelable() && !m_frame->document()->ownerElement()) {
+                DEFINE_STATIC_LOCAL(EnumerationHistogram, rootDocumentListenerHistogram, ("Event.Touch.TargetAndDispatchResult", ListenerHistogramMax));
+                rootDocumentListenerHistogram.count(toTouchTargetHistogramValue(eventTarget, domDispatchResult));
+            }
+            eventResult = mergeEventResult(eventResult, toWebInputEventResult(domDispatchResult));
         }
     }
 
     return eventResult;
 }
 
 WebInputEventResult EventHandler::handleTouchEvent(const PlatformTouchEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleTouchEvent");
 
@@ skipping 271 matching lines @@
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink