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::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();
 
   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());
 
+  recordNonCompositedMainThreadScrollingReasons(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 326 matching lines @@
     if (scrollbar->gestureEvent(targetedEvent.event(), &shouldUpdateCapture)) {
       if (shouldUpdateCapture)
         m_scrollbarHandlingScrollGesture = scrollbar;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace blink