Use proper integer constants instead of enums

-Wtype-limits will throw warnings if an enum is used interchangably
with an integer. Replace some such usages with proper integer
constants.

BUG=424334
TEST=build, unit test

Review URL: https://codereview.chromium.org/662893002

Cr-Commit-Position: refs/heads/master@{#300376}

ui/events/gesture_detection/velocity_tracker.cc

@@ -51,13 +51,13 @@ struct Position {
 };
 
 struct Estimator {
-  enum { MAX_DEGREE = 4 };
+  static const uint8_t kMaxDegree = 4;
 
   // Estimator time base.
   TimeTicks time;
 
   // Polynomial coefficients describing motion in X and Y.
-  float xcoeff[MAX_DEGREE + 1], ycoeff[MAX_DEGREE + 1];
+  float xcoeff[kMaxDegree + 1], ycoeff[kMaxDegree + 1];
 
   // Polynomial degree (number of coefficients), or zero if no information is
   // available.
@@ -71,7 +71,7 @@ struct Estimator {
     time = TimeTicks();
     degree = 0;
     confidence = 0;
-    for (size_t i = 0; i <= MAX_DEGREE; i++) {
+    for (size_t i = 0; i <= kMaxDegree; i++) {
       xcoeff[i] = 0;
       ycoeff[i] = 0;
     }
@@ -114,9 +114,9 @@ class LeastSquaresVelocityTrackerStrategy : public VelocityTrackerStrategy {
   };
 
   // Number of samples to keep.
-  enum { HISTORY_SIZE = 20 };
+  static const uint8_t kHistorySize = 20;
 
-  // Degree must be no greater than Estimator::MAX_DEGREE.
+  // Degree must be no greater than Estimator::kMaxDegree.
   LeastSquaresVelocityTrackerStrategy(uint32_t degree,
                                       Weighting weighting = WEIGHTING_NONE);
   virtual ~LeastSquaresVelocityTrackerStrategy();
@@ -133,7 +133,7 @@ class LeastSquaresVelocityTrackerStrategy : public VelocityTrackerStrategy {
   // Sample horizon.
   // We don't use too much history by default since we want to react to quick
   // changes in direction.
-  enum { HORIZON_MS = 100 };
+  static const uint8_t kHorizonMS = 100;
 
   struct Movement {
     TimeTicks event_time;
@@ -150,7 +150,7 @@ class LeastSquaresVelocityTrackerStrategy : public VelocityTrackerStrategy {
   const uint32_t degree_;
   const Weighting weighting_;
   uint32_t index_;
-  Movement movements_[HISTORY_SIZE];
+  Movement movements_[kHistorySize];
 };
 
 // Velocity tracker algorithm that uses an IIR filter.
@@ -371,7 +371,7 @@ void LeastSquaresVelocityTrackerStrategy::AddMovement(
     const TimeTicks& event_time,
     BitSet32 id_bits,
     const Position* positions) {
-  if (++index_ == HISTORY_SIZE) {
+  if (++index_ == kHistorySize) {
     index_ = 0;
   }
 
@@ -395,7 +395,7 @@ LeastSquaresVelocityTrackerStrategy::LeastSquaresVelocityTrackerStrategy(
     uint32_t degree,
     Weighting weighting)
     : degree_(degree), weighting_(weighting) {
-  DCHECK_LT(degree_, static_cast<uint32_t>(Estimator::MAX_DEGREE));
+  DCHECK_LT(degree_, static_cast<uint32_t>(Estimator::kMaxDegree));
   Clear();
 }
 
@@ -469,12 +469,11 @@ static bool SolveLeastSquares(const float* x,
   // MSVC does not support variable-length arrays (used by the original Android
   // implementation of this function).
 #if defined(COMPILER_MSVC)
-  enum {
-    M_ARRAY_LENGTH = LeastSquaresVelocityTrackerStrategy::HISTORY_SIZE,
-    N_ARRAY_LENGTH = Estimator::MAX_DEGREE
-  };
-  DCHECK_LE(m, static_cast<uint32_t>(M_ARRAY_LENGTH));
-  DCHECK_LE(n, static_cast<uint32_t>(N_ARRAY_LENGTH));
+  const uint32_t M_ARRAY_LENGTH =
+      LeastSquaresVelocityTrackerStrategy::kHistorySize;
+  const uint32_t N_ARRAY_LENGTH = Estimator::kMaxDegree;
+  DCHECK_LE(m, M_ARRAY_LENGTH);
+  DCHECK_LE(n, N_ARRAY_LENGTH);
 #else
   const uint32_t M_ARRAY_LENGTH = m;
   const uint32_t N_ARRAY_LENGTH = n;
@@ -573,13 +572,13 @@ bool LeastSquaresVelocityTrackerStrategy::GetEstimator(
   out_estimator->Clear();
 
   // Iterate over movement samples in reverse time order and collect samples.
-  float x[HISTORY_SIZE];
-  float y[HISTORY_SIZE];
-  float w[HISTORY_SIZE];
-  float time[HISTORY_SIZE];
+  float x[kHistorySize];
+  float y[kHistorySize];
+  float w[kHistorySize];
+  float time[kHistorySize];
   uint32_t m = 0;
   uint32_t index = index_;
-  const base::TimeDelta horizon = base::TimeDelta::FromMilliseconds(HORIZON_MS);
+  const base::TimeDelta horizon = base::TimeDelta::FromMilliseconds(kHorizonMS);
   const Movement& newest_movement = movements_[index_];
   do {
     const Movement& movement = movements_[index];
@@ -595,8 +594,8 @@ bool LeastSquaresVelocityTrackerStrategy::GetEstimator(
     y[m] = position.y;
     w[m] = ChooseWeight(index);
     time[m] = -age.InSecondsF();
-    index = (index == 0 ? HISTORY_SIZE : index) - 1;
-  } while (++m < HISTORY_SIZE);
+    index = (index == 0 ? kHistorySize : index) - 1;
+  } while (++m < kHistorySize);
 
   if (m == 0)
     return false;  // no data
@@ -638,7 +637,7 @@ float LeastSquaresVelocityTrackerStrategy::ChooseWeight(uint32_t index) const {
       if (index == index_) {
         return 1.0f;
       }
-      uint32_t next_index = (index + 1) % HISTORY_SIZE;
+      uint32_t next_index = (index + 1) % kHistorySize;
       float delta_millis =
           static_cast<float>((movements_[next_index].event_time -
                               movements_[index].event_time).InMillisecondsF());
@@ -700,7 +699,7 @@ float LeastSquaresVelocityTrackerStrategy::ChooseWeight(uint32_t index) const {
 IntegratingVelocityTrackerStrategy::IntegratingVelocityTrackerStrategy(
     uint32_t degree)
     : degree_(degree) {
-  DCHECK_LT(degree_, static_cast<uint32_t>(Estimator::MAX_DEGREE));
+  DCHECK_LT(degree_, static_cast<uint32_t>(Estimator::kMaxDegree));
 }
 
 IntegratingVelocityTrackerStrategy::~IntegratingVelocityTrackerStrategy() {}