cc: Fix enum style conformance in InputHandler.

ui/events/blink/input_handler_proxy.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 <stddef.h>
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
+#include "cc/input/main_thread_scrolling_reason.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/events/blink/input_handler_proxy_client.h"
 #include "ui/events/blink/input_scroll_elasticity_controller.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/geometry/point_conversions.h"
 
 using blink::WebFloatPoint;
 using blink::WebFloatSize;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
@@ skipping 323 matching lines @@
         // otherwise disrupt an in-progress touch scroll.
         if (fling_curve_)
           CancelCurrentFling();
       }
       break;
   }
 
   return DID_NOT_HANDLE;
 }
 
-void RecordMainThreadScrollingReasons(
-    WebInputEvent::Type type,
-    cc::InputHandler::MainThreadScrollingReason reasons) {
+void RecordMainThreadScrollingReasons(WebInputEvent::Type type,
+                                      uint32_t reasons) {
   static const char* kGestureHistogramName =
       "Renderer4.MainThreadGestureScrollReason";
   static const char* kWheelHistogramName =
       "Renderer4.MainThreadWheelScrollReason";
 
   DCHECK(type == WebInputEvent::GestureScrollBegin ||
          type == WebInputEvent::MouseWheel);
 
   if (type != WebInputEvent::GestureScrollBegin &&
       type != WebInputEvent::MouseWheel) {
     return;
   }
 
-  if (reasons == cc::InputHandler::NOT_SCROLLING_ON_MAIN) {
+  if (reasons == cc::MainThreadScrollingReason::kNotScrollingOnMain) {
     if (type == WebInputEvent::GestureScrollBegin) {
       UMA_HISTOGRAM_ENUMERATION(
-          kGestureHistogramName, cc::InputHandler::NOT_SCROLLING_ON_MAIN,
-          cc::InputHandler::MainThreadScrollingReasonCount);
+          kGestureHistogramName,
+          cc::MainThreadScrollingReason::kNotScrollingOnMain,
+          cc::MainThreadScrollingReason::kMainThreadScrollingReasonCount);
     } else {
       UMA_HISTOGRAM_ENUMERATION(
-          kWheelHistogramName, cc::InputHandler::NOT_SCROLLING_ON_MAIN,
-          cc::InputHandler::MainThreadScrollingReasonCount);
+          kWheelHistogramName,
+          cc::MainThreadScrollingReason::kNotScrollingOnMain,
+          cc::MainThreadScrollingReason::kMainThreadScrollingReasonCount);
     }
   }
 
-  for (int i = 0; i < cc::InputHandler::MainThreadScrollingReasonCount - 1;
+  for (uint32_t i = 0;
+       i < cc::MainThreadScrollingReason::kMainThreadScrollingReasonCount - 1;
        ++i) {
     unsigned val = 1 << i;
     if (reasons & val) {
       if (type == WebInputEvent::GestureScrollBegin) {
         UMA_HISTOGRAM_ENUMERATION(
             kGestureHistogramName, i + 1,
-            cc::InputHandler::MainThreadScrollingReasonCount);
+            cc::MainThreadScrollingReason::kMainThreadScrollingReasonCount);
       } else {
         UMA_HISTOGRAM_ENUMERATION(
             kWheelHistogramName, i + 1,
-            cc::InputHandler::MainThreadScrollingReasonCount);
+            cc::MainThreadScrollingReason::kMainThreadScrollingReasonCount);
       }
     }
   }
 }
 
 bool InputHandlerProxy::ShouldAnimate(
     const blink::WebMouseWheelEvent& event) const {
 #if defined(OS_MACOSX)
   // Mac does not smooth scroll wheel events (crbug.com/574283).
   return false;
@@ skipping 14 matching lines @@
           ? -wheel_event.deltaX
           : 0,
       wheel_event.railsMode != WebInputEvent::RailsModeHorizontal
           ? -wheel_event.deltaY
           : 0);
 
   if (wheel_event.scrollByPage) {
     // TODO(jamesr): We don't properly handle scroll by page in the compositor
     // thread, so punt it to the main thread. http://crbug.com/236639
     result = DID_NOT_HANDLE;
-    RecordMainThreadScrollingReasons(wheel_event.type,
-                                     cc::InputHandler::PAGE_BASED_SCROLLING);
+    RecordMainThreadScrollingReasons(
+        wheel_event.type, cc::MainThreadScrollingReason::kPageBasedScrolling);
 
   } else if (!wheel_event.canScroll) {
     // Wheel events with |canScroll| == false will not trigger scrolling,
     // only event handlers.  Forward to the main thread.
     result = DID_NOT_HANDLE;
   } else if (ShouldAnimate(wheel_event)) {
     cc::InputHandler::ScrollStatus scroll_status =
         input_handler_->ScrollAnimated(gfx::Point(wheel_event.x, wheel_event.y),
                                        scroll_delta);
 
@@ skipping 45 matching lines @@
         // TODO(jamesr): This should be DROP_EVENT, but in cases where we fail
         // to properly sync scrollability it's safer to send the event to the
         // main thread. Change back to DROP_EVENT once we have synchronization
         // bugs sorted out.
         result = DID_NOT_HANDLE;
         break;
       case cc::InputHandler::SCROLL_UNKNOWN:
       case cc::InputHandler::SCROLL_ON_MAIN_THREAD:
         result = DID_NOT_HANDLE;
         break;
-      case cc::InputHandler::ScrollStatusCount:
-        NOTREACHED();
-        break;
     }
   }
 
   // Send the event and its disposition to the elasticity controller to update
   // the over-scroll animation. If the event is to be handled on the main
   // thread, the event and its disposition will be sent to the elasticity
   // controller after being handled on the main thread.
   if (scroll_elasticity_controller_ && result != DID_NOT_HANDLE) {
     // Note that the call to the elasticity controller is made asynchronously,
     // to minimize divergence between main thread and impl thread event
@@ skipping 15 matching lines @@
 #ifndef NDEBUG
   DCHECK(!expect_scroll_update_end_);
   expect_scroll_update_end_ = true;
 #endif
   cc::ScrollState scroll_state = CreateScrollStateForGesture(gesture_event);
   cc::InputHandler::ScrollStatus scroll_status;
   if (gesture_event.data.scrollBegin.deltaHintUnits ==
       blink::WebGestureEvent::ScrollUnits::Page) {
     scroll_status.thread = cc::InputHandler::SCROLL_ON_MAIN_THREAD;
     scroll_status.main_thread_scrolling_reasons =
-          cc::InputHandler::CONTINUING_MAIN_THREAD_SCROLL;
+        cc::MainThreadScrollingReason::kContinuingMainThreadScroll;
   } else if (gesture_event.data.scrollBegin.targetViewport) {
     scroll_status = input_handler_->RootScrollBegin(&scroll_state,
                                                     cc::InputHandler::GESTURE);
   } else if (smooth_scroll_enabled_ &&
              gesture_event.data.scrollBegin.deltaHintUnits ==
                  blink::WebGestureEvent::ScrollUnits::Pixels) {
     gfx::Vector2dF scroll_delta(-gesture_event.data.scrollBegin.deltaXHint,
                                 -gesture_event.data.scrollBegin.deltaYHint);
     scroll_status = input_handler_->ScrollAnimated(
         gfx::Point(gesture_event.x, gesture_event.y), scroll_delta);
   } else {
     scroll_status =
         input_handler_->ScrollBegin(&scroll_state, cc::InputHandler::GESTURE);
   }
   UMA_HISTOGRAM_ENUMERATION("Renderer4.CompositorScrollHitTestResult",
                             scroll_status.thread,
-                            cc::InputHandler::ScrollStatusCount);
+                            cc::InputHandler::LAST_SCROLL_STATUS + 1);
 
   RecordMainThreadScrollingReasons(gesture_event.type,
                                    scroll_status.main_thread_scrolling_reasons);
 
   switch (scroll_status.thread) {
     case cc::InputHandler::SCROLL_ON_IMPL_THREAD:
       TRACE_EVENT_INSTANT0("input",
                            "InputHandlerProxy::handle_input gesture scroll",
                            TRACE_EVENT_SCOPE_THREAD);
       gesture_scroll_on_impl_thread_ = true;
       return DID_HANDLE;
     case cc::InputHandler::SCROLL_UNKNOWN:
     case cc::InputHandler::SCROLL_ON_MAIN_THREAD:
       return DID_NOT_HANDLE;
     case cc::InputHandler::SCROLL_IGNORED:
       return DROP_EVENT;
-    case cc::InputHandler::ScrollStatusCount:
-      NOTREACHED();
-      break;
   }
   return DID_NOT_HANDLE;
 }
 
 InputHandlerProxy::EventDisposition
 InputHandlerProxy::HandleGestureScrollUpdate(
   const WebGestureEvent& gesture_event) {
 #ifndef NDEBUG
   DCHECK(expect_scroll_update_end_);
 #endif
@@ skipping 36 matching lines @@
     return DID_NOT_HANDLE;
   gesture_scroll_on_impl_thread_ = false;
   return DID_HANDLE;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureFlingStart(
     const WebGestureEvent& gesture_event) {
   cc::ScrollState scroll_state = CreateScrollStateForGesture(gesture_event);
   cc::InputHandler::ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
-      cc::InputHandler::NOT_SCROLLING_ON_MAIN;
+      cc::MainThreadScrollingReason::kNotScrollingOnMain;
   switch (gesture_event.sourceDevice) {
   case blink::WebGestureDeviceTouchpad:
     if (gesture_event.data.flingStart.targetViewport) {
       scroll_status = input_handler_->RootScrollBegin(
           &scroll_state, cc::InputHandler::NON_BUBBLING_GESTURE);
     } else {
       scroll_status = input_handler_->ScrollBegin(
           &scroll_state, cc::InputHandler::NON_BUBBLING_GESTURE);
     }
     break;
   case blink::WebGestureDeviceTouchscreen:
     if (!gesture_scroll_on_impl_thread_) {
       scroll_status.thread = cc::InputHandler::SCROLL_ON_MAIN_THREAD;
       scroll_status.main_thread_scrolling_reasons =
-          cc::InputHandler::CONTINUING_MAIN_THREAD_SCROLL;
+          cc::MainThreadScrollingReason::kContinuingMainThreadScroll;
     } else {
       scroll_status = input_handler_->FlingScrollBegin();
     }
     break;
   case blink::WebGestureDeviceUninitialized:
     NOTREACHED();
     return DID_NOT_HANDLE;
   }
 
 #ifndef NDEBUG
@@ skipping 50 matching lines @@
           TRACE_EVENT_SCOPE_THREAD);
       gesture_scroll_on_impl_thread_ = false;
       if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad) {
         // We still pass the curve to the main thread if there's nothing
         // scrollable, in case something
         // registers a handler before the curve is over.
         return DID_NOT_HANDLE;
       }
       return DROP_EVENT;
     }
-    case cc::InputHandler::ScrollStatusCount:
-      NOTREACHED();
-      break;
   }
   return DID_NOT_HANDLE;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleTouchStart(
     const blink::WebTouchEvent& touch_event) {
   for (size_t i = 0; i < touch_event.touchesLength; ++i) {
     if (touch_event.touches[i].state != WebTouchPoint::StatePressed)
       continue;
     if (input_handler_->DoTouchEventsBlockScrollAt(
@@ skipping 443 matching lines @@
   // trigger a scroll, e.g., with a trivial time delta between fling updates.
   // Return true in this case to prevent early fling termination.
   if (std::abs(clipped_increment.width) < kScrollEpsilon &&
       std::abs(clipped_increment.height) < kScrollEpsilon)
     return true;
 
   return did_scroll;
 }
 
 }  // namespace ui