Remove static-initializeres from VelocityTracker

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 16 matching lines @@
   virtual bool GetEstimator(uint32_t id, Estimator* out_estimator) const = 0;
 
  protected:
   VelocityTrackerStrategy() {}
 };
 
 namespace {
 
 COMPILE_ASSERT(MotionEvent::MAX_POINTER_ID < 32, max_pointer_id_too_large);
 
+// Threshold for determining that a pointer has stopped moving.
+// Some input devices do not send ACTION_MOVE events in the case where a pointer
+// has stopped.  We need to detect this case so that we can accurately predict
+// the velocity after the pointer starts moving again.
+const int kAssumePointerStoppedTimeMs = 40;
+
 struct Position {
   float x, y;
 };
 
 struct Estimator {
   enum { MAX_DEGREE = 4 };
 
   // Estimator time base.
   TimeTicks time;
 
@@ skipping 12 matching lines @@
     time = TimeTicks();
     degree = 0;
     confidence = 0;
     for (size_t i = 0; i <= MAX_DEGREE; i++) {
       xcoeff[i] = 0;
       ycoeff[i] = 0;
     }
   }
 };
 
-// Threshold for determining that a pointer has stopped moving.
-// Some input devices do not send ACTION_MOVE events in the case where a pointer
-// hasstopped.  We need to detect this case so that we can accurately predict
-// the velocity after the pointer starts moving again.
-const TimeDelta ASSUME_POINTER_STOPPED_TIME = TimeDelta::FromMilliseconds(40);
-
-static float VectorDot(const float* a, const float* b, uint32_t m) {
+float VectorDot(const float* a, const float* b, uint32_t m) {
   float r = 0;
   while (m--) {
     r += *(a++) * *(b++);
   }
   return r;
 }
 
-static float VectorNorm(const float* a, uint32_t m) {
+float VectorNorm(const float* a, uint32_t m) {
   float r = 0;
   while (m--) {
     float t = *(a++);
     r += t * t;
   }
   return sqrtf(r);
 }
 
 // Velocity tracker algorithm based on least-squares linear regression.
 class LeastSquaresVelocityTrackerStrategy : public VelocityTrackerStrategy {
@@ skipping 26 matching lines @@
   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.
-  static const TimeDelta HORIZON;
+  enum { HORIZON_MS = 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)];
     }
   };
@@ skipping 107 matching lines @@
   strategy_->ClearPointers(id_bits);
 }
 
 void VelocityTracker::AddMovement(const TimeTicks& event_time,
                                   BitSet32 id_bits,
                                   const Position* positions) {
   while (id_bits.count() > MAX_POINTERS)
     id_bits.clear_last_marked_bit();
 
   if ((current_pointer_id_bits_.value & id_bits.value) &&
-      event_time >= (last_event_time_ + ASSUME_POINTER_STOPPED_TIME)) {
+      event_time >= (last_event_time_ + base::TimeDelta::FromMilliseconds(
+                                            kAssumePointerStoppedTimeMs))) {
     // We have not received any movements for too long.  Assume that all
     // pointers
     // have stopped.
     strategy_->Clear();
   }
   last_event_time_ = event_time;
 
   current_pointer_id_bits_ = id_bits;
   if (active_pointer_id_ < 0 || !id_bits.has_bit(active_pointer_id_))
     active_pointer_id_ = id_bits.is_empty() ? -1 : id_bits.first_marked_bit();
@@ skipping 101 matching lines @@
   }
 }
 
 bool VelocityTracker::GetEstimator(uint32_t id,
                                    Estimator* out_estimator) const {
   return strategy_->GetEstimator(id, out_estimator);
 }
 
 // --- LeastSquaresVelocityTrackerStrategy ---
 
-const TimeDelta LeastSquaresVelocityTrackerStrategy::HORIZON =
-    TimeDelta::FromMilliseconds(100);
-
 LeastSquaresVelocityTrackerStrategy::LeastSquaresVelocityTrackerStrategy(
     uint32_t degree,
     Weighting weighting)
     : degree_(degree), weighting_(weighting) {
   DCHECK_LT(degree_, static_cast<uint32_t>(Estimator::MAX_DEGREE));
   Clear();
 }
 
 LeastSquaresVelocityTrackerStrategy::~LeastSquaresVelocityTrackerStrategy() {}
 
@@ skipping 168 matching lines @@
     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];
   uint32_t m = 0;
   uint32_t index = index_;
+  const base::TimeDelta horizon = base::TimeDelta::FromMilliseconds(HORIZON_MS);
   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)
+    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);
 
@@ skipping 208 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