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 "wtf/PtrUtil.h"
 
 namespace blink {
 
 ScrollManager::ScrollManager(LocalFrame& frame) : m_frame(frame) {
   clear();
 }
 
 void ScrollManager::clear() {
@@ skipping 179 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 318 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())
+    return;
+
+  if (device == WebGestureDeviceTouchpad) {
+    DEFINE_STATIC_LOCAL(
+        CustomCountHistogram, sizeHistogram,

[tdresser, 2017/03/28 13:30:12]

It looks like these macros are defining a static local with the same name.

Don't these names need to be different? Why is this currently working?

[yigu, 2017/03/29 15:32:03]

It's better we differentiate the names. There are existing logic that uses same
histogram name
(https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/html/HTML...).
Could it be static method overload? But the param type looks identical. I need
to dig into the WTF::StaticSingleton.

+        ("Event.Scroll.ScrollerSize.OnScroll_Wheel", 1, 90000, 50));

[flackr, 2017/03/28 14:40:23]

As I mentioned in the cc file we should use constants for the max and number of
buckets.

I'm not sure if 90000 is the right maximum for small scrollers, I'd recommend
about 200000 to cover any scroller that's smaller than 500x400 at and above
which size you could argue it is intended to be a/the main scroller.
Alternately, we could have a maximum that goes well above what we would consider
to be large scrollers which would help us to determine the relative proportion
of small scroller scrolling vs large scroller scrolling.

How will we tell if there are small scrollers that do not get scrolled (i.e.
prime candidates to not save layers for)? I think we should also record scroller
sizes that we see occur on pages.

[yigu, 2017/03/29 15:32:03]

500*400 makes sense to me.
There is gonna be another patch that adds recording scrollers on load/create and
that's why I name the histograms *OnScroll*.

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