Change SkTime::GetMSecs to double; ensure values stored in SkMSec do not overflow.

gm/SkAnimTimer.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTime.h"
 
 #ifndef SkAnimTimer_DEFINED
@@ skipping 11 matching lines @@
 public:
     enum State {
         kStopped_State,
         kPaused_State,
         kRunning_State
     };
 
     /**
      *  Class begins in the "stopped" state.
      */
-    SkAnimTimer() : fBaseTime(0), fCurrTime(0), fState(kStopped_State) {}
+    SkAnimTimer() : fBaseTimeNanos(0), fCurrTimeNanos(0), fState(kStopped_State) {}
 
     bool isStopped() const { return kStopped_State == fState; }
     bool isRunning() const { return kRunning_State == fState; }
     bool isPaused() const { return kPaused_State == fState; }
 
     /**
      *  Stops the timer, and resets it, such that the next call to run or togglePauseResume
      *  will begin at time 0.
      */
     void stop() {
@@ skipping 20 matching lines @@
 
     /**
      *  Call this each time you want to sample the clock for the timer. This is NOT done
      *  automatically, so that repeated calls to msec() or secs() will always return the
      *  same value.
      *
      *  This may safely be called with the timer in any state.
      */
     void updateTime() {
         if (kRunning_State == fState) {
-            fCurrTime = SkTime::GetMSecs();
+            fCurrTimeNanos = SkTime::GetNSecs();
         }
     }
 
     /**
      *  Return the time in milliseconds the timer has been in the running state.
-     *  Returns 0 if the timer is stopped.
+     *  Returns 0 if the timer is stopped. Behavior is undefined if the timer
+     *  has been running longer than SK_MSecMax.
      */
-    SkMSec msec() const { return fCurrTime - fBaseTime; }
+    SkMSec msec() const {
+        const double msec = (fCurrTimeNanos - fBaseTimeNanos) * 1e-6;
+        SkASSERT(SK_MSecMax >= msec);
+        return static_cast<SkMSec>(msec);
+    }
 
     /**
      *  Return the time in seconds the timer has been in the running state.
      *  Returns 0 if the timer is stopped.
      */
-    double secs() const {
-        return this->msec() * 0.001;
-    }
+    double secs() const { return (fCurrTimeNanos - fBaseTimeNanos) * 1e-9; }
 
     /**
      *  Return the time in seconds the timer has been in the running state,
      *  scaled by "speed" and (if not zero) mod by period.
      *  Returns 0 if the timer is stopped.
      */
     SkScalar scaled(SkScalar speed, SkScalar period = 0) const {
         double value = this->secs() * speed;
         if (period) {
             value = ::fmod(value, SkScalarToDouble(period));
         }
         return SkDoubleToScalar(value);
     }
 
 private:
-    SkMSec  fBaseTime;
-    SkMSec  fCurrTime;
+    double  fBaseTimeNanos;
+    double  fCurrTimeNanos;
     State   fState;
 
     void setState(State newState) {
         switch (newState) {
             case kStopped_State:
-                fBaseTime = fCurrTime = 0;
+                fBaseTimeNanos = fCurrTimeNanos = 0;
                 fState = kStopped_State;
                 break;
             case kPaused_State:
                 if (kRunning_State == fState) {
                     fState = kPaused_State;
                 } // else stay stopped or paused
                 break;
             case kRunning_State:
                 switch (fState) {
                     case kStopped_State:
-                        fBaseTime = fCurrTime = SkTime::GetMSecs();
+                        fBaseTimeNanos = fCurrTimeNanos = SkTime::GetNSecs();
                         break;
                     case kPaused_State: {// they want "resume"
-                        SkMSec now = SkTime::GetMSecs();
-                        fBaseTime += now - fCurrTime;
-                        fCurrTime = now;
+                        double now = SkTime::GetNSecs();
+                        fBaseTimeNanos += now - fCurrTimeNanos;
+                        fCurrTimeNanos = now;
                     } break;
                     case kRunning_State:
                         break;
                 }
                 fState = kRunning_State;
                 break;
         }
     }
 };
 
 #endif