Move logic of recording main thread scrolling reasons from cc to blink::ScrollManager

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

Index: third_party/WebKit/Source/core/input/ScrollManager.cpp
diff --git a/third_party/WebKit/Source/core/input/ScrollManager.cpp b/third_party/WebKit/Source/core/input/ScrollManager.cpp
index 6d05fe059f6f8a7ddb8b1370866f43cd5abda5ea..36869725211848db98d6b3e12d1c3be643e9cc90 100644
--- a/third_party/WebKit/Source/core/input/ScrollManager.cpp
+++ b/third_party/WebKit/Source/core/input/ScrollManager.cpp
@@ -22,6 +22,7 @@
 #include "core/page/scrolling/RootScrollerController.h"
 #include "core/page/scrolling/ScrollState.h"
 #include "core/paint/PaintLayer.h"
+#include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "wtf/PtrUtil.h"
 
@@ -196,6 +197,75 @@ void ScrollManager::customizedScroll(const Node& startNode,
   scrollState.distributeToScrollChainDescendant();
 }
 
+uint32_t ScrollManager::computeMainThreadScrollingReasons(const Node& node) {
+  if (!m_frame || !m_frame->view())
+    return 0;
+  uint32_t reasons = m_frame->view()->mainThreadScrollingReasons();
+  LayoutBox* curBox = node.layoutObject()->enclosingBox();
+  Element* documentElement = m_frame->document()->documentElement();
+  while (curBox) {
+    Node* curNode = curBox->node();
+    Element* curElement = nullptr;
+    // FIXME: this should reject more elements, as part of crbug.com/410974.
+    if (curNode && curNode->isElementNode()) {
+      curElement = toElement(curNode);
+    } else if (curNode && curNode->isDocumentNode()) {
+      // In normal circumastances, the documentElement will be the root
+      // scroller but the documentElement itself isn't a containing block,
+      // that'll be the document node rather than the element.
+      curElement = documentElement;

[bokan, 2017/03/24 17:55:54]

Document-scrolling is always composited so we don't need to worry about it on
the main thread. If we need to main thread scroll it - the existing machinery
will set the reasons on its GraphicsLayer/cc::Layer and it'll be reported on the
compositor (see my note in input_handler_proxy)

[yigu, 2017/03/27 21:02:07]

Done.

+    } else {
+      curBox = curBox->containingBlock();
+      continue;
+    }
+    if (curElement) {
+      if (isViewportScrollingElement(*curElement) ||
+          curElement == documentElement)
+        break;
+    }
+    if (curNode->layoutBoxModelObject() &&
+        curNode->layoutBoxModelObject()->getScrollableArea()) {
+      reasons |= curNode->layoutBoxModelObject()

[bokan, 2017/03/24 17:55:54]

Given that I think since we'll record the other main thread scrolling reasons on
the compositor (i.e. from main thread, we'll only record reasons due to
non-compositing) I don't think you have to walk up the ancestor chain.

Instead, you should walk up the LayoutBox tree to the first node that's
PLSA::isScrollable and record the "main thread scrolling reasons" there.

[yigu, 2017/03/27 21:02:07]

Done.

+                     ->getScrollableArea()
+                     ->getStyleRelatedMainThreadScrollingReasons();
+    }
+    curBox = curBox->containingBlock();
+  }
+  return reasons;
+}
+
+void ScrollManager::recordMainThreadScrollingReasons(
+    const uint32_t reasons,
+    const WebGestureDevice device) {
+  uint32_t mainThreadScrollingReasonEnumMax =
+      MainThreadScrollingReason::kMainThreadScrollingReasonCount + 1;
+  for (uint32_t i = 0;
+       i < MainThreadScrollingReason::kMainThreadScrollingReasonCount; ++i) {
+    unsigned val = 1 << i;
+    if (reasons & val) {
+      if (val == MainThreadScrollingReason::kHandlingScrollFromMainThread) {
+        // We only want to record "Handling scroll from main thread" reason if
+        // it's the only reason. If it's not the only reason, the "real"
+        // reason for scrolling on main is something else, and we only want to
+        // pay attention to that reason.
+        if (reasons & ~val)
+          continue;
+      }
+      if (device == WebGestureDeviceTouchscreen) {
+        DEFINE_STATIC_LOCAL(EnumerationHistogram, touchHistogram,
+                            ("Renderer4.MainThreadGestureScrollReason",
+                             mainThreadScrollingReasonEnumMax));
+        touchHistogram.count(i + 1);
+      } else {
+        DEFINE_STATIC_LOCAL(EnumerationHistogram, wheelHistogram,
+                            ("Renderer4.MainThreadWheelScrollReason",
+                             mainThreadScrollingReasonEnumMax));
+        wheelHistogram.count(i + 1);
+      }
+    }
+  }
+}
+
 WebInputEventResult ScrollManager::handleGestureScrollBegin(
     const WebGestureEvent& gestureEvent) {
   Document* document = m_frame->document();
@@ -221,6 +291,15 @@ WebInputEventResult ScrollManager::handleGestureScrollBegin(
   passScrollGestureEvent(gestureEvent,
                          m_scrollGestureHandlingNode->layoutObject());
 
+  if (m_scrollGestureHandlingNode->layoutObject() &&
+      (gestureEvent.sourceDevice == WebGestureDeviceTouchpad ||
+       gestureEvent.sourceDevice == WebGestureDeviceTouchscreen)) {
+    uint32_t reasons =
+        computeMainThreadScrollingReasons(*m_scrollGestureHandlingNode);
+    if (reasons)

[bokan, 2017/03/24 17:55:54]

Move all the additions above into recordMainThreadScrollingReasons and early-out
there if you don't need to record. recordMainThreadScrollingReasons should be
private. This means you'll need to adjust the tests in EventHandlerTest -- we
should really be loading some HTML that isn't composited, scrolling it, and
making sure the appropriate stats are recorded.

Given that I'm not sure unit tests are appropriately hooked up with compositing
- it's possible in a unit test everything is marked as non-composited. If you
can't make it work there, you may need to create a SimTest instead but lets
cross that bridge when we get to it.

+      recordMainThreadScrollingReasons(reasons, gestureEvent.sourceDevice);
+  }
+
   m_currentScrollChain.clear();
   std::unique_ptr<ScrollStateData> scrollStateData =
       WTF::makeUnique<ScrollStateData>();