Use std::chrono

3 files changed, 59 insertions, 61 deletions

diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index ff584c54ba..3359dd317f 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -5,7 +5,6 @@
 #include <mbgl/renderer/painter.hpp>
 #include <mbgl/map/sprite.hpp>
 #include <mbgl/util/transition.hpp>
-#include <mbgl/util/time.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/clip_ids.hpp>
 #include <mbgl/util/string.hpp>
@@ -435,13 +434,13 @@ void Map::cancelTransitions() {
 
 #pragma mark - Position
 
-void Map::moveBy(double dx, double dy, double duration) {
-    transform.moveBy(dx, dy, duration * 1_second);
+void Map::moveBy(double dx, double dy, std::chrono::steady_clock::duration duration) {
+    transform.moveBy(dx, dy, duration);
     update();
 }
 
-void Map::setLonLat(double lon, double lat, double duration) {
-    transform.setLonLat(lon, lat, duration * 1_second);
+void Map::setLonLat(double lon, double lat, std::chrono::steady_clock::duration duration) {
+    transform.setLonLat(lon, lat, duration);
     update();
 }
 
@@ -469,13 +468,13 @@ void Map::resetPosition() {
 
 #pragma mark - Scale
 
-void Map::scaleBy(double ds, double cx, double cy, double duration) {
-    transform.scaleBy(ds, cx, cy, duration * 1_second);
+void Map::scaleBy(double ds, double cx, double cy, std::chrono::steady_clock::duration duration) {
+    transform.scaleBy(ds, cx, cy, duration);
     update();
 }
 
-void Map::setScale(double scale, double cx, double cy, double duration) {
-    transform.setScale(scale, cx, cy, duration * 1_second);
+void Map::setScale(double scale, double cx, double cy, std::chrono::steady_clock::duration duration) {
+    transform.setScale(scale, cx, cy, duration);
     update();
 }
 
@@ -483,8 +482,8 @@ double Map::getScale() const {
     return transform.getScale();
 }
 
-void Map::setZoom(double zoom, double duration) {
-    transform.setZoom(zoom, duration * 1_second);
+void Map::setZoom(double zoom, std::chrono::steady_clock::duration duration) {
+    transform.setZoom(zoom, duration);
     update();
 }
 
@@ -492,8 +491,8 @@ double Map::getZoom() const {
     return transform.getZoom();
 }
 
-void Map::setLonLatZoom(double lon, double lat, double zoom, double duration) {
-    transform.setLonLatZoom(lon, lat, zoom, duration * 1_second);
+void Map::setLonLatZoom(double lon, double lat, double zoom, std::chrono::steady_clock::duration duration) {
+    transform.setLonLatZoom(lon, lat, zoom, duration);
     update();
 }
 
@@ -526,13 +525,13 @@ double Map::getMaxZoom() const {
 
 #pragma mark - Rotation
 
-void Map::rotateBy(double sx, double sy, double ex, double ey, double duration) {
-    transform.rotateBy(sx, sy, ex, ey, duration * 1_second);
+void Map::rotateBy(double sx, double sy, double ex, double ey, std::chrono::steady_clock::duration duration) {
+    transform.rotateBy(sx, sy, ex, ey, duration);
     update();
 }
 
-void Map::setBearing(double degrees, double duration) {
-    transform.setAngle(-degrees * M_PI / 180, duration * 1_second);
+void Map::setBearing(double degrees, std::chrono::steady_clock::duration duration) {
+    transform.setAngle(-degrees * M_PI / 180, duration);
     update();
 }
 
@@ -546,7 +545,7 @@ double Map::getBearing() const {
 }
 
 void Map::resetNorth() {
-    transform.setAngle(0, 500_milliseconds);
+    transform.setAngle(0, std::chrono::milliseconds(500));
     update();
 }
 
@@ -618,14 +617,14 @@ std::vector<std::string> Map::getClasses() const {
    return classes;
 }
 
-void Map::setDefaultTransitionDuration(uint64_t milliseconds) {
-    defaultTransitionDuration = milliseconds;
+void Map::setDefaultTransitionDuration(std::chrono::steady_clock::duration duration) {
+    defaultTransitionDuration = duration;
     if (style) {
-        style->setDefaultTransitionDuration(milliseconds);
+        style->setDefaultTransitionDuration(duration);
     }
 }
 
-uint64_t Map::getDefaultTransitionDuration() {
+std::chrono::steady_clock::duration Map::getDefaultTransitionDuration() {
     return defaultTransitionDuration;
 }
 
@@ -704,14 +703,14 @@ void Map::prepare() {
     }
 
     // Update transform transitions.
-    animationTime = util::now();
+    animationTime = std::chrono::steady_clock::now();
     if (transform.needsTransition()) {
         transform.updateTransitions(animationTime);
     }
 
     state = transform.currentState();
 
-    animationTime = util::now();
+    animationTime = std::chrono::steady_clock::now();
     updateSources();
     style->updateProperties(state.getNormalizedZoom(), animationTime);
 
diff --git a/src/mbgl/map/source.hpp b/src/mbgl/map/source.hpp
index 8976f67b05..f0023afa09 100644
--- a/src/mbgl/map/source.hpp
+++ b/src/mbgl/map/source.hpp
@@ -6,7 +6,6 @@
 #include <mbgl/style/style_source.hpp>
 
 #include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/time.hpp>
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/ptr.hpp>
 
@@ -14,6 +13,7 @@
 #include <forward_list>
 #include <iosfwd>
 #include <map>
+#include <chrono>
 
 namespace mbgl {
 
@@ -75,7 +75,7 @@ private:
     bool loaded = false;
 
     // Stores the time when this source was most recently updated.
-    timestamp updated = 0;
+    std::chrono::steady_clock::time_point updated = std::chrono::steady_clock::time_point::min();
 
     std::map<Tile::ID, std::unique_ptr<Tile>> tiles;
     std::map<Tile::ID, std::weak_ptr<TileData>> tile_data;
diff --git a/src/mbgl/map/transform.cpp b/src/mbgl/map/transform.cpp
index bf79d24b5d..7952531192 100644
--- a/src/mbgl/map/transform.cpp
+++ b/src/mbgl/map/transform.cpp
@@ -4,7 +4,6 @@
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/std.hpp>
 #include <mbgl/util/math.hpp>
-#include <mbgl/util/time.hpp>
 #include <mbgl/util/transition.hpp>
 #include <mbgl/platform/platform.hpp>
 
@@ -48,16 +47,16 @@ bool Transform::resize(const uint16_t w, const uint16_t h, const float ratio,
 
 #pragma mark - Position
 
-void Transform::moveBy(const double dx, const double dy, const timestamp duration) {
+void Transform::moveBy(const double dx, const double dy, const std::chrono::steady_clock::duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     _moveBy(dx, dy, duration);
 }
 
-void Transform::_moveBy(const double dx, const double dy, const timestamp duration) {
+void Transform::_moveBy(const double dx, const double dy, const std::chrono::steady_clock::duration duration) {
     // This is only called internally, so we don't need a lock here.
 
-    view.notifyMapChange(duration ?
+    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
                            MapChangeRegionWillChangeAnimated :
                            MapChangeRegionWillChange);
 
@@ -66,25 +65,25 @@ void Transform::_moveBy(const double dx, const double dy, const timestamp durati
 
     constrain(final.scale, final.y);
 
-    if (duration == 0) {
+    if (duration == std::chrono::steady_clock::duration::zero()) {
         current.x = final.x;
         current.y = final.y;
     } else {
         // Use a common start time for all of the transitions to avoid divergent transitions.
-        timestamp start = util::now();
+        std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
         transitions.emplace_front(
             std::make_shared<util::ease_transition<double>>(current.x, final.x, current.x, start, duration));
         transitions.emplace_front(
             std::make_shared<util::ease_transition<double>>(current.y, final.y, current.y, start, duration));
     }
 
-    view.notifyMapChange(duration ?
+    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
                            MapChangeRegionDidChangeAnimated :
                            MapChangeRegionDidChange,
                            duration);
 }
 
-void Transform::setLonLat(const double lon, const double lat, const timestamp duration) {
+void Transform::setLonLat(const double lon, const double lat, const std::chrono::steady_clock::duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     const double f = std::fmin(std::fmax(std::sin(D2R * lat), -0.9999), 0.9999);
@@ -95,7 +94,7 @@ void Transform::setLonLat(const double lon, const double lat, const timestamp du
 }
 
 void Transform::setLonLatZoom(const double lon, const double lat, const double zoom,
-                              const timestamp duration) {
+                              const std::chrono::steady_clock::duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     double new_scale = std::pow(2.0, zoom);
@@ -131,8 +130,8 @@ void Transform::startPanning() {
 
     // Add a 200ms timeout for resetting this to false
     current.panning = true;
-    timestamp start = util::now();
-    pan_timeout = std::make_shared<util::timeout<bool>>(false, current.panning, start, 200_milliseconds);
+    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+    pan_timeout = std::make_shared<util::timeout<bool>>(false, current.panning, start, std::chrono::steady_clock::duration(200));
     transitions.emplace_front(pan_timeout);
 }
 
@@ -152,7 +151,7 @@ void Transform::_clearPanning() {
 
 #pragma mark - Zoom
 
-void Transform::scaleBy(const double ds, const double cx, const double cy, const timestamp duration) {
+void Transform::scaleBy(const double ds, const double cx, const double cy, const std::chrono::steady_clock::duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     // clamp scale to min/max values
@@ -167,13 +166,13 @@ void Transform::scaleBy(const double ds, const double cx, const double cy, const
 }
 
 void Transform::setScale(const double scale, const double cx, const double cy,
-                         const timestamp duration) {
+                         const std::chrono::steady_clock::duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     _setScale(scale, cx, cy, duration);
 }
 
-void Transform::setZoom(const double zoom, const timestamp duration) {
+void Transform::setZoom(const double zoom, const std::chrono::steady_clock::duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     _setScale(std::pow(2.0, zoom), -1, -1, duration);
@@ -198,8 +197,8 @@ void Transform::startScaling() {
 
     // Add a 200ms timeout for resetting this to false
     current.scaling = true;
-    timestamp start = util::now();
-    scale_timeout = std::make_shared<util::timeout<bool>>(false, current.scaling, start, 200_milliseconds);
+    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+    scale_timeout = std::make_shared<util::timeout<bool>>(false, current.scaling, start, std::chrono::milliseconds(200));
     transitions.emplace_front(scale_timeout);
 }
 
@@ -231,7 +230,7 @@ void Transform::_clearScaling() {
     }
 }
 
-void Transform::_setScale(double new_scale, double cx, double cy, const timestamp duration) {
+void Transform::_setScale(double new_scale, double cx, double cy, const std::chrono::steady_clock::duration duration) {
     // This is only called internally, so we don't need a lock here.
 
     // Ensure that we don't zoom in further than the maximum allowed.
@@ -265,10 +264,10 @@ void Transform::_setScale(double new_scale, double cx, double cy, const timestam
 }
 
 void Transform::_setScaleXY(const double new_scale, const double xn, const double yn,
-                            const timestamp duration) {
+                            const std::chrono::steady_clock::duration duration) {
     // This is only called internally, so we don't need a lock here.
 
-    view.notifyMapChange(duration ?
+    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
                            MapChangeRegionWillChangeAnimated :
                            MapChangeRegionWillChange);
 
@@ -278,13 +277,13 @@ void Transform::_setScaleXY(const double new_scale, const double xn, const doubl
 
     constrain(final.scale, final.y);
 
-    if (duration == 0) {
+    if (duration == std::chrono::steady_clock::duration::zero()) {
         current.scale = final.scale;
         current.x = final.x;
         current.y = final.y;
     } else {
         // Use a common start time for all of the transitions to avoid divergent transitions.
-        timestamp start = util::now();
+        std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
         transitions.emplace_front(std::make_shared<util::ease_transition<double>>(
             current.scale, final.scale, current.scale, start, duration));
         transitions.emplace_front(
@@ -297,7 +296,7 @@ void Transform::_setScaleXY(const double new_scale, const double xn, const doubl
     Bc = s / 360;
     Cc = s / (2 * M_PI);
 
-    view.notifyMapChange(duration ?
+    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
                            MapChangeRegionDidChangeAnimated :
                            MapChangeRegionDidChange,
                            duration);
@@ -319,7 +318,7 @@ void Transform::constrain(double& scale, double& y) const {
 #pragma mark - Angle
 
 void Transform::rotateBy(const double start_x, const double start_y, const double end_x,
-                         const double end_y, const timestamp duration) {
+                         const double end_y, const std::chrono::steady_clock::duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     double center_x = current.width / 2, center_y = current.height / 2;
@@ -349,7 +348,7 @@ void Transform::rotateBy(const double start_x, const double start_y, const doubl
     _setAngle(ang, duration);
 }
 
-void Transform::setAngle(const double new_angle, const timestamp duration) {
+void Transform::setAngle(const double new_angle, const std::chrono::steady_clock::duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     _setAngle(new_angle, duration);
@@ -363,20 +362,20 @@ void Transform::setAngle(const double new_angle, const double cx, const double c
     if (cx >= 0 && cy >= 0) {
         dx = (final.width / 2) - cx;
         dy = (final.height / 2) - cy;
-        _moveBy(dx, dy, 0);
+        _moveBy(dx, dy, std::chrono::steady_clock::duration::zero());
     }
 
-    _setAngle(new_angle, 0);
+    _setAngle(new_angle, std::chrono::steady_clock::duration::zero());
 
     if (cx >= 0 && cy >= 0) {
-        _moveBy(-dx, -dy, 0);
+        _moveBy(-dx, -dy, std::chrono::steady_clock::duration::zero());
     }
 }
 
-void Transform::_setAngle(double new_angle, const timestamp duration) {
+void Transform::_setAngle(double new_angle, const std::chrono::steady_clock::duration duration) {
     // This is only called internally, so we don't need a lock here.
 
-    view.notifyMapChange(duration ?
+    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
                            MapChangeRegionWillChangeAnimated :
                            MapChangeRegionWillChange);
 
@@ -387,15 +386,15 @@ void Transform::_setAngle(double new_angle, const timestamp duration) {
 
     final.angle = new_angle;
 
-    if (duration == 0) {
+    if (duration == std::chrono::steady_clock::duration::zero()) {
         current.angle = final.angle;
     } else {
-        timestamp start = util::now();
+        std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
         transitions.emplace_front(std::make_shared<util::ease_transition<double>>(
             current.angle, final.angle, current.angle, start, duration));
     }
 
-    view.notifyMapChange(duration ?
+    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
                            MapChangeRegionDidChangeAnimated :
                            MapChangeRegionDidChange,
                            duration);
@@ -414,8 +413,8 @@ void Transform::startRotating() {
 
     // Add a 200ms timeout for resetting this to false
     current.rotating = true;
-    timestamp start = util::now();
-    rotate_timeout = std::make_shared<util::timeout<bool>>(false, current.rotating, start, 200_milliseconds);
+    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+    rotate_timeout = std::make_shared<util::timeout<bool>>(false, current.rotating, start, std::chrono::milliseconds(200));
     transitions.emplace_front(rotate_timeout);
 }
 
@@ -443,7 +442,7 @@ bool Transform::needsTransition() const {
     return !transitions.empty();
 }
 
-void Transform::updateTransitions(const timestamp now) {
+void Transform::updateTransitions(const std::chrono::steady_clock::time_point now) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     transitions.remove_if([now](const util::ptr<util::transition> &transition) {