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) : frame_(frame) {
   Clear();
 }
 
 void ScrollManager::Clear() {
@@ skipping 154 matching lines @@
   if (scroll_state.deltaX() || scroll_state.deltaY())
     frame_->GetDocument()->UpdateStyleAndLayoutIgnorePendingStylesheets();
 
   if (current_scroll_chain_.empty())
     RecomputeScrollChain(start_node, current_scroll_chain_);
   scroll_state.SetScrollChain(current_scroll_chain_);
 
   scroll_state.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 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 (!scroll_gesture_handling_node_->GetLayoutObject() || !frame_->View())
+    return 0;
+
+  uint32_t non_composited_main_thread_scrolling_reasons = 0;
+
+  for (auto* cur_box =
+           scroll_gesture_handling_node_->GetLayoutObject()->EnclosingBox();
+       cur_box; cur_box = cur_box->ContainingBlock()) {
+    PaintLayerScrollableArea* scrollable_area = cur_box->GetScrollableArea();
+
+    if (!scrollable_area || !scrollable_area->ScrollsOverflow())
+      continue;
+
+    DCHECK(!scrollable_area->UsesCompositedScrolling() ||
+           !scrollable_area->GetNonCompositedMainThreadScrollingReasons());
+    non_composited_main_thread_scrolling_reasons |=
+        scrollable_area->GetNonCompositedMainThreadScrollingReasons();
+  }

[flackr, 2017/04/11 19:35:35]

What is the state when we handle these events? If compositing inputs are clean,
which it seems like they should be if we're checking for compositing reasons,
then I think you can replace this loop with
scroll_gesture_handling_node_->enclosingLayer()->ancestorScrollingLayer()

[flackr, 2017/04/11 20:13:03]

It looks like recomputing the scroll chain actually computes all of the ancestor
scrollers in an upwards walk to the root too, so this shouldn't be too bad for
performance. It is worth noting however that if compositing inputs are dirty the
reasons are probably not current either, but this may be fine.

+
+  return non_composited_main_thread_scrolling_reasons;
+}
+
+void ScrollManager::RecordNonCompositedMainThreadScrollingReasons(
+    const WebGestureDevice device) {
+  if (device != kWebGestureDeviceTouchpad &&
+      device != kWebGestureDeviceTouchscreen) {
+    return;
+  }
+
+  uint32_t reasons = ComputeNonCompositedMainThreadScrollingReasons();
+  if (!reasons)
+    return;
+  DCHECK(MainThreadScrollingReason::HasNonCompositedScrollReasons(reasons));
+
+  uint32_t main_thread_scrolling_reason_enum_max =
+      MainThreadScrollingReason::kMainThreadScrollingReasonCount + 1;
+  for (uint32_t i = MainThreadScrollingReason::kNonCompositedReasonsFirst;
+       i <= MainThreadScrollingReason::kNonCompositedReasonsLast; ++i) {
+    unsigned val = 1 << i;
+    if (reasons & val) {
+      if (device == kWebGestureDeviceTouchscreen) {
+        DEFINE_STATIC_LOCAL(EnumerationHistogram, touch_histogram,
+                            ("Renderer4.MainThreadGestureScrollReason",
+                             main_thread_scrolling_reason_enum_max));
+        touch_histogram.Count(i + 1);
+      } else {
+        DEFINE_STATIC_LOCAL(EnumerationHistogram, wheel_histogram,
+                            ("Renderer4.MainThreadWheelScrollReason",
+                             main_thread_scrolling_reason_enum_max));

[flackr, 2017/04/11 20:13:03]

I notice the device in this case is only kWebGestureDeviceTouchpad, does that
include mouse wheel scrolls?

[yigu, 2017/04/11 21:28:10]

Mouse wheel scrolling uses kWebGestureDeviceTouchpad as device type.

+        wheel_histogram.Count(i + 1);
+      }
+    }
+  }
+}
+
 WebInputEventResult ScrollManager::HandleGestureScrollBegin(
     const WebGestureEvent& gesture_event) {
   Document* document = frame_->GetDocument();
 
   if (document->GetLayoutViewItem().IsNull())
     return WebInputEventResult::kNotHandled;
 
   // 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 (scroll_gesture_handling_node_ &&
          !scroll_gesture_handling_node_->GetLayoutObject())
     scroll_gesture_handling_node_ =
         scroll_gesture_handling_node_->ParentOrShadowHostNode();
 
   if (!scroll_gesture_handling_node_)
     scroll_gesture_handling_node_ = frame_->GetDocument()->documentElement();
 
   if (!scroll_gesture_handling_node_ ||
       !scroll_gesture_handling_node_->GetLayoutObject())
     return WebInputEventResult::kNotHandled;
 
   PassScrollGestureEvent(gesture_event,
                          scroll_gesture_handling_node_->GetLayoutObject());
 
+  RecordNonCompositedMainThreadScrollingReasons(gesture_event.source_device);
+
   current_scroll_chain_.clear();
   std::unique_ptr<ScrollStateData> scroll_state_data =
       WTF::MakeUnique<ScrollStateData>();
   IntPoint position = FlooredIntPoint(gesture_event.PositionInRootFrame());
   scroll_state_data->position_x = position.X();
   scroll_state_data->position_y = position.Y();
   scroll_state_data->is_beginning = true;
   scroll_state_data->from_user_input = true;
   scroll_state_data->is_direct_manipulation =
       gesture_event.source_device == kWebGestureDeviceTouchscreen;
@@ skipping 332 matching lines @@
                                 &should_update_capture)) {
       if (should_update_capture)
         scrollbar_handling_scroll_gesture_ = scrollbar;
       return true;
     }
   }
   return false;
 }
 
 }  // namespace blink