Use std::chrono

27 files changed, 171 insertions, 172 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) {
diff --git a/src/mbgl/renderer/frame_history.cpp b/src/mbgl/renderer/frame_history.cpp
index 8b69162a23..21925fa312 100644
--- a/src/mbgl/renderer/frame_history.cpp
+++ b/src/mbgl/renderer/frame_history.cpp
@@ -3,11 +3,11 @@
 using namespace mbgl;
 
 // Record frame history that will be used to calculate fading params
-void FrameHistory::record(timestamp now, float zoom) {
+void FrameHistory::record(std::chrono::steady_clock::time_point now, float zoom) {
     // first frame ever
     if (!history.size()) {
-        history.emplace_back(FrameSnapshot{0, zoom});
-        history.emplace_back(FrameSnapshot{0, zoom});
+        history.emplace_back(FrameSnapshot{std::chrono::steady_clock::time_point::min(), zoom});
+        history.emplace_back(FrameSnapshot{std::chrono::steady_clock::time_point::min(), zoom});
     }
 
     if (history.size() > 0 || history.back().z != zoom) {
@@ -15,7 +15,7 @@ void FrameHistory::record(timestamp now, float zoom) {
     }
 }
 
-bool FrameHistory::needsAnimation(const timestamp duration) const {
+bool FrameHistory::needsAnimation(const std::chrono::steady_clock::duration duration) const {
     if (!history.size()) {
         return false;
     }
@@ -26,7 +26,7 @@ bool FrameHistory::needsAnimation(const timestamp duration) const {
     const FrameSnapshot &pivot = history.back();
 
     int i = -1;
-    while ((int)history.size() > i + 1 && history[i + 1].t + duration < pivot.t) {
+    while ((int)history.size() > i + 1 && history[i + 1].now + duration < pivot.now) {
         i++;
     }
 
@@ -47,16 +47,16 @@ bool FrameHistory::needsAnimation(const timestamp duration) const {
     return false;
 }
 
-FadeProperties FrameHistory::getFadeProperties(timestamp duration)
+FadeProperties FrameHistory::getFadeProperties(std::chrono::steady_clock::duration duration)
 {
-    const timestamp currentTime = util::now();
+    const std::chrono::steady_clock::time_point currentTime = std::chrono::steady_clock::now();
 
     // Remove frames until only one is outside the duration, or until there are only three
-    while (history.size() > 3 && history[1].t + duration < currentTime) {
+    while (history.size() > 3 && history[1].now + duration < currentTime) {
         history.pop_front();
     }
 
-    if (history[1].t + duration < currentTime) {
+    if (history[1].now + duration < currentTime) {
         history[0].z = history[1].z;
     }
 
@@ -69,12 +69,13 @@ FadeProperties FrameHistory::getFadeProperties(timestamp duration)
 
     // Calculate the speed of zooming, and how far it would zoom in terms of zoom levels in one
     // duration
-    float zoomDiff = endingZ - history[1].z, timeDiff = lastFrame.t - history[1].t;
+    float zoomDiff = endingZ - history[1].z;
+    std::chrono::duration<float> timeDiff = lastFrame.now - history[1].now;
     float fadedist = zoomDiff / (timeDiff / duration);
 
     // At end of a zoom when the zoom stops changing continue pretending to zoom at that speed
     // bump is how much farther it would have been if it had continued zooming at the same rate
-    float bump = (currentTime - lastFrame.t) / duration * fadedist;
+    float bump = std::chrono::duration<float>(currentTime - lastFrame.now) / duration * fadedist;
 
     return FadeProperties {
         fadedist,
diff --git a/src/mbgl/renderer/frame_history.hpp b/src/mbgl/renderer/frame_history.hpp
index 61bb59da33..f56b391256 100644
--- a/src/mbgl/renderer/frame_history.hpp
+++ b/src/mbgl/renderer/frame_history.hpp
@@ -4,15 +4,15 @@
 #include <deque>
 #include <cassert>
 #include <cmath>
+#include <chrono>
 
 #include <mbgl/platform/platform.hpp>
-#include <mbgl/util/time.hpp>
 
 namespace mbgl {
 
 struct FrameSnapshot {
-    explicit inline FrameSnapshot(timestamp t_, float z_) : t(t_), z(z_) {}
-    float t;
+    explicit inline FrameSnapshot(std::chrono::steady_clock::time_point now_, float z_) : now(now_), z(z_) {}
+    std::chrono::steady_clock::time_point now;
     float z;
 };
 
@@ -26,10 +26,10 @@ struct FadeProperties {
 class FrameHistory {
 public:
     // Record frame history that will be used to calculate fading params
-    void record(timestamp now, float zoom);
+    void record(std::chrono::steady_clock::time_point now, float zoom);
 
-    bool needsAnimation(timestamp duration) const;
-    FadeProperties getFadeProperties(timestamp duration);
+    bool needsAnimation(std::chrono::steady_clock::duration duration) const;
+    FadeProperties getFadeProperties(std::chrono::steady_clock::duration duration);
 
 public:
     std::deque<FrameSnapshot> history;
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 0fb99826c6..3f30e6d0f5 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -5,7 +5,6 @@
 #include <mbgl/style/style_bucket.hpp>
 #include <mbgl/util/std.hpp>
 #include <mbgl/util/string.hpp>
-#include <mbgl/util/time.hpp>
 #include <mbgl/util/clip_ids.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/mat3.hpp>
@@ -35,7 +34,7 @@ Painter::~Painter() {
 }
 
 bool Painter::needsAnimation() const {
-    return frameHistory.needsAnimation(300);
+    return frameHistory.needsAnimation(std::chrono::milliseconds(300));
 }
 
 void Painter::setup() {
@@ -216,7 +215,7 @@ void Painter::prepareTile(const Tile& tile) {
 }
 
 void Painter::render(const Style& style, const std::set<util::ptr<StyleSource>>& sources,
-                     TransformState state_, timestamp time) {
+                     TransformState state_, std::chrono::steady_clock::time_point time) {
     state = state_;
 
     clear();
@@ -461,7 +460,7 @@ mat4 Painter::translatedMatrix(const mat4& matrix, const std::array<float, 2> &t
     }
 }
 
-void Painter::recordZoom(const timestamp time, const float zoom) {
+void Painter::recordZoom(const std::chrono::steady_clock::time_point time, const float zoom) {
     frameHistory.record(time, zoom);
 
     if (lastZoom < 0) {
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index 5a42070200..bbce588642 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -28,6 +28,7 @@
 #include <map>
 #include <unordered_map>
 #include <set>
+#include <chrono>
 
 namespace mbgl {
 
@@ -78,7 +79,7 @@ public:
     void render(const Style& style,
                 const std::set<util::ptr<StyleSource>>& sources,
                 TransformState state,
-                timestamp time);
+                std::chrono::steady_clock::time_point time);
 
     void renderLayers(util::ptr<StyleLayerGroup> group);
     void renderLayer(util::ptr<StyleLayer> layer_desc, const Tile::ID* id = nullptr, const mat4* matrix = nullptr);
@@ -139,7 +140,7 @@ private:
     mat4 translatedMatrix(const mat4& matrix, const std::array<float, 2> &translation, const Tile::ID &id, TranslateAnchorType anchor);
 
     void prepareTile(const Tile& tile);
-    void recordZoom(const timestamp time, const float zoom);
+    void recordZoom(const std::chrono::steady_clock::time_point time, const float zoom);
 
     template <typename BucketProperties, typename StyleProperties>
     void renderSDF(SymbolBucket &bucket,
@@ -193,7 +194,7 @@ private:
     const float strata_epsilon = 1.0f / (1 << 16);
 
     int lastIntegerZoom;
-    timestamp lastIntegerZoomTime = 0;
+    std::chrono::steady_clock::time_point lastIntegerZoomTime = std::chrono::steady_clock::time_point::min();
     float lastZoom = -1;
 
 public:
diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp
index 5e8f46d340..45de66201c 100644
--- a/src/mbgl/renderer/painter_fill.cpp
+++ b/src/mbgl/renderer/painter_fill.cpp
@@ -63,9 +63,9 @@ void Painter::renderFill(FillBucket& bucket, util::ptr<StyleLayer> layer_desc, c
             float factor = 8.0 / std::pow(2, state.getIntegerZoom() - id.z);
 
             float mix;
-            float duration = 300 * 1_millisecond;
+            std::chrono::steady_clock::duration duration = std::chrono::milliseconds(300);
             const float fraction = std::fmod(float(state.getZoom()), 1.0f);
-            float t = std::min((util::now() - lastIntegerZoomTime) / duration, 1.0f);
+            float t = std::min(static_cast<float>((std::chrono::steady_clock::now() - lastIntegerZoomTime) / duration), 1.0f);
             if (state.getZoom() > lastIntegerZoom) {
                 // zooming in
                 mix = fraction + (1.0f - fraction) * t;
diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp
index 3951f2e7c8..1f69a05511 100644
--- a/src/mbgl/renderer/painter_line.cpp
+++ b/src/mbgl/renderer/painter_line.cpp
@@ -70,9 +70,9 @@ void Painter::renderLine(LineBucket& bucket, util::ptr<StyleLayer> layer_desc, c
         bucket.drawPoints(*linejoinShader);
     }
 
-    float duration = 300 * 1_millisecond;
+    std::chrono::steady_clock::duration duration = std::chrono::milliseconds(300);
     const float fraction = std::fmod(float(state.getZoom()), 1.0f);
-    float t = std::min((util::now() - lastIntegerZoomTime) / duration, 1.0f);
+    float t = std::min(static_cast<float>(std::chrono::duration<float>(std::chrono::steady_clock::now() - lastIntegerZoomTime) / duration), 1.0f);
 
     if (properties.dash_array.size()) {
 
diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp
index d9e4a58c23..579a6d2e06 100644
--- a/src/mbgl/renderer/painter_symbol.cpp
+++ b/src/mbgl/renderer/painter_symbol.cpp
@@ -5,6 +5,7 @@
 #include <mbgl/geometry/sprite_atlas.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/util/math.hpp>
+
 #include <cmath>
 
 using namespace mbgl;
@@ -52,7 +53,7 @@ void Painter::renderSDF(SymbolBucket &bucket,
     sdfShader.u_angle = (int32_t)(angle + 256) % 256;
     sdfShader.u_zoom = (state.getNormalizedZoom() - zoomAdjust) * 10; // current zoom level
 
-    FadeProperties f = frameHistory.getFadeProperties(300_milliseconds);
+    FadeProperties f = frameHistory.getFadeProperties(std::chrono::milliseconds(300));
     sdfShader.u_fadedist = f.fadedist * 10;
     sdfShader.u_minfadezoom = std::floor(f.minfadezoom * 10);
     sdfShader.u_maxfadezoom = std::floor(f.maxfadezoom * 10);
diff --git a/src/mbgl/style/applied_class_properties.cpp b/src/mbgl/style/applied_class_properties.cpp
index 9037c6ad5d..4e5647ce4d 100644
--- a/src/mbgl/style/applied_class_properties.cpp
+++ b/src/mbgl/style/applied_class_properties.cpp
@@ -2,7 +2,7 @@
 
 namespace mbgl {
 
-AppliedClassProperty::AppliedClassProperty(ClassID class_id, timestamp begin_, timestamp end_, const PropertyValue &value_)
+AppliedClassProperty::AppliedClassProperty(ClassID class_id, std::chrono::steady_clock::time_point begin_, std::chrono::steady_clock::time_point end_, const PropertyValue &value_)
     : name(class_id),
     begin(begin_),
     end(end_),
@@ -13,7 +13,7 @@ ClassID AppliedClassProperties::mostRecent() const {
     return properties.size() ? properties.back().name : ClassID::Fallback;
 }
 
-void AppliedClassProperties::add(ClassID class_id, timestamp begin, timestamp end, const PropertyValue &value) {
+void AppliedClassProperties::add(ClassID class_id, std::chrono::steady_clock::time_point begin, std::chrono::steady_clock::time_point end, const PropertyValue &value) {
     properties.emplace_back(class_id, begin, end, value);
 }
 
@@ -23,7 +23,7 @@ bool AppliedClassProperties::hasTransitions() const {
 
 // Erase all items in the property list that are before a completed transition.
 // Then, if the only remaining property is a Fallback value, remove it too.
-void AppliedClassProperties::cleanup(timestamp now) {
+void AppliedClassProperties::cleanup(std::chrono::steady_clock::time_point now) {
     // Iterate backwards, but without using the rbegin/rend interface since we need forward
     // iterators to use .erase().
     for (auto it = properties.end(), begin = properties.begin(); it != begin;) {
@@ -49,4 +49,4 @@ bool AppliedClassProperties::empty() const {
     return properties.empty();
 }
 
-}
\ No newline at end of file
+}
diff --git a/src/mbgl/style/applied_class_properties.hpp b/src/mbgl/style/applied_class_properties.hpp
index 827f15a2a1..ac086a2246 100644
--- a/src/mbgl/style/applied_class_properties.hpp
+++ b/src/mbgl/style/applied_class_properties.hpp
@@ -3,20 +3,20 @@
 
 #include <mbgl/style/property_value.hpp>
 #include <mbgl/style/class_dictionary.hpp>
-#include <mbgl/util/time.hpp>
 
 #include <list>
+#include <chrono>
 
 namespace mbgl {
 
 class AppliedClassProperty {
 public:
-    AppliedClassProperty(ClassID class_id, timestamp begin, timestamp end, const PropertyValue &value);
+    AppliedClassProperty(ClassID class_id, std::chrono::steady_clock::time_point begin, std::chrono::steady_clock::time_point end, const PropertyValue &value);
 
 public:
     const ClassID name;
-    const timestamp begin;
-    const timestamp end;
+    const std::chrono::steady_clock::time_point begin;
+    const std::chrono::steady_clock::time_point end;
     const PropertyValue value;
 };
 
@@ -28,9 +28,9 @@ public:
 public:
     // Returns thie ID of the most recent
     ClassID mostRecent() const;
-    void add(ClassID class_id, timestamp begin, timestamp end, const PropertyValue &value);
+    void add(ClassID class_id, std::chrono::steady_clock::time_point begin, std::chrono::steady_clock::time_point end, const PropertyValue &value);
     bool hasTransitions() const;
-    void cleanup(timestamp now);
+    void cleanup(std::chrono::steady_clock::time_point now);
     bool empty() const;
 };
 
diff --git a/src/mbgl/style/property_transition.hpp b/src/mbgl/style/property_transition.hpp
index 07b7cfe288..cf9167cc0f 100644
--- a/src/mbgl/style/property_transition.hpp
+++ b/src/mbgl/style/property_transition.hpp
@@ -2,14 +2,15 @@
 #define MBGL_STYLE_PROPERTY_TRANSITION
 
 #include <cstdint>
+#include <chrono>
 
 namespace mbgl {
 
 struct PropertyTransition {
-    uint16_t duration = 0;
-    uint16_t delay = 0;
+    std::chrono::steady_clock::duration duration = std::chrono::steady_clock::duration::zero();
+    std::chrono::steady_clock::duration delay = std::chrono::steady_clock::duration::zero();
 };
 
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index ecff6fb5ff..01781afe3c 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -4,7 +4,6 @@
 #include <mbgl/style/style_parser.hpp>
 #include <mbgl/style/style_bucket.hpp>
 #include <mbgl/util/constants.hpp>
-#include <mbgl/util/time.hpp>
 #include <mbgl/util/error.hpp>
 #include <mbgl/util/std.hpp>
 #include <mbgl/util/uv_detail.hpp>
@@ -26,7 +25,7 @@ Style::Style()
 // for deleting the std::unique_ptr<uv::rwlock>.
 Style::~Style() {}
 
-void Style::updateProperties(float z, timestamp now) {
+void Style::updateProperties(float z, std::chrono::steady_clock::time_point now) {
     uv::writelock lock(mtx);
 
     if (layers) {
@@ -44,13 +43,13 @@ const std::string &Style::getSpriteURL() const {
     return sprite_url;
 }
 
-void Style::setDefaultTransitionDuration(uint16_t duration_milliseconds) {
-    defaultTransition.duration = duration_milliseconds;
+void Style::setDefaultTransitionDuration(std::chrono::steady_clock::duration duration) {
+    defaultTransition.duration = duration;
 }
 
 void Style::cascadeClasses(const std::vector<std::string>& classes) {
     if (layers) {
-        layers->setClasses(classes, util::now(), defaultTransition);
+        layers->setClasses(classes, std::chrono::steady_clock::now(), defaultTransition);
     }
 }
 
diff --git a/src/mbgl/style/style.hpp b/src/mbgl/style/style.hpp
index e9205712ef..af00f9710b 100644
--- a/src/mbgl/style/style.hpp
+++ b/src/mbgl/style/style.hpp
@@ -4,7 +4,6 @@
 #include <mbgl/style/property_transition.hpp>
 #include <mbgl/style/style_source.hpp>
 
-#include <mbgl/util/time.hpp>
 #include <mbgl/util/uv.hpp>
 #include <mbgl/util/ptr.hpp>
 
@@ -14,6 +13,7 @@
 #include <unordered_map>
 #include <vector>
 #include <set>
+#include <chrono>
 
 namespace mbgl {
 
@@ -31,9 +31,9 @@ public:
     void loadJSON(const uint8_t *const data);
 
     size_t layerCount() const;
-    void updateProperties(float z, timestamp t);
+    void updateProperties(float z, std::chrono::steady_clock::time_point now);
 
-    void setDefaultTransitionDuration(uint16_t duration_milliseconds = 0);
+    void setDefaultTransitionDuration(std::chrono::steady_clock::duration duration = std::chrono::steady_clock::duration::zero());
     void cascadeClasses(const std::vector<std::string>&);
 
     bool hasTransitions() const;
diff --git a/src/mbgl/style/style_layer.cpp b/src/mbgl/style/style_layer.cpp
index 262ca23af8..3b82d7f94a 100644
--- a/src/mbgl/style/style_layer.cpp
+++ b/src/mbgl/style/style_layer.cpp
@@ -14,7 +14,7 @@ bool StyleLayer::isBackground() const {
     return type == StyleLayerType::Background;
 }
 
-void StyleLayer::setClasses(const std::vector<std::string> &class_names, const timestamp now,
+void StyleLayer::setClasses(const std::vector<std::string> &class_names, const std::chrono::steady_clock::time_point now,
                             const PropertyTransition &defaultTransition) {
     // Stores all keys that we have already added transitions for.
     std::set<PropertyKey> already_applied;
@@ -45,8 +45,8 @@ void StyleLayer::setClasses(const std::vector<std::string> &class_names, const t
         if (appliedProperties.mostRecent() != ClassID::Fallback) {
             // This property key hasn't been set by a previous class, so we need to add a transition
             // to the fallback value for that key.
-            const timestamp begin = now + defaultTransition.delay * 1_millisecond;
-            const timestamp end = begin + defaultTransition.duration * 1_millisecond;
+            const std::chrono::steady_clock::time_point begin = now + defaultTransition.delay;
+            const std::chrono::steady_clock::time_point end = begin + defaultTransition.duration;
             const PropertyValue &value = PropertyFallbackValue::Get(key);
             appliedProperties.add(ClassID::Fallback, begin, end, value);
         }
@@ -55,7 +55,7 @@ void StyleLayer::setClasses(const std::vector<std::string> &class_names, const t
 
 // Helper function for applying all properties of a a single class that haven't been applied yet.
 void StyleLayer::applyClassProperties(const ClassID class_id,
-                                      std::set<PropertyKey> &already_applied, timestamp now,
+                                      std::set<PropertyKey> &already_applied, std::chrono::steady_clock::time_point now,
                                       const PropertyTransition &defaultTransition) {
     auto style_it = styles.find(class_id);
     if (style_it == styles.end()) {
@@ -83,8 +83,8 @@ void StyleLayer::applyClassProperties(const ClassID class_id,
         if (appliedProperties.mostRecent() != class_id) {
             const PropertyTransition &transition =
                 class_properties.getTransition(key, defaultTransition);
-            const timestamp begin = now + transition.delay * 1_millisecond;
-            const timestamp end = begin + transition.duration * 1_millisecond;
+            const std::chrono::steady_clock::time_point begin = now + transition.delay;
+            const std::chrono::steady_clock::time_point end = begin + transition.duration;
             const PropertyValue &value = property_pair.second;
             appliedProperties.add(class_id, begin, end, value);
         }
@@ -115,7 +115,7 @@ private:
 };
 
 template <typename T>
-void StyleLayer::applyStyleProperty(PropertyKey key, T &target, const float z, const timestamp now) {
+void StyleLayer::applyStyleProperty(PropertyKey key, T &target, const float z, const std::chrono::steady_clock::time_point now) {
     auto it = appliedStyle.find(key);
     if (it != appliedStyle.end()) {
         AppliedClassProperties &applied = it->second;
@@ -133,7 +133,7 @@ void StyleLayer::applyStyleProperty(PropertyKey key, T &target, const float z, c
 }
 
 template <typename T>
-void StyleLayer::applyTransitionedStyleProperty(PropertyKey key, T &target, const float z, const timestamp now) {
+void StyleLayer::applyTransitionedStyleProperty(PropertyKey key, T &target, const float z, const std::chrono::steady_clock::time_point now) {
     auto it = appliedStyle.find(key);
     if (it != appliedStyle.end()) {
         AppliedClassProperties &applied = it->second;
@@ -145,7 +145,7 @@ void StyleLayer::applyTransitionedStyleProperty(PropertyKey key, T &target, cons
                 target = mapbox::util::apply_visitor(evaluator, property.value);
             } else if (now >= property.begin) {
                 // We overwrite the current property partially with the new value.
-                float progress = float(now - property.begin) / float(property.end - property.begin);
+                float progress = std::chrono::duration<float>(now - property.begin) / (property.end - property.begin);
                 target = util::interpolate(target, mapbox::util::apply_visitor(evaluator, property.value), progress);
             } else {
                 // Do not apply this property because its transition hasn't begun yet.
@@ -155,7 +155,7 @@ void StyleLayer::applyTransitionedStyleProperty(PropertyKey key, T &target, cons
 }
 
 template <>
-void StyleLayer::applyStyleProperties<FillProperties>(const float z, const timestamp now) {
+void StyleLayer::applyStyleProperties<FillProperties>(const float z, const std::chrono::steady_clock::time_point now) {
     properties.set<FillProperties>();
     FillProperties &fill = properties.get<FillProperties>();
     applyStyleProperty(PropertyKey::FillAntialias, fill.antialias, z, now);
@@ -169,7 +169,7 @@ void StyleLayer::applyStyleProperties<FillProperties>(const float z, const times
 }
 
 template <>
-void StyleLayer::applyStyleProperties<LineProperties>(const float z, const timestamp now) {
+void StyleLayer::applyStyleProperties<LineProperties>(const float z, const std::chrono::steady_clock::time_point now) {
     properties.set<LineProperties>();
     LineProperties &line = properties.get<LineProperties>();
     applyTransitionedStyleProperty(PropertyKey::LineOpacity, line.opacity, z, now);
@@ -184,11 +184,11 @@ void StyleLayer::applyStyleProperties<LineProperties>(const float z, const times
     applyStyleProperty(PropertyKey::LineImage, line.image, z, now);
 
     // for scaling dasharrays
-    applyStyleProperty(PropertyKey::LineWidth, line.dash_line_width, std::floor(z), now + 10000);
+    applyStyleProperty(PropertyKey::LineWidth, line.dash_line_width, std::floor(z), std::chrono::steady_clock::time_point::max());
 }
 
 template <>
-void StyleLayer::applyStyleProperties<SymbolProperties>(const float z, const timestamp now) {
+void StyleLayer::applyStyleProperties<SymbolProperties>(const float z, const std::chrono::steady_clock::time_point now) {
     properties.set<SymbolProperties>();
     SymbolProperties &symbol = properties.get<SymbolProperties>();
     applyTransitionedStyleProperty(PropertyKey::IconOpacity, symbol.icon.opacity, z, now);
@@ -214,7 +214,7 @@ void StyleLayer::applyStyleProperties<SymbolProperties>(const float z, const tim
 }
 
 template <>
-void StyleLayer::applyStyleProperties<RasterProperties>(const float z, const timestamp now) {
+void StyleLayer::applyStyleProperties<RasterProperties>(const float z, const std::chrono::steady_clock::time_point now) {
     properties.set<RasterProperties>();
     RasterProperties &raster = properties.get<RasterProperties>();
     applyTransitionedStyleProperty(PropertyKey::RasterOpacity, raster.opacity, z, now);
@@ -227,7 +227,7 @@ void StyleLayer::applyStyleProperties<RasterProperties>(const float z, const tim
 }
 
 template <>
-void StyleLayer::applyStyleProperties<BackgroundProperties>(const float z, const timestamp now) {
+void StyleLayer::applyStyleProperties<BackgroundProperties>(const float z, const std::chrono::steady_clock::time_point now) {
     properties.set<BackgroundProperties>();
     BackgroundProperties &background = properties.get<BackgroundProperties>();
     applyTransitionedStyleProperty(PropertyKey::BackgroundOpacity, background.opacity, z, now);
@@ -235,7 +235,7 @@ void StyleLayer::applyStyleProperties<BackgroundProperties>(const float z, const
     applyStyleProperty(PropertyKey::BackgroundImage, background.image, z, now);
 }
 
-void StyleLayer::updateProperties(float z, const timestamp now) {
+void StyleLayer::updateProperties(float z, const std::chrono::steady_clock::time_point now) {
     cleanupAppliedStyleProperties(now);
 
     switch (type) {
@@ -258,7 +258,7 @@ bool StyleLayer::hasTransitions() const {
 }
 
 
-void StyleLayer::cleanupAppliedStyleProperties(timestamp now) {
+void StyleLayer::cleanupAppliedStyleProperties(std::chrono::steady_clock::time_point now) {
     auto it = appliedStyle.begin();
     const auto end = appliedStyle.end();
     while (it != end) {
diff --git a/src/mbgl/style/style_layer.hpp b/src/mbgl/style/style_layer.hpp
index 7cf661ca33..b6cfe779c7 100644
--- a/src/mbgl/style/style_layer.hpp
+++ b/src/mbgl/style/style_layer.hpp
@@ -12,6 +12,7 @@
 #include <string>
 #include <map>
 #include <set>
+#include <chrono>
 
 namespace mbgl {
 
@@ -35,10 +36,10 @@ public:
 
     // Updates the StyleProperties information in this layer by evaluating all
     // pending transitions and applied classes in order.
-    void updateProperties(float z, timestamp now);
+    void updateProperties(float z, std::chrono::steady_clock::time_point now);
 
     // Sets the list of classes and creates transitions to the currently applied values.
-    void setClasses(const std::vector<std::string> &class_names, timestamp now,
+    void setClasses(const std::vector<std::string> &class_names, std::chrono::steady_clock::time_point now,
                     const PropertyTransition &defaultTransition);
 
     bool hasTransitions() const;
@@ -46,16 +47,16 @@ public:
 private:
     // Applies all properties from a class, if they haven't been applied already.
     void applyClassProperties(ClassID class_id, std::set<PropertyKey> &already_applied,
-                              timestamp now, const PropertyTransition &defaultTransition);
+                              std::chrono::steady_clock::time_point now, const PropertyTransition &defaultTransition);
 
     // Sets the properties of this object by evaluating all pending transitions and
     // aplied classes in order.
-    template <typename T> void applyStyleProperties(float z, timestamp now);
-    template <typename T> void applyStyleProperty(PropertyKey key, T &, float z, timestamp now);
-    template <typename T> void applyTransitionedStyleProperty(PropertyKey key, T &, float z, timestamp now);
+    template <typename T> void applyStyleProperties(float z, std::chrono::steady_clock::time_point now);
+    template <typename T> void applyStyleProperty(PropertyKey key, T &, float z, std::chrono::steady_clock::time_point now);
+    template <typename T> void applyTransitionedStyleProperty(PropertyKey key, T &, float z, std::chrono::steady_clock::time_point now);
 
     // Removes all expired style transitions.
-    void cleanupAppliedStyleProperties(timestamp now);
+    void cleanupAppliedStyleProperties(std::chrono::steady_clock::time_point now);
 
 public:
     // The name of this layer.
diff --git a/src/mbgl/style/style_layer_group.cpp b/src/mbgl/style/style_layer_group.cpp
index 0ca0fa0cce..3f1a4a5111 100644
--- a/src/mbgl/style/style_layer_group.cpp
+++ b/src/mbgl/style/style_layer_group.cpp
@@ -2,7 +2,7 @@
 
 namespace mbgl {
 
-void StyleLayerGroup::setClasses(const std::vector<std::string> &class_names, timestamp now,
+void StyleLayerGroup::setClasses(const std::vector<std::string> &class_names, std::chrono::steady_clock::time_point now,
                                  const PropertyTransition &defaultTransition) {
     for (const util::ptr<StyleLayer> &layer : layers) {
         if (layer) {
@@ -11,10 +11,10 @@ void StyleLayerGroup::setClasses(const std::vector<std::string> &class_names, ti
     }
 }
 
-void StyleLayerGroup::updateProperties(float z, timestamp t) {
+void StyleLayerGroup::updateProperties(float z, std::chrono::steady_clock::time_point now) {
     for (const util::ptr<StyleLayer> &layer: layers) {
         if (layer) {
-            layer->updateProperties(z, t);
+            layer->updateProperties(z, now);
         }
     }
 }
diff --git a/src/mbgl/style/style_layer_group.hpp b/src/mbgl/style/style_layer_group.hpp
index 1af6e23bd7..3f5a20073d 100644
--- a/src/mbgl/style/style_layer_group.hpp
+++ b/src/mbgl/style/style_layer_group.hpp
@@ -4,14 +4,15 @@
 #include <mbgl/style/style_layer.hpp>
 
 #include <vector>
+#include <chrono>
 
 namespace mbgl {
 
 class StyleLayerGroup {
 public:
-    void setClasses(const std::vector<std::string> &class_names, timestamp now,
+    void setClasses(const std::vector<std::string> &class_names, std::chrono::steady_clock::time_point now,
                     const PropertyTransition &defaultTransition);
-    void updateProperties(float z, timestamp t);
+    void updateProperties(float z, std::chrono::steady_clock::time_point now);
 
     bool hasTransitions() const;
 public:
diff --git a/src/mbgl/style/style_parser.cpp b/src/mbgl/style/style_parser.cpp
index f048b24bd4..e69388e3f8 100644
--- a/src/mbgl/style/style_parser.cpp
+++ b/src/mbgl/style/style_parser.cpp
@@ -367,14 +367,14 @@ template<> std::tuple<bool, PropertyTransition> StyleParser::parseProperty(JSVal
     PropertyTransition transition;
     if (value.IsObject()) {
         if (value.HasMember("duration") && value["duration"].IsNumber()) {
-            transition.duration = value["duration"].GetUint();
+            transition.duration = std::chrono::milliseconds(value["duration"].GetUint());
         }
         if (value.HasMember("delay") && value["delay"].IsNumber()) {
-            transition.delay = value["delay"].GetUint();
+            transition.delay = std::chrono::milliseconds(value["delay"].GetUint());
         }
     }
 
-    if (transition.duration == 0 && transition.delay == 0) {
+    if (transition.duration == std::chrono::steady_clock::duration::zero() && transition.delay == std::chrono::steady_clock::duration::zero()) {
         return std::tuple<bool, PropertyTransition> { false, std::move(transition) };
     }
 
diff --git a/src/mbgl/util/raster.cpp b/src/mbgl/util/raster.cpp
index 3049d92289..724936972c 100644
--- a/src/mbgl/util/raster.cpp
+++ b/src/mbgl/util/raster.cpp
@@ -2,7 +2,6 @@
 #include <mbgl/platform/gl.hpp>
 
 #include <mbgl/util/raster.hpp>
-#include <mbgl/util/time.hpp>
 #include <mbgl/util/uv_detail.hpp>
 #include <mbgl/util/std.hpp>
 
@@ -91,15 +90,15 @@ void Raster::bind(const GLuint custom_texture) {
 }
 
 void Raster::beginFadeInTransition() {
-    timestamp start = util::now();
-    fade_transition = std::make_shared<util::ease_transition<double>>(opacity, 1.0, opacity, start, 250_milliseconds);
+    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
+    fade_transition = std::make_shared<util::ease_transition<double>>(opacity, 1.0, opacity, start, std::chrono::milliseconds(250));
 }
 
 bool Raster::needsTransition() const {
     return fade_transition != nullptr;
 }
 
-void Raster::updateTransitions(timestamp now) {
+void Raster::updateTransitions(std::chrono::steady_clock::time_point now) {
     if (fade_transition->update(now) == util::transition::complete) {
         fade_transition = nullptr;
     }
diff --git a/src/mbgl/util/raster.hpp b/src/mbgl/util/raster.hpp
index bbdfc5321d..f9e275461c 100644
--- a/src/mbgl/util/raster.hpp
+++ b/src/mbgl/util/raster.hpp
@@ -8,6 +8,7 @@
 
 #include <string>
 #include <mutex>
+#include <chrono>
 
 typedef struct uv_loop_s uv_loop_t;
 
@@ -34,7 +35,7 @@ public:
     // transitions
     void beginFadeInTransition();
     bool needsTransition() const;
-    void updateTransitions(timestamp now);
+    void updateTransitions(std::chrono::steady_clock::time_point now);
 
 public:
     // loaded image dimensions
diff --git a/src/mbgl/util/stopwatch.cpp b/src/mbgl/util/stopwatch.cpp
index 14b4f4018b..310bdb8ff2 100644
--- a/src/mbgl/util/stopwatch.cpp
+++ b/src/mbgl/util/stopwatch.cpp
@@ -1,6 +1,5 @@
 #ifndef DISABLE_STOPWATCH
 #include <mbgl/util/stopwatch.hpp>
-#include <mbgl/util/time.hpp>
 #include <mbgl/util/string.hpp>
 #include <mbgl/platform/log.hpp>
 
@@ -10,21 +9,21 @@
 using namespace mbgl::util;
 
 stopwatch::stopwatch(Event event_)
-    : event(event_), start(now()) {}
+    : event(event_), start(std::chrono::steady_clock::now()) {}
 
 stopwatch::stopwatch(EventSeverity severity_, Event event_)
-    : severity(severity_), event(event_), start(now()) {}
+    : severity(severity_), event(event_), start(std::chrono::steady_clock::now()) {}
 
 stopwatch::stopwatch(const std::string &name_, Event event_)
-    : name(name_), event(event_), start(now()) {}
+    : name(name_), event(event_), start(std::chrono::steady_clock::now()) {}
 
 stopwatch::stopwatch(const std::string &name_, EventSeverity severity_, Event event_)
-    : name(name_), severity(severity_), event(event_), start(now()) {}
+    : name(name_), severity(severity_), event(event_), start(std::chrono::steady_clock::now()) {}
 
 void stopwatch::report(const std::string &name_) {
-    timestamp duration = now() - start;
+    std::chrono::steady_clock::duration duration = std::chrono::steady_clock::now() - start;
 
-    Log::Record(severity, event, name_ + ": " + util::toString(double(duration) / 1_millisecond) + "ms");
+    Log::Record(severity, event, name_ + ": " + util::toString(std::chrono::duration_cast<std::chrono::milliseconds>(duration).count()) + "ms");
     start += duration;
 }
 
diff --git a/src/mbgl/util/stopwatch.hpp b/src/mbgl/util/stopwatch.hpp
index 663bbb6fc7..bfa384c07e 100644
--- a/src/mbgl/util/stopwatch.hpp
+++ b/src/mbgl/util/stopwatch.hpp
@@ -4,6 +4,7 @@
 #include <mbgl/platform/event.hpp>
 
 #include <string>
+#include <chrono>
 
 namespace mbgl {
 namespace util {
@@ -22,7 +23,7 @@ private:
     const std::string name;
     EventSeverity severity = EventSeverity::Debug;
     Event event = Event::General;
-    uint64_t start;
+    std::chrono::steady_clock::time_point start;
 };
 #else
 class stopwatch {
diff --git a/src/mbgl/util/time.cpp b/src/mbgl/util/time.cpp
index 1953975b18..94936acff0 100644
--- a/src/mbgl/util/time.cpp
+++ b/src/mbgl/util/time.cpp
@@ -4,10 +4,6 @@
 namespace mbgl {
 namespace util {
 
-timestamp now() {
-    return uv_hrtime();
-}
-
 static const char *week[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
 static const char *months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
                                "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
diff --git a/src/mbgl/util/transition.cpp b/src/mbgl/util/transition.cpp
index e63a5c311f..c47776c9b5 100644
--- a/src/mbgl/util/transition.cpp
+++ b/src/mbgl/util/transition.cpp
@@ -10,7 +10,7 @@ UnitBezier ease(0, 0, 0.25, 1);
 transition::~transition() {}
 
 template <typename T>
-transition::state ease_transition<T>::update(timestamp now) const {
+transition::state ease_transition<T>::update(std::chrono::steady_clock::time_point now) const {
     float t = progress(now);
     if (t >= 1) {
         value = to;
diff --git a/src/mbgl/util/transition.hpp b/src/mbgl/util/transition.hpp
index d6bbc9eba0..fc1ecd23c3 100644
--- a/src/mbgl/util/transition.hpp
+++ b/src/mbgl/util/transition.hpp
@@ -2,7 +2,7 @@
 #define MBGL_UTIL_TRANSITION
 
 #include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/time.hpp>
+#include <chrono>
 
 namespace mbgl {
 namespace util {
@@ -14,34 +14,35 @@ public:
         complete
     };
 
-    inline transition(timestamp start_, timestamp duration_)
+    inline transition(std::chrono::steady_clock::time_point start_, std::chrono::steady_clock::duration duration_)
         : start(start_),
           duration(duration_) {}
 
-    inline float progress(timestamp now) const {
-        if (duration == 0) return 1;
+    inline float progress(std::chrono::steady_clock::time_point now) const {
+        if (duration == std::chrono::steady_clock::duration::zero()) return 1;
         if (start > now) return 0;
 
-        return (float)(now - start) / duration;
+        return std::chrono::duration<float>(now - start) / duration;
     }
 
-    virtual state update(timestamp now) const = 0;
+    virtual state update(std::chrono::steady_clock::time_point now) const = 0;
     virtual ~transition();
 
 protected:
-    const timestamp start, duration;
+    const std::chrono::steady_clock::time_point start;
+    const std::chrono::steady_clock::duration duration;
 };
 
 template <typename T>
 class ease_transition : public transition {
 public:
-    ease_transition(T from_, T to_, T& value_, timestamp start_, timestamp duration_)
+    ease_transition(T from_, T to_, T& value_, std::chrono::steady_clock::time_point start_, std::chrono::steady_clock::duration duration_)
         : transition(start_, duration_),
           from(from_),
           to(to_),
           value(value_) {}
 
-    state update(timestamp now) const;
+    state update(std::chrono::steady_clock::time_point now) const;
 
 private:
     const T from, to;
@@ -52,12 +53,12 @@ private:
 template <typename T>
 class timeout : public transition {
 public:
-    timeout(T final_value_, T& value_, timestamp start_, timestamp duration_)
+    timeout(T final_value_, T& value_, std::chrono::steady_clock::time_point start_, std::chrono::steady_clock::duration duration_)
         : transition(start_, duration_),
           final_value(final_value_),
           value(value_) {}
 
-    state update(timestamp now) const {
+    state update(std::chrono::steady_clock::time_point now) const {
         if (progress(now) >= 1) {
             value = final_value;
             return complete;