5 files changed, 60 insertions, 59 deletions

diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index c4ad6efc53..9dad7a58b3 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -456,12 +456,12 @@ void Map::cancelTransitions() {
 
 #pragma mark - Position
 
-void Map::moveBy(double dx, double dy, std::chrono::steady_clock::duration duration) {
+void Map::moveBy(double dx, double dy, Duration duration) {
     transform.moveBy(dx, dy, duration);
     triggerUpdate();
 }
 
-void Map::setLatLng(LatLng latLng, std::chrono::steady_clock::duration duration) {
+void Map::setLatLng(LatLng latLng, Duration duration) {
     transform.setLatLng(latLng, duration);
     triggerUpdate();
 }
@@ -490,12 +490,12 @@ void Map::resetPosition() {
 
 #pragma mark - Scale
 
-void Map::scaleBy(double ds, double cx, double cy, std::chrono::steady_clock::duration duration) {
+void Map::scaleBy(double ds, double cx, double cy, Duration duration) {
     transform.scaleBy(ds, cx, cy, duration);
     triggerUpdate();
 }
 
-void Map::setScale(double scale, double cx, double cy, std::chrono::steady_clock::duration duration) {
+void Map::setScale(double scale, double cx, double cy, Duration duration) {
     transform.setScale(scale, cx, cy, duration);
     triggerUpdate();
 }
@@ -504,7 +504,7 @@ double Map::getScale() const {
     return transform.getScale();
 }
 
-void Map::setZoom(double zoom, std::chrono::steady_clock::duration duration) {
+void Map::setZoom(double zoom, Duration duration) {
     transform.setZoom(zoom, duration);
     triggerUpdate();
 }
@@ -513,7 +513,7 @@ double Map::getZoom() const {
     return transform.getZoom();
 }
 
-void Map::setLatLngZoom(LatLng latLng, double zoom, std::chrono::steady_clock::duration duration) {
+void Map::setLatLngZoom(LatLng latLng, double zoom, Duration duration) {
     transform.setLatLngZoom(latLng, zoom, duration);
     triggerUpdate();
 }
@@ -543,12 +543,12 @@ double Map::getMaxZoom() const {
 
 #pragma mark - Rotation
 
-void Map::rotateBy(double sx, double sy, double ex, double ey, std::chrono::steady_clock::duration duration) {
+void Map::rotateBy(double sx, double sy, double ex, double ey, Duration duration) {
     transform.rotateBy(sx, sy, ex, ey, duration);
     triggerUpdate();
 }
 
-void Map::setBearing(double degrees, std::chrono::steady_clock::duration duration) {
+void Map::setBearing(double degrees, Duration duration) {
     transform.setAngle(-degrees * M_PI / 180, duration);
     triggerUpdate();
 }
@@ -671,7 +671,7 @@ bool Map::getDebug() const {
     return data->getDebug();
 }
 
-std::chrono::steady_clock::time_point Map::getTime() const {
+TimePoint Map::getTime() const {
     return data->getAnimationTime();
 }
 
@@ -700,14 +700,14 @@ std::vector<std::string> Map::getClasses() const {
     return data->getClasses();
 }
 
-void Map::setDefaultTransitionDuration(std::chrono::steady_clock::duration duration) {
+void Map::setDefaultTransitionDuration(Duration duration) {
     assert(Environment::currentlyOn(ThreadType::Main));
 
     data->setDefaultTransitionDuration(duration);
     triggerUpdate(Update::DefaultTransitionDuration);
 }
 
-std::chrono::steady_clock::duration Map::getDefaultTransitionDuration() {
+Duration Map::getDefaultTransitionDuration() {
     assert(Environment::currentlyOn(ThreadType::Main));
     return data->getDefaultTransitionDuration();
 }
@@ -829,7 +829,7 @@ void Map::prepare() {
 
     // Update transform transitions.
 
-    const auto animationTime = std::chrono::steady_clock::now();
+    const auto animationTime = Clock::now();
     data->setAnimationTime(animationTime);
     if (transform.needsTransition()) {
         transform.updateTransitions(animationTime);
diff --git a/src/mbgl/map/map_data.hpp b/src/mbgl/map/map_data.hpp
index c0d57134d9..718c3eb0e0 100644
--- a/src/mbgl/map/map_data.hpp
+++ b/src/mbgl/map/map_data.hpp
@@ -1,10 +1,11 @@
 #ifndef MBGL_MAP_MAP_DATA
 #define MBGL_MAP_MAP_DATA
 
+#include <mbgl/util/chrono.hpp>
+
 #include <string>
 #include <mutex>
 #include <atomic>
-#include <chrono>
 #include <vector>
 
 namespace mbgl {
@@ -20,8 +21,8 @@ class MapData {
 
 public:
     inline MapData() {
-        setAnimationTime(std::chrono::steady_clock::time_point::min());
-        setDefaultTransitionDuration(std::chrono::steady_clock::duration::zero());
+        setAnimationTime(TimePoint::min());
+        setDefaultTransitionDuration(Duration::zero());
     }
 
     inline StyleInfo getStyleInfo() const {
@@ -70,19 +71,19 @@ public:
         debug = value;
     }
 
-    inline std::chrono::steady_clock::time_point getAnimationTime() const {
-        // We're casting the time_point to and from a duration because libstdc++
-        // has a bug that doesn't allow time_points to be atomic.
-        return std::chrono::steady_clock::time_point(animationTime);
+    inline TimePoint getAnimationTime() const {
+        // We're casting the TimePoint to and from a Duration because libstdc++
+        // has a bug that doesn't allow TimePoints to be atomic.
+        return TimePoint(animationTime);
     }
-    inline void setAnimationTime(std::chrono::steady_clock::time_point timePoint) {
+    inline void setAnimationTime(TimePoint timePoint) {
         animationTime = timePoint.time_since_epoch();
     };
 
-    inline std::chrono::steady_clock::duration getDefaultTransitionDuration() const {
+    inline Duration getDefaultTransitionDuration() const {
         return defaultTransitionDuration;
     }
-    inline void setDefaultTransitionDuration(std::chrono::steady_clock::duration duration) {
+    inline void setDefaultTransitionDuration(Duration duration) {
         defaultTransitionDuration = duration;
     };
 
@@ -93,8 +94,8 @@ private:
     std::string accessToken;
     std::vector<std::string> classes;
     std::atomic<uint8_t> debug { false };
-    std::atomic<std::chrono::steady_clock::time_point::duration> animationTime;
-    std::atomic<std::chrono::steady_clock::duration> defaultTransitionDuration;
+    std::atomic<Duration> animationTime;
+    std::atomic<Duration> defaultTransitionDuration;
 };
 
 }
diff --git a/src/mbgl/map/source.hpp b/src/mbgl/map/source.hpp
index 4cdd2ed64d..4a04769bcf 100644
--- a/src/mbgl/map/source.hpp
+++ b/src/mbgl/map/source.hpp
@@ -8,12 +8,12 @@
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/ptr.hpp>
+#include <mbgl/util/chrono.hpp>
 
 #include <cstdint>
 #include <forward_list>
 #include <iosfwd>
 #include <map>
-#include <chrono>
 
 namespace mbgl {
 
@@ -68,7 +68,7 @@ private:
     bool loaded = false;
 
     // Stores the time when this source was most recently updated.
-    std::chrono::steady_clock::time_point updated = std::chrono::steady_clock::time_point::min();
+    TimePoint updated = TimePoint::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 f3b14731e1..dd0fd620b1 100644
--- a/src/mbgl/map/transform.cpp
+++ b/src/mbgl/map/transform.cpp
@@ -44,16 +44,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 std::chrono::steady_clock::duration duration) {
+void Transform::moveBy(const double dx, const double dy, const Duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     _moveBy(dx, dy, duration);
 }
 
-void Transform::_moveBy(const double dx, const double dy, const std::chrono::steady_clock::duration duration) {
+void Transform::_moveBy(const double dx, const double dy, const Duration duration) {
     // This is only called internally, so we don't need a lock here.
 
-    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
+    view.notifyMapChange(duration != Duration::zero() ?
                            MapChangeRegionWillChangeAnimated :
                            MapChangeRegionWillChange);
 
@@ -62,25 +62,25 @@ void Transform::_moveBy(const double dx, const double dy, const std::chrono::ste
 
     constrain(final.scale, final.y);
 
-    if (duration == std::chrono::steady_clock::duration::zero()) {
+    if (duration == 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.
-        std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+        TimePoint start = 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 != std::chrono::steady_clock::duration::zero() ?
+    view.notifyMapChange(duration != Duration::zero() ?
                            MapChangeRegionDidChangeAnimated :
                            MapChangeRegionDidChange,
                            duration);
 }
 
-void Transform::setLatLng(const LatLng latLng, const std::chrono::steady_clock::duration duration) {
+void Transform::setLatLng(const LatLng latLng, const Duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     const double m = 1 - 1e-15;
@@ -92,7 +92,7 @@ void Transform::setLatLng(const LatLng latLng, const std::chrono::steady_clock::
     _setScaleXY(current.scale, xn, yn, duration);
 }
 
-void Transform::setLatLngZoom(const LatLng latLng, const double zoom, const std::chrono::steady_clock::duration duration) {
+void Transform::setLatLngZoom(const LatLng latLng, const double zoom, const Duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     double new_scale = std::pow(2.0, zoom);
@@ -117,8 +117,8 @@ void Transform::startPanning() {
 
     // Add a 200ms timeout for resetting this to false
     current.panning = true;
-    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));
+    TimePoint start = Clock::now();
+    pan_timeout = std::make_shared<util::timeout<bool>>(false, current.panning, start, std::chrono::milliseconds(200));
     transitions.emplace_front(pan_timeout);
 }
 
@@ -138,7 +138,7 @@ void Transform::_clearPanning() {
 
 #pragma mark - Zoom
 
-void Transform::scaleBy(const double ds, const double cx, const double cy, const std::chrono::steady_clock::duration duration) {
+void Transform::scaleBy(const double ds, const double cx, const double cy, const Duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     // clamp scale to min/max values
@@ -153,13 +153,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 std::chrono::steady_clock::duration duration) {
+                         const Duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     _setScale(scale, cx, cy, duration);
 }
 
-void Transform::setZoom(const double zoom, const std::chrono::steady_clock::duration duration) {
+void Transform::setZoom(const double zoom, const Duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     _setScale(std::pow(2.0, zoom), -1, -1, duration);
@@ -184,7 +184,7 @@ void Transform::startScaling() {
 
     // Add a 200ms timeout for resetting this to false
     current.scaling = true;
-    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+    TimePoint start = Clock::now();
     scale_timeout = std::make_shared<util::timeout<bool>>(false, current.scaling, start, std::chrono::milliseconds(200));
     transitions.emplace_front(scale_timeout);
 }
@@ -217,7 +217,7 @@ void Transform::_clearScaling() {
     }
 }
 
-void Transform::_setScale(double new_scale, double cx, double cy, const std::chrono::steady_clock::duration duration) {
+void Transform::_setScale(double new_scale, double cx, double cy, const 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.
@@ -251,10 +251,10 @@ void Transform::_setScale(double new_scale, double cx, double cy, const std::chr
 }
 
 void Transform::_setScaleXY(const double new_scale, const double xn, const double yn,
-                            const std::chrono::steady_clock::duration duration) {
+                            const Duration duration) {
     // This is only called internally, so we don't need a lock here.
 
-    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
+    view.notifyMapChange(duration != Duration::zero() ?
                            MapChangeRegionWillChangeAnimated :
                            MapChangeRegionWillChange);
 
@@ -264,13 +264,13 @@ void Transform::_setScaleXY(const double new_scale, const double xn, const doubl
 
     constrain(final.scale, final.y);
 
-    if (duration == std::chrono::steady_clock::duration::zero()) {
+    if (duration == 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.
-        std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+        TimePoint start = Clock::now();
         transitions.emplace_front(std::make_shared<util::ease_transition<double>>(
             current.scale, final.scale, current.scale, start, duration));
         transitions.emplace_front(
@@ -283,7 +283,7 @@ void Transform::_setScaleXY(const double new_scale, const double xn, const doubl
     current.Bc = s / 360;
     current.Cc = s / util::M2PI;
 
-    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
+    view.notifyMapChange(duration != Duration::zero() ?
                            MapChangeRegionDidChangeAnimated :
                            MapChangeRegionDidChange,
                            duration);
@@ -305,7 +305,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 std::chrono::steady_clock::duration duration) {
+                         const double end_y, const Duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     double center_x = current.width / 2, center_y = current.height / 2;
@@ -335,7 +335,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 std::chrono::steady_clock::duration duration) {
+void Transform::setAngle(const double new_angle, const Duration duration) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     _setAngle(new_angle, duration);
@@ -349,20 +349,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, std::chrono::steady_clock::duration::zero());
+        _moveBy(dx, dy, Duration::zero());
     }
 
-    _setAngle(new_angle, std::chrono::steady_clock::duration::zero());
+    _setAngle(new_angle, Duration::zero());
 
     if (cx >= 0 && cy >= 0) {
-        _moveBy(-dx, -dy, std::chrono::steady_clock::duration::zero());
+        _moveBy(-dx, -dy, Duration::zero());
     }
 }
 
-void Transform::_setAngle(double new_angle, const std::chrono::steady_clock::duration duration) {
+void Transform::_setAngle(double new_angle, const Duration duration) {
     // This is only called internally, so we don't need a lock here.
 
-    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
+    view.notifyMapChange(duration != Duration::zero() ?
                            MapChangeRegionWillChangeAnimated :
                            MapChangeRegionWillChange);
 
@@ -373,15 +373,15 @@ void Transform::_setAngle(double new_angle, const std::chrono::steady_clock::dur
 
     final.angle = new_angle;
 
-    if (duration == std::chrono::steady_clock::duration::zero()) {
+    if (duration == Duration::zero()) {
         current.angle = final.angle;
     } else {
-        std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+        TimePoint start = Clock::now();
         transitions.emplace_front(std::make_shared<util::ease_transition<double>>(
             current.angle, final.angle, current.angle, start, duration));
     }
 
-    view.notifyMapChange(duration != std::chrono::steady_clock::duration::zero() ?
+    view.notifyMapChange(duration != Duration::zero() ?
                            MapChangeRegionDidChangeAnimated :
                            MapChangeRegionDidChange,
                            duration);
@@ -400,7 +400,7 @@ void Transform::startRotating() {
 
     // Add a 200ms timeout for resetting this to false
     current.rotating = true;
-    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+    TimePoint start = Clock::now();
     rotate_timeout = std::make_shared<util::timeout<bool>>(false, current.rotating, start, std::chrono::milliseconds(200));
     transitions.emplace_front(rotate_timeout);
 }
@@ -430,7 +430,7 @@ bool Transform::needsTransition() const {
     return !transitions.empty();
 }
 
-void Transform::updateTransitions(const std::chrono::steady_clock::time_point now) {
+void Transform::updateTransitions(const TimePoint now) {
     std::lock_guard<std::recursive_mutex> lock(mtx);
 
     transitions.remove_if([now](const util::ptr<util::transition> &transition) {
diff --git a/src/mbgl/map/view.cpp b/src/mbgl/map/view.cpp
index 21ba4daf36..95c31f93e3 100644
--- a/src/mbgl/map/view.cpp
+++ b/src/mbgl/map/view.cpp
@@ -13,7 +13,7 @@ void View::resize(uint16_t width, uint16_t height, float ratio, uint16_t fbWidth
     map->resize(width, height, ratio, fbWidth, fbHeight);
 }
 
-void View::notifyMapChange(MapChange, std::chrono::steady_clock::duration) {
+void View::notifyMapChange(MapChange, Duration) {
     // no-op
 }