Record size of scroller that user scrolls

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 "platform/scroll/ScrollerSize.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 ScrollManager::ScrollManager(LocalFrame& frame) : m_frame(frame) {
   clear();
 }
 
 void ScrollManager::clear() {
   m_lastGestureScrollOverFrameViewBase = false;
@@ skipping 178 matching lines @@
   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)) {
+    recordScrollerSize(*(m_scrollGestureHandlingNode->layoutObject()),
+                       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 325 matching lines @@
     bool shouldUpdateCapture = false;
     if (scrollbar->gestureEvent(targetedEvent.event(), &shouldUpdateCapture)) {
       if (shouldUpdateCapture)
         m_scrollbarHandlingScrollGesture = scrollbar;
       return true;
     }
   }
   return false;
 }
 
+void ScrollManager::recordScrollerSize(const LayoutObject& layoutObject,
+                                       const WebGestureDevice device) {
+  if (!layoutObject.enclosingLayer())

[flackr, 2017/04/12 15:31:04]

I'm confused, is the scroll gesture handling node an arbitrary descendant of the
scroller? If so, we need to walk up to the nearest ancestor scroller. It seems
like this method should have a
DCHECK(layoutObject.scrollableArea())

+    return;
+
+  if (device == WebGestureDeviceTouchpad) {
+    DEFINE_STATIC_LOCAL(CustomCountHistogram, sizeHistogramWheel,
+                        ("Event.Scroll.ScrollerSize.OnScroll_Wheel", 1,
+                         kMaxScrollerSize, kBucketNum));
+    sizeHistogramWheel.count(
+        layoutObject.enclosingLayer()->visualRect().width().toInt() *

[bokan, 2017/03/31 20:23:50]

I think this misses a few edge cases. For starters, I think if you're hitting
the documentElement, the enclosing layer will be the layer in which the entire
document is drawn into rather than the viewport scroll layer which is what I
think you want. You'll want to specifically check for whether enclosingLayer ==
PaintLayerCompositor::rootLayer and if it is use the
FrameView->scrollingLayer().

The other issue I see is that the enclosingLayer may have been created for a
reason other than overflow/scrolling. E.g. z-index causes creation of a new
PaintLayer. In that case, you'd be calculating the area of the Element with
z-index while the thing you're scrolling might be higher up in the layout tree.
I'd look in the scrolling code to see how it bubbles up trying to scroll and
duplicate that logic here.

Basically, using enclosingLayer alone isn't enough.

(Also, please add tests for these edge cases)

[bokan, 2017/03/31 20:24:45]

I think this is probably the reason your frame scrolling test is returning the
200,000 bucket.

[yigu, 2017/03/31 20:38:32]

We basically don't care about the main scroller as it's too big (viewport) and
we have a layer created for it anyway. The z-index thing I need to test.

[bokan, 2017/04/04 15:25:45]

If we don't care about the viewport, we should avoid recording it at all rather
than muddying the metric with it. You'll currently be over-reporting large
scrollers because you're recording the size of the  *contents* for the viewport,
rather than the viewport size.

+        layoutObject.enclosingLayer()->visualRect().height().toInt());
+  } else {
+    DEFINE_STATIC_LOCAL(CustomCountHistogram, sizeHistogramTouch,
+                        ("Event.Scroll.ScrollerSize.OnScroll_Touch", 1,
+                         kMaxScrollerSize, kBucketNum));
+    sizeHistogramTouch.count(
+        layoutObject.enclosingLayer()->visualRect().width().toInt() *
+        layoutObject.enclosingLayer()->visualRect().height().toInt());
+  }
+}
+
 }  // namespace blink