Use proper integer constants instead of enums

ui/events/gesture_detection/velocity_tracker.cc

 // Copyright 2014 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/gesture_detection/velocity_tracker.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "ui/events/gesture_detection/motion_event.h"
@@ skipping 33 matching lines @@
 // determining that a pointer has stopped moving. This is a larger threshold
 // than |kAssumePointerMoveStoppedTimeMs|, as some devices may delay synthesis
 // of ACTION_{UP|POINTER_UP} to reduce risk of noisy release.
 const int kAssumePointerUpStoppedTimeMs = 80;
 
 struct Position {
   float x, y;
 };
 
 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.
   uint32_t degree;
 
   // Confidence (coefficient of determination), between 0 (no fit)
   // and 1 (perfect fit).
   float confidence;
 
   inline void Clear() {
     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;
     }
   }
 };
 
 float VectorDot(const float* a, const float* b, uint32_t m) {
   float r = 0;
   while (m--) {
     r += *(a++) * *(b++);
@@ skipping 22 matching lines @@
 
     // Weight such that points within a certain horizon are weighed more than
     // those outside of that horizon.
     WEIGHTING_CENTRAL,
 
     // Weight such that points older than a certain amount are weighed less.
     WEIGHTING_RECENT,
   };
 
   // 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();
 
   virtual void Clear() override;
   virtual void ClearPointers(BitSet32 id_bits) override;
   virtual void AddMovement(const TimeTicks& event_time,
                            BitSet32 id_bits,
                            const Position* positions) override;
   virtual bool GetEstimator(uint32_t id,
                             Estimator* out_estimator) const override;
 
  private:
   // 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;
     BitSet32 id_bits;
     Position positions[VelocityTracker::MAX_POINTERS];
 
     inline const Position& GetPosition(uint32_t id) const {
       return positions[id_bits.get_index_of_bit(id)];
     }
   };
 
   float ChooseWeight(uint32_t index) const;
 
   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.
 class IntegratingVelocityTrackerStrategy : public VelocityTrackerStrategy {
  public:
   // Degree must be 1 or 2.
   explicit IntegratingVelocityTrackerStrategy(uint32_t degree);
   virtual ~IntegratingVelocityTrackerStrategy();
 
   virtual void Clear() override;
@@ skipping 200 matching lines @@
   }
   *out_vx = 0;
   *out_vy = 0;
   return false;
 }
 
 void LeastSquaresVelocityTrackerStrategy::AddMovement(
     const TimeTicks& event_time,
     BitSet32 id_bits,
     const Position* positions) {
-  if (++index_ == HISTORY_SIZE) {
+  if (++index_ == kHistorySize) {
     index_ = 0;
   }
 
   Movement& movement = movements_[index_];
   movement.event_time = event_time;
   movement.id_bits = id_bits;
   uint32_t count = id_bits.count();
   for (uint32_t i = 0; i < count; i++) {
     movement.positions[i] = positions[i];
   }
 }
 
 bool VelocityTracker::GetEstimator(uint32_t id,
                                    Estimator* out_estimator) const {
   return strategy_->GetEstimator(id, out_estimator);
 }
 
 // --- LeastSquaresVelocityTrackerStrategy ---
 
 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();
 }
 
 LeastSquaresVelocityTrackerStrategy::~LeastSquaresVelocityTrackerStrategy() {}
 
 void LeastSquaresVelocityTrackerStrategy::Clear() {
   index_ = 0;
   movements_[0].id_bits.clear();
 }
 
@@ skipping 53 matching lines @@
 static bool SolveLeastSquares(const float* x,
                               const float* y,
                               const float* w,
                               uint32_t m,
                               uint32_t n,
                               float* out_b,
                               float* out_det) {
   // 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;
 #endif
 
   // Expand the X vector to a matrix A, pre-multiplied by the weights.
   float a[N_ARRAY_LENGTH][M_ARRAY_LENGTH];  // column-major order
   for (uint32_t h = 0; h < m; h++) {
     a[0][h] = w[h];
     for (uint32_t i = 1; i < n; i++) {
@@ skipping 78 matching lines @@
   BitSet32 remaining_id_bits(movements_[index_].id_bits.value & ~id_bits.value);
   movements_[index_].id_bits = remaining_id_bits;
 }
 
 bool LeastSquaresVelocityTrackerStrategy::GetEstimator(
     uint32_t id,
     Estimator* out_estimator) const {
   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];
     if (!movement.id_bits.has_bit(id))
       break;
 
     TimeDelta age = newest_movement.event_time - movement.event_time;
     if (age > horizon)
       break;
 
     const Position& position = movement.GetPosition(id);
     x[m] = position.x;
     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
 
   // Calculate a least squares polynomial fit.
   uint32_t degree = degree_;
   if (degree > m - 1)
     degree = m - 1;
 
   if (degree >= 1) {
@@ skipping 21 matching lines @@
 float LeastSquaresVelocityTrackerStrategy::ChooseWeight(uint32_t index) const {
   switch (weighting_) {
     case WEIGHTING_DELTA: {
       // Weight points based on how much time elapsed between them and the next
       // point so that points that "cover" a shorter time span are weighed less.
       //   delta  0ms: 0.5
       //   delta 10ms: 1.0
       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());
       if (delta_millis < 0)
         return 0.5f;
       if (delta_millis < 10)
         return 0.5f + delta_millis * 0.05;
 
       return 1.0f;
     }
@@ skipping 41 matching lines @@
     default:
       return 1.0f;
   }
 }
 
 // --- IntegratingVelocityTrackerStrategy ---
 
 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() {}
 
 void IntegratingVelocityTrackerStrategy::Clear() { pointer_id_bits_.clear(); }
 
 void IntegratingVelocityTrackerStrategy::ClearPointers(BitSet32 id_bits) {
   pointer_id_bits_.value &= ~id_bits.value;
 }
 
@@ skipping 95 matching lines @@
   out_estimator->degree = state.degree;
   out_estimator->xcoeff[0] = state.xpos;
   out_estimator->xcoeff[1] = state.xvel;
   out_estimator->xcoeff[2] = state.xaccel / 2;
   out_estimator->ycoeff[0] = state.ypos;
   out_estimator->ycoeff[1] = state.yvel;
   out_estimator->ycoeff[2] = state.yaccel / 2;
 }
 
 }  // namespace ui