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 727c3e74e57525196f5f4abb1ec12c18a21ecc4c..9423015b04b852c9a999eb510a86d68785e38fe2 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,81 @@ void ScrollManager::customizedScroll(const Node& startNode,
   scrollState.distributeToScrollChainDescendant();
 }
 
+uint32_t ScrollManager::computeNonCompositedMainThreadScrollingReasons() {
+  // When scrolling on the main thread, the scrollableArea may or may not be
+  // composited. If it's composited and has the main thread scrolling reasons
+  // stored in its layer, the reasons have been recorded on cc side. If it
+  // dosen't have existing reasons but scrolls on main, we walk up its
+  // containing scroll chain to find the first non composited region and record
+  // reasons accordingly. If no such region is found or it doesn't have any main
+  // thread scrolling reason, we record the reason kUnknownNonCompositedRegion.
+  // If it's not composited, we have recorded "NonFastScrollableRegion" on
+  // the cc side. Here we try to record additional reasons that prevent
+  // promotion.
+  if (!m_scrollGestureHandlingNode->layoutObject() || !m_frame->view())
+    return 0;
+  uint32_t reasons = 0;
+  bool hasMainThreadScrollingReason = false;
+  bool usesCompositedScrolling = false;
+
+  for (auto* curBox =
+           m_scrollGestureHandlingNode->layoutObject()->enclosingBox();
+       curBox; curBox = curBox->containingBlock()) {
+    auto* scrollableArea = curBox->getScrollableArea();
+    if (!scrollableArea)
+      continue;
+
+    if (scrollableArea->usesCompositedScrolling()) {
+      usesCompositedScrolling = true;
+      hasMainThreadScrollingReason =
+          !!(m_frame->view()->mainThreadScrollingReasons());

[bokan, 2017/04/04 18:14:26]

There's no need to use !!, the value will be implicitly converted to bool.

Also, I think this shouldn't be against m_frame->view()?

Also also, this needs to look for only "MainThreadCanSetReasons" and
"CompositorCanSetReasons" and ignore "NonCompositedScrollReasons" though that
should be the case if usesCompositedScrolling is true so please add a DCHECK
that it doesn't have a NonCompositedScrollReason

+    } else {
+      reasons = scrollableArea->getNonCompositedMainThreadScrollingReasons();
+      if (!reasons)

[bokan, 2017/04/04 18:14:26]

This `if` violates the rule that a non-composited scroller must always have a
NonCompositedMainThreadScrollingReason.

+        continue;
+      break;

[bokan, 2017/04/04 18:14:26]

hmm...I think it would be beneficial to keep walking up even if we do have a
NonComposited reason. So if there's two non-composited scrollers in a chain -
both cause main thread scrolling so we should probably record both. flackr@,
does that sound reasonable?

+    }
+  }
+
+  if (usesCompositedScrolling && !reasons && !hasMainThreadScrollingReason)

[bokan, 2017/04/04 18:14:26]

I think this is still off. usesCompositedScrolling should instead be
usesNonCompositedScrolling since we need to make sure we didn't hit any
*non-composited* scrollers before returning Unknown. (If we hit a non-composited
scroller, we shouldn't return Unknown since we should use the reason for that
scroller).

+    return MainThreadScrollingReason::kUnknownNonCompositedRegion;
+
+  return reasons;
+}
+
+void ScrollManager::recordNonCompositedMainThreadScrollingReasons(
+    const WebGestureDevice device) {
+  if (device != WebGestureDeviceTouchpad &&
+      device != WebGestureDeviceTouchscreen) {
+    return;
+  }
+
+  uint32_t reasons = computeNonCompositedMainThreadScrollingReasons();
+  if (!reasons)
+    return;
+  DCHECK(MainThreadScrollingReason::NonCompositedScrollReasons(reasons));
+
+  uint32_t mainThreadScrollingReasonEnumMax =
+      MainThreadScrollingReason::kMainThreadScrollingReasonCount + 1;
+  for (uint32_t i = MainThreadScrollingReason::kNonCompositedReasonsFirst;
+       i <= MainThreadScrollingReason::kNonCompositedReasonsLast; ++i) {
+    unsigned val = 1 << i;
+    if (reasons & val) {
+      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 +297,8 @@ WebInputEventResult ScrollManager::handleGestureScrollBegin(
   passScrollGestureEvent(gestureEvent,
                          m_scrollGestureHandlingNode->layoutObject());
 
+  recordNonCompositedMainThreadScrollingReasons(gestureEvent.sourceDevice);
+
   m_currentScrollChain.clear();
   std::unique_ptr<ScrollStateData> scrollStateData =
       WTF::makeUnique<ScrollStateData>();