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

third_party/WebKit/Source/core/input/ScrollManager.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/ScrollManager.h"
 
 #include <memory>
 #include "core/dom/DOMNodeIds.h"
 #include "core/events/GestureEvent.h"
 #include "core/frame/BrowserControls.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/input/EventHandler.h"
 #include "core/input/EventHandlingUtil.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/OverscrollController.h"
 #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"
 
 namespace blink {
 
 ScrollManager::ScrollManager(LocalFrame& frame) : m_frame(frame) {
   clear();
 }
 
 void ScrollManager::clear() {
@@ skipping 154 matching lines @@
   if (scrollState.deltaX() || scrollState.deltaY())
     m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   if (m_currentScrollChain.empty())
     recomputeScrollChain(startNode, m_currentScrollChain);
   scrollState.setScrollChain(m_currentScrollChain);
 
   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();
 
   if (document->layoutViewItem().isNull())
     return WebInputEventResult::NotHandled;
 
   // If there's no layoutObject on the node, send the event to the nearest
   // ancestor with a layoutObject.  Needed for <option> and <optgroup> elements
   // so we can touch scroll <select>s
   while (m_scrollGestureHandlingNode &&
          !m_scrollGestureHandlingNode->layoutObject())
     m_scrollGestureHandlingNode =
         m_scrollGestureHandlingNode->parentOrShadowHostNode();
 
   if (!m_scrollGestureHandlingNode)
     m_scrollGestureHandlingNode = m_frame->document()->documentElement();
 
   if (!m_scrollGestureHandlingNode ||
       !m_scrollGestureHandlingNode->layoutObject())
     return WebInputEventResult::NotHandled;
 
   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>();
   IntPoint position = flooredIntPoint(gestureEvent.positionInRootFrame());
   scrollStateData->position_x = position.x();
   scrollStateData->position_y = position.y();
   scrollStateData->is_beginning = true;
   scrollStateData->from_user_input = true;
   scrollStateData->is_direct_manipulation =
       gestureEvent.sourceDevice == WebGestureDeviceTouchscreen;
@@ skipping 319 matching lines @@
     if (scrollbar->gestureEvent(targetedEvent.event(), &shouldUpdateCapture)) {
       if (shouldUpdateCapture)
         m_scrollbarHandlingScrollGesture = scrollbar;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace blink