Record size of scroller that user scrolls

third_party/WebKit/Source/core/input/EventHandlerTest.cpp

 // Copyright 2015 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/EventHandler.h"
 
 #include <memory>
 #include "core/dom/ClientRect.h"
 #include "core/dom/Document.h"
 #include "core/dom/Range.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutBox.h"
 #include "core/loader/EmptyClients.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/Page.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "core/testing/DummyPageHolder.h"
 #include "platform/scroll/MainThreadScrollingReason.h"
+#include "platform/scroll/ScrollerSizeMetrics.h"
 #include "platform/testing/HistogramTester.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define EXPECT_WHEEL_BUCKET(reason, count)     \
   histogram_tester.ExpectBucketCount(          \
       "Renderer4.MainThreadWheelScrollReason", \
       GetBucketIndex(MainThreadScrollingReason::reason), count);
 
 #define EXPECT_TOUCH_BUCKET(reason, count)       \
   histogram_tester.ExpectBucketCount(            \
@@ skipping 12 matching lines @@
 
 class EventHandlerTest : public ::testing::Test {
  protected:
   void SetUp() override;
 
   Page& GetPage() const { return dummy_page_holder_->GetPage(); }
   Document& GetDocument() const { return dummy_page_holder_->GetDocument(); }
   FrameSelection& Selection() const {
     return GetDocument().GetFrame()->Selection();
   }
-
   void SetHtmlInnerHTML(const char* html_content);
+  void Scroll(Element*, const WebGestureDevice);
 
  protected:
   std::unique_ptr<DummyPageHolder> dummy_page_holder_;
 };
 
 class NonCompositedMainThreadScrollingReasonRecordTest
     : public EventHandlerTest {
  protected:
-  class ScrollBeginEventBuilder : public WebGestureEvent {
-   public:
-    ScrollBeginEventBuilder(IntPoint position,
-                            FloatPoint delta,
-                            WebGestureDevice device)
-        : WebGestureEvent() {
-      type_ = WebInputEvent::kGestureScrollBegin;
-      x = global_x = position.X();
-      y = global_y = position.Y();
-      data.scroll_begin.delta_y_hint = delta.Y();
-      source_device = device;
-      frame_scale_ = 1;
-    }
-  };
-
-  class ScrollUpdateEventBuilder : public WebGestureEvent {
-   public:
-    ScrollUpdateEventBuilder() : WebGestureEvent() {
-      type_ = WebInputEvent::kGestureScrollUpdate;
-      data.scroll_update.delta_x = 0.0f;
-      data.scroll_update.delta_y = 1.0f;
-      data.scroll_update.velocity_x = 0;
-      data.scroll_update.velocity_y = 1;
-      frame_scale_ = 1;
-    }
-  };
-
-  class ScrollEndEventBuilder : public WebGestureEvent {
-   public:
-    ScrollEndEventBuilder() : WebGestureEvent() {
-      type_ = WebInputEvent::kGestureScrollEnd;
-      frame_scale_ = 1;
-    }
-  };
-
   int GetBucketIndex(uint32_t reason);
-  void Scroll(Element*, const WebGestureDevice);
 };
 
 class TapEventBuilder : public WebGestureEvent {
  public:
   TapEventBuilder(IntPoint position, int tap_count)
       : WebGestureEvent(WebInputEvent::kGestureTap,
                         WebInputEvent::kNoModifiers,
                         TimeTicks::Now().InSeconds()) {
     x = global_x = position.X();
     y = global_y = position.Y();
@@ skipping 27 matching lines @@
                       WebInputEvent::kNoModifiers,
                       TimeTicks::Now().InSeconds()) {
     click_count = click_count_param;
     button = button_param;
     SetPositionInWidget(position_param.X(), position_param.Y());
     SetPositionInScreen(position_param.X(), position_param.Y());
     frame_scale_ = 1;
   }
 };
 
+class ScrollBeginEventBuilder : public WebGestureEvent {
+ public:
+  ScrollBeginEventBuilder(IntPoint position,
+                          FloatPoint delta,
+                          WebGestureDevice device)
+      : WebGestureEvent() {
+    type_ = WebInputEvent::kGestureScrollBegin;
+    x = global_x = position.X();
+    y = global_y = position.Y();
+    data.scroll_begin.delta_y_hint = delta.Y();
+    source_device = device;
+    frame_scale_ = 1;
+  }
+};
+
+class ScrollUpdateEventBuilder : public WebGestureEvent {
+ public:
+  ScrollUpdateEventBuilder() : WebGestureEvent() {
+    type_ = WebInputEvent::kGestureScrollUpdate;
+    data.scroll_update.delta_x = 0.0f;
+    data.scroll_update.delta_y = 1.0f;
+    data.scroll_update.velocity_x = 0;
+    data.scroll_update.velocity_y = 1;
+    frame_scale_ = 1;
+  }
+};
+
+class ScrollEndEventBuilder : public WebGestureEvent {
+ public:
+  ScrollEndEventBuilder() : WebGestureEvent() {
+    type_ = WebInputEvent::kGestureScrollEnd;
+    frame_scale_ = 1;
+  }
+};
+
 void EventHandlerTest::SetUp() {
   dummy_page_holder_ = DummyPageHolder::Create(IntSize(300, 400));
 }
 
 void EventHandlerTest::SetHtmlInnerHTML(const char* html_content) {
   GetDocument().documentElement()->setInnerHTML(String::FromUTF8(html_content));
   GetDocument().View()->UpdateAllLifecyclePhases();
 }
 
 int NonCompositedMainThreadScrollingReasonRecordTest::GetBucketIndex(
     uint32_t reason) {
   int index = 1;
   while (!(reason & 1)) {
     reason >>= 1;
     ++index;
   }
   DCHECK_EQ(reason, 1u);
   return index;
 }
 
-void NonCompositedMainThreadScrollingReasonRecordTest::Scroll(
-    Element* element,
-    const WebGestureDevice device) {
+void EventHandlerTest::Scroll(Element* element, const WebGestureDevice device) {
   DCHECK(element);
   DCHECK(element->getBoundingClientRect());
   ClientRect* rect = element->getBoundingClientRect();
   ScrollBeginEventBuilder scroll_begin(
       IntPoint(rect->left() + rect->width() / 2,
                rect->top() + rect->height() / 2),
       FloatPoint(0.f, 1.f), device);
   ScrollUpdateEventBuilder scroll_update;
   ScrollEndEventBuilder scroll_end;
   GetDocument().GetFrame()->GetEventHandler().HandleGestureEvent(scroll_begin);
   GetDocument().GetFrame()->GetEventHandler().HandleGestureEvent(scroll_update);
   GetDocument().GetFrame()->GetEventHandler().HandleGestureEvent(scroll_end);
+  ASSERT_GT(scroll_update.DeltaYInRootFrame(), 0);
 }
 
 TEST_F(EventHandlerTest, dragSelectionAfterScroll) {
   SetHtmlInnerHTML(
       "<style> body { margin: 0px; } .upper { width: 300px; height: 400px; }"
       ".lower { margin: 0px; width: 300px; height: 400px; } .line { display: "
       "block; width: 300px; height: 30px; } </style>"
       "<div class='upper'></div>"
       "<div class='lower'>"
       "<span class='line'>Line 1</span><span class='line'>Line 2</span><span "
@@ skipping 380 matching lines @@
       WebInputEvent::kMouseUp, WebFloatPoint(100, 50), WebFloatPoint(200, 250),
       WebPointerProperties::Button::kLeft, 1, WebInputEvent::kNoModifiers,
       TimeTicks::Now().InSeconds());
   mouse_up_event.SetFrameScale(1);
   GetDocument().GetFrame()->GetEventHandler().DragSourceEndedAt(
       mouse_up_event, kDragOperationNone);
 
   // This test passes if it doesn't crash.
 }
 
+TEST_F(EventHandlerTest,
+       ScrollerSizeOfMainThreadScrollingHistogramRecordingTest) {
+  SetHtmlInnerHTML(
+      "<!DOCTYPE html>"
+      "<style>"
+      " .container { width: 200px; height: 200px; overflow: scroll; }"
+      " .box { width: 100px; height: 100px; overflow: scroll; }"
+      " .spacer { height: 1000px; }"
+      " .target { width: 200px; height: 200px; }"
+      " body { height: 2000px; }"
+      "</style>"
+      "<div class='container'>"
+      " <div id='box' class='box'>"
+      "  <div id='content' class='spacer'></div>"
+      " </div>"
+      "</div>"
+      "<div id='target' class='target'></div>");
+
+  Element* box = GetDocument().getElementById("box");
+  HistogramTester histogram_tester;
+
+  // Test wheel scroll on the box.
+  Scroll(box, kWebGestureDeviceTouchpad);
+  histogram_tester.ExpectBucketCount("Event.Scroll.ScrollerSize.OnScroll_Wheel",
+                                     10000, 1);
+  // Only the first scrollable area is recorded.
+  histogram_tester.ExpectBucketCount("Event.Scroll.ScrollerSize.OnScroll_Wheel",
+                                     40000, 0);
+  histogram_tester.ExpectTotalCount("Event.Scroll.ScrollerSize.OnScroll_Wheel",
+                                    1);
+
+  // Test touch scroll.
+  Scroll(box, kWebGestureDeviceTouchscreen);
+  histogram_tester.ExpectBucketCount("Event.Scroll.ScrollerSize.OnScroll_Touch",
+                                     10000, 1);
+  histogram_tester.ExpectTotalCount("Event.Scroll.ScrollerSize.OnScroll_Touch",
+                                    1);
+
+  // Scrolling the non-scrollable target leads to scroll the root layer which
+  // doesn't add to count.
+  Element* body_scroll_target = GetDocument().getElementById("target");
+  Scroll(body_scroll_target, kWebGestureDeviceTouchscreen);
+  histogram_tester.ExpectBucketCount("Event.Scroll.ScrollerSize.OnScroll_Touch",
+                                     kScrollerSizeLargestBucket, 0);
+  histogram_tester.ExpectTotalCount("Event.Scroll.ScrollerSize.OnScroll_Touch",
+                                    1);
+}
+
 class TooltipCapturingChromeClient : public EmptyChromeClient {
  public:
   TooltipCapturingChromeClient() {}
 
   void SetToolTip(LocalFrame&, const String& str, TextDirection) override {
     last_tool_tip_ = str;
   }
 
   String& LastToolTip() { return last_tool_tip_; }
 
@@ skipping 182 matching lines @@
   // inner box itself has no reason because it's composited. Other scrollable
   // areas from the chain have corresponding reasons.
   EXPECT_WHEEL_BUCKET(kHasOpacityAndLCDText, 1);
   EXPECT_WHEEL_BUCKET(kBackgroundNotOpaqueInRectAndLCDText, 1);
   EXPECT_WHEEL_BUCKET(kHasBorderRadius, 1);
   EXPECT_WHEEL_BUCKET(kHasTransformAndLCDText, 0);
   EXPECT_WHEEL_TOTAL(3);
 }
 
 }  // namespace blink