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. Either way, we have recorded either the reasons that

[bokan, 2017/04/06 21:45:09]

nit: "reasons that stored" -> "reasons stored"

[yigu, 2017/04/07 16:35:32]

Done.

+  // stored in its layer or the reason NonFastScrollableRegion from the
+  // compositor side. Here we record scrolls that occurred on main thread
+  // due to a non-composited scroller.
+  if (!m_scrollGestureHandlingNode->layoutObject() || !m_frame->view())
+    return 0;
+
+  uint32_t nonCompositedMainThreadScrollingReasons = 0;
+
+  for (auto* curBox =
+           m_scrollGestureHandlingNode->layoutObject()->enclosingBox();
+       curBox; curBox = curBox->containingBlock()) {
+    PaintLayerScrollableArea* scrollableArea = curBox->getScrollableArea();
+
+    if (!scrollableArea || !scrollableArea->scrollsOverflow())
+      continue;
+
+    DCHECK(!scrollableArea->usesCompositedScrolling() ||
+           !nonCompositedMainThreadScrollingReasons);
+    nonCompositedMainThreadScrollingReasons =

[bokan, 2017/04/06 21:45:09]

this should be |=, right?

[yigu, 2017/04/07 16:35:32]

Done.

+        scrollableArea->getNonCompositedMainThreadScrollingReasons();
+  }
+
+  return nonCompositedMainThreadScrollingReasons;
+}
+
+void ScrollManager::recordNonCompositedMainThreadScrollingReasons(
+    const WebGestureDevice device) {
+  if (device != WebGestureDeviceTouchpad &&
+      device != WebGestureDeviceTouchscreen) {
+    return;
+  }
+
+  uint32_t reasons = computeNonCompositedMainThreadScrollingReasons();
+  if (!reasons)
+    return;
+  DCHECK(MainThreadScrollingReason::NonCompositedScrollReasons(reasons));

[bokan, 2017/04/06 21:45:09]

It wouldn't hurt to DCHECK that we don't have any mainThread or CompositorSet
reasons.

[yigu, 2017/04/07 16:35:32]

Current DCHECK guarantees that the reason doesn't include MainThreadCanSet or
CompositedCanSet reasons.

[bokan, 2017/04/07 17:39:03]

Ah, my bad, I didn't pay close enough attention to how these methods work. Now
that I take a look though I think we should change it to my understanding (which
is what the other call site uses). See my comment in the function definition. It
means you'll have to also DCHECK here that we don't have any of the other types
here.

+
+  uint32_t mainThreadScrollingReasonEnumMax =

[bokan, 2017/04/06 21:45:10]

unused

[yigu, 2017/04/07 16:35:32]

It's used in DEFINE_STATIC_LOCAL.

[bokan, 2017/04/07 17:39:03]

Doh

+      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