cc: Fix enum style conformance in InputHandler.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 18 matching lines @@
 #include "cc/animation/timing_function.h"
 #include "cc/base/histograms.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/debug/debug_rect_history.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/frame_rate_counter.h"
 #include "cc/debug/frame_viewer_instrumentation.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/debug/traced_value.h"
+#include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/input/page_scale_animation.h"
 #include "cc/input/scroll_elasticity_helper.h"
 #include "cc/input/scroll_state.h"
 #include "cc/input/top_controls_manager.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/render_surface_impl.h"
@@ skipping 492 matching lines @@
   if (!scrolling_layer_impl)
     return false;
 
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
 
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
 
   bool scroll_on_main_thread = false;
-  InputHandler::MainThreadScrollingReason main_thread_scrolling_reasons;
+  uint32_t main_thread_scrolling_reasons;
   LayerImpl* test_layer_impl = FindScrollLayerForDeviceViewportPoint(
       device_viewport_point, type, layer_impl, &scroll_on_main_thread, nullptr,
       &main_thread_scrolling_reasons);
 
   if (!test_layer_impl)
     return false;
 
   if (scrolling_layer_impl == test_layer_impl)
     return true;
 
@@ skipping 1910 matching lines @@
   DCHECK(input_handler_client_ == NULL);
   input_handler_client_ = client;
 }
 
 LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
     const gfx::PointF& device_viewport_point,
     InputHandler::ScrollInputType type,
     LayerImpl* layer_impl,
     bool* scroll_on_main_thread,
     bool* optional_has_ancestor_scroll_handler,
-    InputHandler::MainThreadScrollingReason* main_thread_scrolling_reasons)
-    const {
+    uint32_t* main_thread_scrolling_reasons) const {
   DCHECK(scroll_on_main_thread);
   DCHECK(main_thread_scrolling_reasons);
-  *main_thread_scrolling_reasons = InputHandler::NOT_SCROLLING_ON_MAIN;
+  *main_thread_scrolling_reasons =
+      MainThreadScrollingReason::kNotScrollingOnMain;
 
   ScrollBlocksOn block_mode = EffectiveScrollBlocksOn(layer_impl);
 
   // Walk up the hierarchy and look for a scrollable layer.
   LayerImpl* potentially_scrolling_layer_impl = NULL;
   for (; layer_impl; layer_impl = NextLayerInScrollOrder(layer_impl)) {
     // The content layer can also block attempts to scroll outside the main
     // thread.
     ScrollStatus status =
         layer_impl->TryScroll(device_viewport_point, type, block_mode);
     if (status.thread == SCROLL_ON_MAIN_THREAD) {
       if (layer_impl->should_scroll_on_main_thread()) {
-        DCHECK(status.main_thread_scrolling_reasons <=
-               InputHandler::MaxNonTransientScrollingReason);
+        DCHECK_LE(status.main_thread_scrolling_reasons,
+                  MainThreadScrollingReason::kMaxNonTransientScrollingReason);
       } else {
-        DCHECK(status.main_thread_scrolling_reasons >
-               InputHandler::MaxNonTransientScrollingReason);
+        DCHECK_GT(status.main_thread_scrolling_reasons,
+                  MainThreadScrollingReason::kMaxNonTransientScrollingReason);
       }
 
       *scroll_on_main_thread = true;
       *main_thread_scrolling_reasons = status.main_thread_scrolling_reasons;
       return NULL;
     }
 
     LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
     if (!scroll_layer_impl)
       continue;
 
     status =
         scroll_layer_impl->TryScroll(device_viewport_point, type, block_mode);
 
     // If any layer wants to divert the scroll event to the main thread, abort.
     if (status.thread == SCROLL_ON_MAIN_THREAD) {
       if (layer_impl->should_scroll_on_main_thread()) {
-        DCHECK(status.main_thread_scrolling_reasons <=
-               InputHandler::MaxNonTransientScrollingReason);
+        DCHECK_LE(status.main_thread_scrolling_reasons,
+                  MainThreadScrollingReason::kMaxNonTransientScrollingReason);
       } else {
-        DCHECK(status.main_thread_scrolling_reasons >
-               InputHandler::MaxNonTransientScrollingReason);
+        DCHECK_GT(status.main_thread_scrolling_reasons,
+                  MainThreadScrollingReason::kMaxNonTransientScrollingReason);
       }
 
       *scroll_on_main_thread = true;
       *main_thread_scrolling_reasons = status.main_thread_scrolling_reasons;
       return NULL;
     }
 
     if (optional_has_ancestor_scroll_handler &&
         scroll_layer_impl->have_scroll_event_handlers())
       *optional_has_ancestor_scroll_handler = true;
@@ skipping 38 matching lines @@
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBeginImpl(
     ScrollState* scroll_state,
     LayerImpl* scrolling_layer_impl,
     InputHandler::ScrollInputType type) {
   DCHECK(scroll_state);
   DCHECK(scroll_state->delta_x() == 0 && scroll_state->delta_y() == 0);
 
   InputHandler::ScrollStatus scroll_status;
-  scroll_status.main_thread_scrolling_reasons = NOT_SCROLLING_ON_MAIN;
+  scroll_status.main_thread_scrolling_reasons =
+      MainThreadScrollingReason::kNotScrollingOnMain;
   if (!scrolling_layer_impl) {
     scroll_status.thread = SCROLL_IGNORED;
-    scroll_status.main_thread_scrolling_reasons = NO_SCROLLING_LAYER;
+    scroll_status.main_thread_scrolling_reasons =
+        MainThreadScrollingReason::kNoScrollingLayer;
     return scroll_status;
   }
   scroll_status.thread = SCROLL_ON_IMPL_THREAD;
   ScrollAnimationAbort(scrolling_layer_impl);
 
   top_controls_manager_->ScrollBegin();
 
   active_tree_->SetCurrentlyScrollingLayer(scrolling_layer_impl);
   // TODO(majidvp): get rid of wheel_scrolling_ and set is_direct_manipulation
   // in input_handler_proxy instead.
@@ skipping 19 matching lines @@
 
   ClearCurrentlyScrollingLayer();
 
   return ScrollBeginImpl(scroll_state, InnerViewportScrollLayer(), type);
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
     ScrollState* scroll_state,
     InputHandler::ScrollInputType type) {
   ScrollStatus scroll_status;
-  scroll_status.main_thread_scrolling_reasons = NOT_SCROLLING_ON_MAIN;
+  scroll_status.main_thread_scrolling_reasons =
+      MainThreadScrollingReason::kNotScrollingOnMain;
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
 
   ClearCurrentlyScrollingLayer();
 
   gfx::Point viewport_point(scroll_state->start_position_x(),
                             scroll_state->start_position_y());
 
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
 
   if (layer_impl) {
     LayerImpl* scroll_layer_impl =
         active_tree_->FindFirstScrollingLayerThatIsHitByPoint(
             device_viewport_point);
     if (scroll_layer_impl &&
         !HasScrollAncestor(layer_impl, scroll_layer_impl)) {
       scroll_status.thread = SCROLL_UNKNOWN;
       scroll_status.main_thread_scrolling_reasons =
-          InputHandler::FAILED_HIT_TEST;
+          MainThreadScrollingReason::kFailedHitTest;
       return scroll_status;
     }
   }
 
   bool scroll_on_main_thread = false;
   LayerImpl* scrolling_layer_impl = FindScrollLayerForDeviceViewportPoint(
       device_viewport_point, type, layer_impl, &scroll_on_main_thread,
       &scroll_affects_scroll_handler_,
       &scroll_status.main_thread_scrolling_reasons);
 
   if (scroll_on_main_thread) {
     RecordCompositorSlowScrollMetric(type, MAIN_THREAD);
 
     // TODO(lanwei): Will remove this metric in M50 when we have used the new
     // metrics for one milestone, see https://crbug.com/557787.
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
     scroll_status.thread = SCROLL_ON_MAIN_THREAD;
     return scroll_status;
   }
 
   return ScrollBeginImpl(scroll_state, scrolling_layer_impl, type);
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollAnimated(
     const gfx::Point& viewport_point,
     const gfx::Vector2dF& scroll_delta) {
   InputHandler::ScrollStatus scroll_status;
-  scroll_status.main_thread_scrolling_reasons = NOT_SCROLLING_ON_MAIN;
+  scroll_status.main_thread_scrolling_reasons =
+      MainThreadScrollingReason::kNotScrollingOnMain;
   if (LayerImpl* layer_impl = CurrentlyScrollingLayer()) {
     if (ScrollAnimationUpdateTarget(layer_impl, scroll_delta)) {
       scroll_status.thread = SCROLL_ON_IMPL_THREAD;
     } else {
       scroll_status.thread = SCROLL_IGNORED;
-      scroll_status.main_thread_scrolling_reasons = NOT_SCROLLABLE;
+      scroll_status.main_thread_scrolling_reasons =
+          MainThreadScrollingReason::kNotScrollable;
     }
     return scroll_status;
   }
 
   ScrollState scroll_state(0, 0, viewport_point.x(), viewport_point.y(), 0, 0,
                            false, true, false);
   // ScrollAnimated is used for animated wheel scrolls. We find the first layer
   // that can scroll and set up an animation of its scroll offset. Note that
   // this does not currently go through the scroll customization and viewport
   // machinery that ScrollBy uses for non-animated wheel scrolls.
@@ skipping 354 matching lines @@
   DCHECK(scroll_state->delta_x() == 0 && scroll_state->delta_y() == 0);
 
   DistributeScrollDelta(scroll_state);
   top_controls_manager_->ScrollEnd();
   ClearCurrentlyScrollingLayer();
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
   InputHandler::ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
-      InputHandler::NOT_SCROLLING_ON_MAIN;
+      MainThreadScrollingReason::kNotScrollingOnMain;
   if (!CurrentlyScrollingLayer()) {
     scroll_status.thread = SCROLL_IGNORED;
-    scroll_status.main_thread_scrolling_reasons = NO_SCROLLING_LAYER;
+    scroll_status.main_thread_scrolling_reasons =
+        MainThreadScrollingReason::kNoScrollingLayer;
   } else {
     scroll_status.thread = SCROLL_ON_IMPL_THREAD;
   }
   return scroll_status;
 }
 
 float LayerTreeHostImpl::DeviceSpaceDistanceToLayer(
     const gfx::PointF& device_viewport_point,
     LayerImpl* layer_impl) {
   if (!layer_impl)
@@ skipping 11 matching lines @@
 void LayerTreeHostImpl::MouseMoveAt(const gfx::Point& viewport_point) {
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
   HandleMouseOverScrollbar(layer_impl);
   if (scroll_layer_id_when_mouse_over_scrollbar_ != Layer::INVALID_ID)
     return;
 
   bool scroll_on_main_thread = false;
-  InputHandler::MainThreadScrollingReason main_thread_scrolling_reasons;
+  uint32_t main_thread_scrolling_reasons;
   LayerImpl* scroll_layer_impl = FindScrollLayerForDeviceViewportPoint(
       device_viewport_point, InputHandler::GESTURE, layer_impl,
       &scroll_on_main_thread, NULL, &main_thread_scrolling_reasons);
   if (scroll_layer_impl == InnerViewportScrollLayer())
     scroll_layer_impl = OuterViewportScrollLayer();
   if (scroll_on_main_thread || !scroll_layer_impl)
     return;
 
   ScrollbarAnimationController* animation_controller =
       ScrollbarAnimationControllerForId(scroll_layer_impl->id());
@@ skipping 792 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc