Added missing MainThreadScrollingReason in histograms.xml

ui/events/blink/input_handler_proxy_unittest.cc

 // Copyright 2013 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 "ui/events/blink/input_handler_proxy.h"
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/test/histogram_tester.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/trees/swap_promise_monitor.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
 #include "third_party/WebKit/public/platform/WebFloatSize.h"
 #include "third_party/WebKit/public/platform/WebGestureCurve.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/events/blink/input_handler_proxy_client.h"
@@ skipping 231 matching lines @@
     cc::MainThreadScrollingReason::kNotScrollingOnMain);
 
 const cc::InputHandler::ScrollStatus kMainThreadScrollState(
     cc::InputHandler::SCROLL_ON_MAIN_THREAD,
     cc::MainThreadScrollingReason::kEventHandlers);
 
 const cc::InputHandler::ScrollStatus kScrollIgnoredScrollState(
     cc::InputHandler::SCROLL_IGNORED,
     cc::MainThreadScrollingReason::kNotScrollable);
 
+class TestInputHandlerProxy : public InputHandlerProxy {
+ public:
+  TestInputHandlerProxy(cc::InputHandler* input_handler,
+                        InputHandlerProxyClient* client)
+      : InputHandlerProxy(input_handler, client) {}
+  void RecordMainThreadScrollingReasonsForTest(blink::WebInputEvent::Type type,
+                                               uint32_t reasons) {
+    RecordMainThreadScrollingReasons(type, reasons);
+  }
+};
+
 }  // namespace
 
 class InputHandlerProxyTest
     : public testing::Test,
       public testing::WithParamInterface<InputHandlerProxyTestType> {
  public:
   InputHandlerProxyTest()
       : synchronous_root_scroll_(GetParam() == ROOT_SCROLL_SYNCHRONOUS_HANDLER),
         install_synchronous_handler_(
             GetParam() == ROOT_SCROLL_SYNCHRONOUS_HANDLER ||
             GetParam() == CHILD_SCROLL_SYNCHRONOUS_HANDLER),
         expected_disposition_(InputHandlerProxy::DID_HANDLE) {
     input_handler_.reset(
-        new ui::InputHandlerProxy(
+        new TestInputHandlerProxy(
             &mock_input_handler_, &mock_client_));
     scroll_result_did_scroll_.did_scroll = true;
     scroll_result_did_not_scroll_.did_scroll = false;
 
     if (install_synchronous_handler_) {
       EXPECT_CALL(mock_input_handler_,
                   RequestUpdateForSynchronousInputHandler())
           .Times(1);
       input_handler_->SetOnlySynchronouslyAnimateRootFlings(
           &mock_synchronous_input_handler_);
@@ skipping 88 matching lines @@
   void SetMouseWheelGesturesOn(bool value) {
     input_handler_->set_use_gesture_events_for_mouse_wheel(value);
   }
 
  protected:
   const bool synchronous_root_scroll_;
   const bool install_synchronous_handler_;
   testing::StrictMock<MockInputHandler> mock_input_handler_;
   testing::StrictMock<MockSynchronousInputHandler>
       mock_synchronous_input_handler_;
-  scoped_ptr<ui::InputHandlerProxy> input_handler_;
+  scoped_ptr<TestInputHandlerProxy> input_handler_;
   testing::StrictMock<MockInputHandlerProxyClient> mock_client_;
   WebGestureEvent gesture_;
   InputHandlerProxy::EventDisposition expected_disposition_;
   cc::InputHandlerScrollResult scroll_result_did_scroll_;
   cc::InputHandlerScrollResult scroll_result_did_not_scroll_;
 };
 
 TEST_P(InputHandlerProxyTest, MouseWheelByPageMainThread) {
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   SetMouseWheelGesturesOn(false);
@@ skipping 2289 matching lines @@
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, DidReceiveInputEvent_ForFling) {
   testing::StrictMock<MockInputHandlerProxyClientWithDidAnimateForInput>
       mock_client;
   input_handler_.reset(
-        new ui::InputHandlerProxy(
+        new TestInputHandlerProxy(
             &mock_input_handler_, &mock_client));
   if (install_synchronous_handler_) {
     EXPECT_CALL(mock_input_handler_, RequestUpdateForSynchronousInputHandler())
         .Times(1);
     input_handler_->SetOnlySynchronouslyAnimateRootFlings(
         &mock_synchronous_input_handler_);
   }
   mock_input_handler_.set_is_scrolling_root(synchronous_root_scroll_);
 
   gesture_.type = WebInputEvent::GestureFlingStart;
@@ skipping 78 matching lines @@
 
   EXPECT_CALL(mock_input_handler, SetSynchronousInputHandlerRootScrollOffset(
                                       gfx::ScrollOffset(5, 6)));
   proxy.SynchronouslySetRootScrollOffset(gfx::ScrollOffset(5, 6));
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler);
   testing::Mock::VerifyAndClearExpectations(&mock_client);
   testing::Mock::VerifyAndClearExpectations(&mock_synchronous_input_handler);
 }
 
+TEST_P(InputHandlerProxyTest, MainThreadScrollingMouseWheelHistograms) {
+  base::HistogramTester histogram_tester;
+  input_handler_->RecordMainThreadScrollingReasonsForTest(
+      WebInputEvent::MouseWheel,
+      cc::MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects |
+          cc::MainThreadScrollingReason::kThreadedScrollingDisabled |
+          cc::MainThreadScrollingReason::kPageOverlay |
+          cc::MainThreadScrollingReason::kAnimatingScrollOnMainThread);
+
+  EXPECT_THAT(
+      histogram_tester.GetAllSamples("Renderer4.MainThreadWheelScrollReason"),
+      testing::ElementsAre(base::Bucket(1, 1), base::Bucket(3, 1),
+                           base::Bucket(5, 1), base::Bucket(14, 1)));
+}
+
+
 INSTANTIATE_TEST_CASE_P(AnimateInput,
                         InputHandlerProxyTest,
                         testing::ValuesIn(test_types));
 }  // namespace test
 }  // namespace ui