AK: Rename Time to Duration

That's what this class really is; in fact that's what the first line of
the comment says it is.

This commit does not rename the main files, since those will contain
other time-related classes in a little bit.

AK/DOSPackedTime.cpp

@@ -8,12 +8,12 @@
 
 namespace AK {
 
-Time time_from_packed_dos(DOSPackedDate date, DOSPackedTime time)
+Duration time_from_packed_dos(DOSPackedDate date, DOSPackedTime time)
 {
     if (date.value == 0)
-        return Time();
+        return Duration();
 
-    return Time::from_timestamp(first_dos_year + date.year, date.month, date.day, time.hour, time.minute, time.second * 2, 0);
+    return Duration::from_timestamp(first_dos_year + date.year, date.month, date.day, time.hour, time.minute, time.second * 2, 0);
 }
 
 DOSPackedDate to_packed_dos_date(unsigned year, unsigned month, unsigned day)

AK/DOSPackedTime.h

@@ -33,7 +33,7 @@ static_assert(sizeof(DOSPackedDate) == 2);
 
 inline constexpr u16 first_dos_year = 1980;
 
-Time time_from_packed_dos(DOSPackedDate, DOSPackedTime);
+Duration time_from_packed_dos(DOSPackedDate, DOSPackedTime);
 DOSPackedDate to_packed_dos_date(unsigned year, unsigned month, unsigned day);
 DOSPackedTime to_packed_dos_time(unsigned hour, unsigned minute, unsigned second);
 

AK/Forward.h

@@ -27,6 +27,7 @@ class CountingStream;
 class DeprecatedFlyString;
 class DeprecatedString;
 class DeprecatedStringCodePointIterator;
+class Duration;
 class Error;
 class FlyString;
 class GenericLexer;
@@ -44,7 +45,6 @@ class String;
 class StringBuilder;
 class StringImpl;
 class StringView;
-class Time;
 class URL;
 class Utf16View;
 class Utf32CodePointIterator;
@@ -163,6 +163,7 @@ using AK::DeprecatedFlyString;
 using AK::DeprecatedString;
 using AK::DeprecatedStringCodePointIterator;
 using AK::DoublyLinkedList;
+using AK::Duration;
 using AK::Error;
 using AK::ErrorOr;
 using AK::FixedArray;
@@ -194,7 +195,6 @@ using AK::String;
 using AK::StringBuilder;
 using AK::StringImpl;
 using AK::StringView;
-using AK::Time;
 using AK::Traits;
 using AK::URL;
 using AK::Utf16View;

AK/Time.cpp

@@ -38,31 +38,31 @@ unsigned day_of_week(int year, unsigned month, int day)
     return (year + year / 4 - year / 100 + year / 400 + seek_table[month - 1] + day) % 7;
 }
 
-Time Time::from_ticks(clock_t ticks, time_t ticks_per_second)
+Duration Duration::from_ticks(clock_t ticks, time_t ticks_per_second)
 {
     auto secs = ticks % ticks_per_second;
 
     i32 nsecs = 1'000'000'000 * (ticks - (ticks_per_second * secs)) / ticks_per_second;
     i32 extra_secs = sane_mod(nsecs, 1'000'000'000);
-    return Time::from_half_sanitized(secs, extra_secs, nsecs);
+    return Duration::from_half_sanitized(secs, extra_secs, nsecs);
 }
 
-Time Time::from_timespec(const struct timespec& ts)
+Duration Duration::from_timespec(const struct timespec& ts)
 {
     i32 nsecs = ts.tv_nsec;
     i32 extra_secs = sane_mod(nsecs, 1'000'000'000);
-    return Time::from_half_sanitized(ts.tv_sec, extra_secs, nsecs);
+    return Duration::from_half_sanitized(ts.tv_sec, extra_secs, nsecs);
 }
 
-Time Time::from_timeval(const struct timeval& tv)
+Duration Duration::from_timeval(const struct timeval& tv)
 {
     i32 usecs = tv.tv_usec;
     i32 extra_secs = sane_mod(usecs, 1'000'000);
     VERIFY(0 <= usecs && usecs < 1'000'000);
-    return Time::from_half_sanitized(tv.tv_sec, extra_secs, usecs * 1'000);
+    return Duration::from_half_sanitized(tv.tv_sec, extra_secs, usecs * 1'000);
 }
 
-i64 Time::to_truncated_seconds() const
+i64 Duration::to_truncated_seconds() const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     if (m_seconds < 0 && m_nanoseconds) {
@@ -72,7 +72,7 @@ i64 Time::to_truncated_seconds() const
     return m_seconds;
 }
 
-i64 Time::to_truncated_milliseconds() const
+i64 Duration::to_truncated_milliseconds() const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     Checked<i64> milliseconds((m_seconds < 0) ? m_seconds + 1 : m_seconds);
@@ -91,7 +91,7 @@ i64 Time::to_truncated_milliseconds() const
     return m_seconds < 0 ? -0x8000'0000'0000'0000LL : 0x7fff'ffff'ffff'ffffLL;
 }
 
-i64 Time::to_truncated_microseconds() const
+i64 Duration::to_truncated_microseconds() const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     Checked<i64> microseconds((m_seconds < 0) ? m_seconds + 1 : m_seconds);
@@ -110,7 +110,7 @@ i64 Time::to_truncated_microseconds() const
     return m_seconds < 0 ? -0x8000'0000'0000'0000LL : 0x7fff'ffff'ffff'ffffLL;
 }
 
-i64 Time::to_seconds() const
+i64 Duration::to_seconds() const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     if (m_seconds >= 0 && m_nanoseconds) {
@@ -121,7 +121,7 @@ i64 Time::to_seconds() const
     return m_seconds;
 }
 
-i64 Time::to_milliseconds() const
+i64 Duration::to_milliseconds() const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     Checked<i64> milliseconds((m_seconds < 0) ? m_seconds + 1 : m_seconds);
@@ -138,7 +138,7 @@ i64 Time::to_milliseconds() const
     return m_seconds < 0 ? -0x8000'0000'0000'0000LL : 0x7fff'ffff'ffff'ffffLL;
 }
 
-i64 Time::to_microseconds() const
+i64 Duration::to_microseconds() const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     Checked<i64> microseconds((m_seconds < 0) ? m_seconds + 1 : m_seconds);
@@ -155,7 +155,7 @@ i64 Time::to_microseconds() const
     return m_seconds < 0 ? -0x8000'0000'0000'0000LL : 0x7fff'ffff'ffff'ffffLL;
 }
 
-i64 Time::to_nanoseconds() const
+i64 Duration::to_nanoseconds() const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     Checked<i64> nanoseconds((m_seconds < 0) ? m_seconds + 1 : m_seconds);
@@ -170,13 +170,13 @@ i64 Time::to_nanoseconds() const
     return m_seconds < 0 ? -0x8000'0000'0000'0000LL : 0x7fff'ffff'ffff'ffffLL;
 }
 
-timespec Time::to_timespec() const
+timespec Duration::to_timespec() const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     return { static_cast<time_t>(m_seconds), static_cast<long>(m_nanoseconds) };
 }
 
-timeval Time::to_timeval() const
+timeval Duration::to_timeval() const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     // This is done because winsock defines tv_sec and tv_usec as long, and Linux64 as long int.
@@ -185,7 +185,7 @@ timeval Time::to_timeval() const
     return { static_cast<sec_type>(m_seconds), static_cast<usec_type>(m_nanoseconds) / 1000 };
 }
 
-Time Time::operator+(Time const& other) const
+Duration Duration::operator+(Duration const& other) const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     VERIFY(other.m_nanoseconds < 1'000'000'000);
@@ -209,7 +209,7 @@ Time Time::operator+(Time const& other) const
             other_secs += 1;
         } else {
             /* If *both* are INT64_MAX, then adding them will overflow in any case. */
-            return Time::max();
+            return Duration::max();
         }
     }
 
@@ -217,46 +217,46 @@ Time Time::operator+(Time const& other) const
     new_secs += other_secs;
     if (new_secs.has_overflow()) {
         if (other_secs > 0)
-            return Time::max();
+            return Duration::max();
         else
-            return Time::min();
+            return Duration::min();
     }
 
-    return Time { new_secs.value(), new_nsecs };
+    return Duration { new_secs.value(), new_nsecs };
 }
 
-Time& Time::operator+=(Time const& other)
+Duration& Duration::operator+=(Duration const& other)
 {
     *this = *this + other;
     return *this;
 }
 
-Time Time::operator-(Time const& other) const
+Duration Duration::operator-(Duration const& other) const
 {
     VERIFY(m_nanoseconds < 1'000'000'000);
     VERIFY(other.m_nanoseconds < 1'000'000'000);
 
     if (other.m_nanoseconds)
-        return *this + Time((i64) ~(u64)other.m_seconds, 1'000'000'000 - other.m_nanoseconds);
+        return *this + Duration((i64) ~(u64)other.m_seconds, 1'000'000'000 - other.m_nanoseconds);
 
     if (other.m_seconds != (i64)-0x8000'0000'0000'0000)
-        return *this + Time(-other.m_seconds, 0);
+        return *this + Duration(-other.m_seconds, 0);
 
     // Only remaining case: We want to subtract -0x8000'0000'0000'0000 seconds,
     // i.e. add a very large number.
 
     if (m_seconds >= 0)
-        return Time::max();
+        return Duration::max();
-    return Time { (m_seconds + 0x4000'0000'0000'0000) + 0x4000'0000'0000'0000, m_nanoseconds };
+    return Duration { (m_seconds + 0x4000'0000'0000'0000) + 0x4000'0000'0000'0000, m_nanoseconds };
 }
 
-Time& Time::operator-=(Time const& other)
+Duration& Duration::operator-=(Duration const& other)
 {
     *this = *this - other;
     return *this;
 }
 
-Time Time::from_half_sanitized(i64 seconds, i32 extra_seconds, u32 nanoseconds)
+Duration Duration::from_half_sanitized(i64 seconds, i32 extra_seconds, u32 nanoseconds)
 {
     VERIFY(nanoseconds < 1'000'000'000);
 
@@ -269,41 +269,41 @@ Time Time::from_half_sanitized(i64 seconds, i32 extra_seconds, u32 nanoseconds)
     // Now the only possible way to become invalid is overflowing i64 towards positive infinity:
     if (Checked<i64>::addition_would_overflow<i64, i64>(seconds, extra_seconds)) {
         if (seconds < 0) {
-            return Time::min();
+            return Duration::min();
         } else {
-            return Time::max();
+            return Duration::max();
         }
     }
 
-    return Time { seconds + extra_seconds, nanoseconds };
+    return Duration { seconds + extra_seconds, nanoseconds };
 }
 
 #ifndef KERNEL
 namespace {
-static Time now_time_from_clock(clockid_t clock_id)
+static Duration now_time_from_clock(clockid_t clock_id)
 {
     timespec now_spec {};
     ::clock_gettime(clock_id, &now_spec);
-    return Time::from_timespec(now_spec);
+    return Duration::from_timespec(now_spec);
 }
 }
 
-Time Time::now_realtime()
+Duration Duration::now_realtime()
 {
     return now_time_from_clock(CLOCK_REALTIME);
 }
 
-Time Time::now_realtime_coarse()
+Duration Duration::now_realtime_coarse()
 {
     return now_time_from_clock(CLOCK_REALTIME_COARSE);
 }
 
-Time Time::now_monotonic()
+Duration Duration::now_monotonic()
 {
     return now_time_from_clock(CLOCK_MONOTONIC);
 }
 
-Time Time::now_monotonic_coarse()
+Duration Duration::now_monotonic_coarse()
 {
     return now_time_from_clock(CLOCK_MONOTONIC_COARSE);
 }

AK/Time.h

@@ -130,26 +130,28 @@ constexpr i64 seconds_since_epoch_to_year(i64 seconds)
     return 1970 + round_down(years_since_epoch);
 }
 
-/*
+// Represents a duration in a "safe" way.
- * Represents a time amount in a "safe" way.
+// Minimum: -(2**63) seconds, 0 nanoseconds
- * Minimum: 0 seconds, 0 nanoseconds
+// Maximum: 2**63-1 seconds, 999'999'999 nanoseconds
- * Maximum: 2**63-1 seconds, 999'999'999 nanoseconds
+// If any operation (e.g. 'from_timeval' or operator-) would over- or underflow, the closest legal value is returned instead.
- * If any operation (e.g. 'from_timeval' or operator-) would over- or underflow, the closest legal value is returned instead.
+// Inputs (e.g. to 'from_timespec') are allowed to be in non-normal form (e.g. "1 second, 2'012'345'678 nanoseconds" or "1 second, -2 microseconds").
- * Inputs (e.g. to 'from_timespec') are allowed to be in non-normal form (e.g. "1 second, 2'012'345'678 nanoseconds" or "1 second, -2 microseconds").
+// Outputs (e.g. from 'to_timeval') are always in normal form.
- * Outputs (e.g. from 'to_timeval') are always in normal form.
+//
- */
+// NOTE: This class is naive. It may represent either absolute offsets or relative durations. It does not have a reference point in itself,
-class Time {
+//       and therefore comparing multiple instances of this class is only sensible if you are sure that their reference point is identical.
+//       You should not be using this class directly to represent absolute time.
+class Duration {
 public:
-    Time() = default;
+    Duration() = default;
-    Time(Time const&) = default;
+    Duration(Duration const&) = default;
-    Time& operator=(Time const&) = default;
+    Duration& operator=(Duration const&) = default;
 
-    Time(Time&& other)
+    Duration(Duration&& other)
         : m_seconds(exchange(other.m_seconds, 0))
         , m_nanoseconds(exchange(other.m_nanoseconds, 0))
     {
     }
-    Time& operator=(Time&& other)
+    Duration& operator=(Duration&& other)
     {
         if (this != &other) {
             m_seconds = exchange(other.m_seconds, 0);
@@ -188,7 +190,7 @@ private:
     }
 
 public:
-    [[nodiscard]] constexpr static Time from_timestamp(i32 year, u8 month, u8 day, u8 hour, u8 minute, u8 second, u16 millisecond)
+    [[nodiscard]] constexpr static Duration from_timestamp(i32 year, u8 month, u8 day, u8 hour, u8 minute, u8 second, u16 millisecond)
     {
         constexpr auto milliseconds_per_day = 86'400'000;
         constexpr auto milliseconds_per_hour = 3'600'000;
@@ -206,35 +208,35 @@ public:
         return from_milliseconds(milliseconds_since_epoch);
     }
 
-    [[nodiscard]] constexpr static Time from_seconds(i64 seconds) { return Time(seconds, 0); }
+    [[nodiscard]] constexpr static Duration from_seconds(i64 seconds) { return Duration(seconds, 0); }
-    [[nodiscard]] constexpr static Time from_nanoseconds(i64 nanoseconds)
+    [[nodiscard]] constexpr static Duration from_nanoseconds(i64 nanoseconds)
     {
         i64 seconds = sane_mod(nanoseconds, 1'000'000'000);
-        return Time(seconds, nanoseconds);
+        return Duration(seconds, nanoseconds);
     }
-    [[nodiscard]] constexpr static Time from_microseconds(i64 microseconds)
+    [[nodiscard]] constexpr static Duration from_microseconds(i64 microseconds)
     {
         i64 seconds = sane_mod(microseconds, 1'000'000);
-        return Time(seconds, microseconds * 1'000);
+        return Duration(seconds, microseconds * 1'000);
     }
-    [[nodiscard]] constexpr static Time from_milliseconds(i64 milliseconds)
+    [[nodiscard]] constexpr static Duration from_milliseconds(i64 milliseconds)
     {
         i64 seconds = sane_mod(milliseconds, 1'000);
-        return Time(seconds, milliseconds * 1'000'000);
+        return Duration(seconds, milliseconds * 1'000'000);
     }
-    [[nodiscard]] static Time from_ticks(clock_t, time_t);
+    [[nodiscard]] static Duration from_ticks(clock_t, time_t);
-    [[nodiscard]] static Time from_timespec(const struct timespec&);
+    [[nodiscard]] static Duration from_timespec(const struct timespec&);
-    [[nodiscard]] static Time from_timeval(const struct timeval&);
+    [[nodiscard]] static Duration from_timeval(const struct timeval&);
     // We don't pull in <stdint.h> for the pretty min/max definitions because this file is also included in the Kernel
-    [[nodiscard]] constexpr static Time min() { return Time(-__INT64_MAX__ - 1LL, 0); };
+    [[nodiscard]] constexpr static Duration min() { return Duration(-__INT64_MAX__ - 1LL, 0); };
-    [[nodiscard]] constexpr static Time zero() { return Time(0, 0); };
+    [[nodiscard]] constexpr static Duration zero() { return Duration(0, 0); };
-    [[nodiscard]] constexpr static Time max() { return Time(__INT64_MAX__, 999'999'999); };
+    [[nodiscard]] constexpr static Duration max() { return Duration(__INT64_MAX__, 999'999'999); };
 
 #ifndef KERNEL
-    [[nodiscard]] static Time now_realtime();
+    [[nodiscard]] static Duration now_realtime();
-    [[nodiscard]] static Time now_realtime_coarse();
+    [[nodiscard]] static Duration now_realtime_coarse();
-    [[nodiscard]] static Time now_monotonic();
+    [[nodiscard]] static Duration now_monotonic();
-    [[nodiscard]] static Time now_monotonic_coarse();
+    [[nodiscard]] static Duration now_monotonic_coarse();
 #endif
 
     // Truncates towards zero (2.8s to 2s, -2.8s to -2s).
@@ -253,13 +255,13 @@ public:
     [[nodiscard]] bool is_zero() const { return (m_seconds == 0) && (m_nanoseconds == 0); }
     [[nodiscard]] bool is_negative() const { return m_seconds < 0; }
 
-    Time operator+(Time const& other) const;
+    Duration operator+(Duration const& other) const;
-    Time& operator+=(Time const& other);
+    Duration& operator+=(Duration const& other);
-    Time operator-(Time const& other) const;
+    Duration operator-(Duration const& other) const;
-    Time& operator-=(Time const& other);
+    Duration& operator-=(Duration const& other);
 
-    constexpr bool operator==(Time const& other) const = default;
+    constexpr bool operator==(Duration const& other) const = default;
-    constexpr int operator<=>(Time const& other) const
+    constexpr int operator<=>(Duration const& other) const
     {
         if (int cmp = (m_seconds > other.m_seconds ? 1 : m_seconds < other.m_seconds ? -1
                                                                                      : 0);
@@ -273,13 +275,13 @@ public:
     }
 
 private:
-    constexpr explicit Time(i64 seconds, u32 nanoseconds)
+    constexpr explicit Duration(i64 seconds, u32 nanoseconds)
         : m_seconds(seconds)
         , m_nanoseconds(nanoseconds)
     {
     }
 
-    [[nodiscard]] static Time from_half_sanitized(i64 seconds, i32 extra_seconds, u32 nanoseconds);
+    [[nodiscard]] static Duration from_half_sanitized(i64 seconds, i32 extra_seconds, u32 nanoseconds);
 
     i64 m_seconds { 0 };
     u32 m_nanoseconds { 0 }; // Always less than 1'000'000'000
@@ -357,10 +359,10 @@ inline void timespec_to_timeval(TimespecType const& ts, TimevalType& tv)
 // To use these, add a ``using namespace AK::TimeLiterals`` at block or file scope
 namespace TimeLiterals {
 
-constexpr Time operator""_ns(unsigned long long nanoseconds) { return Time::from_nanoseconds(static_cast<i64>(nanoseconds)); }
+constexpr Duration operator""_ns(unsigned long long nanoseconds) { return Duration::from_nanoseconds(static_cast<i64>(nanoseconds)); }
-constexpr Time operator""_us(unsigned long long microseconds) { return Time::from_microseconds(static_cast<i64>(microseconds)); }
+constexpr Duration operator""_us(unsigned long long microseconds) { return Duration::from_microseconds(static_cast<i64>(microseconds)); }
-constexpr Time operator""_ms(unsigned long long milliseconds) { return Time::from_milliseconds(static_cast<i64>(milliseconds)); }
+constexpr Duration operator""_ms(unsigned long long milliseconds) { return Duration::from_milliseconds(static_cast<i64>(milliseconds)); }
-constexpr Time operator""_sec(unsigned long long seconds) { return Time::from_seconds(static_cast<i64>(seconds)); }
+constexpr Duration operator""_sec(unsigned long long seconds) { return Duration::from_seconds(static_cast<i64>(seconds)); }
 
 }
 
@@ -372,9 +374,9 @@ using AK::day_of_year;
 using AK::days_in_month;
 using AK::days_in_year;
 using AK::days_since_epoch;
+using AK::Duration;
 using AK::is_leap_year;
 using AK::seconds_since_epoch_to_year;
-using AK::Time;
 using AK::timespec_add;
 using AK::timespec_add_timeval;
 using AK::timespec_sub;

Kernel/Arch/x86_64/RTC.cpp

@@ -19,9 +19,9 @@ void initialize()
     s_boot_time = now();
 }
 
-Time boot_time()
+Duration boot_time()
 {
-    return Time::from_timespec({ s_boot_time, 0 });
+    return Duration::from_timespec({ s_boot_time, 0 });
 }
 
 static bool update_in_progress()

Kernel/Arch/x86_64/RTC.h

@@ -6,12 +6,13 @@
 
 #pragma once
 
+#include <AK/Time.h>
 #include <Kernel/UnixTypes.h>
 
 namespace Kernel::RTC {
 
 void initialize();
 time_t now();
-Time boot_time();
+Duration boot_time();
 
 }

Kernel/Bus/USB/UHCI/UHCIController.cpp

@@ -590,7 +590,7 @@ ErrorOr<void> UHCIController::spawn_port_process()
             if (m_root_hub)
                 m_root_hub->check_for_port_updates();
 
-            (void)Thread::current()->sleep(Time::from_seconds(1));
+            (void)Thread::current()->sleep(Duration::from_seconds(1));
         }
     }));
     return {};
@@ -616,7 +616,7 @@ ErrorOr<void> UHCIController::spawn_async_poll_process()
                     }
                 }
             }
-            (void)Thread::current()->sleep(Time::from_milliseconds(poll_interval_ms));
+            (void)Thread::current()->sleep(Duration::from_milliseconds(poll_interval_ms));
         }
     }));
     return {};

Kernel/Devices/AsyncDeviceRequest.cpp

@@ -51,7 +51,7 @@ void AsyncDeviceRequest::request_finished()
     m_queue.wake_all();
 }
 
-auto AsyncDeviceRequest::wait(Time* timeout) -> RequestWaitResult
+auto AsyncDeviceRequest::wait(Duration* timeout) -> RequestWaitResult
 {
     VERIFY(!m_parent_request);
     auto request_result = get_request_result();

Kernel/Devices/AsyncDeviceRequest.h

@@ -60,7 +60,7 @@ public:
 
     void add_sub_request(NonnullLockRefPtr<AsyncDeviceRequest>);
 
-    [[nodiscard]] RequestWaitResult wait(Time* = nullptr);
+    [[nodiscard]] RequestWaitResult wait(Duration* = nullptr);
 
     void do_start(SpinlockLocker<Spinlock<LockRank::None>>&& requests_lock)
     {

Kernel/Devices/Audio/IntelHDA/Stream.cpp

@@ -192,7 +192,7 @@ ErrorOr<size_t> OutputStream::write(UserOrKernelBuffer const& data, size_t lengt
             dbgln_if(INTEL_HDA_DEBUG, "IntelHDA: Waiting {} µs until buffer {} becomes writeable", microseconds_to_wait, buffer_index);
 
             // NOTE: we don't care about the reason for interruption - we simply calculate the next delay
-            [[maybe_unused]] auto block_result = Thread::current()->sleep(Time::from_microseconds(microseconds_to_wait));
+            [[maybe_unused]] auto block_result = Thread::current()->sleep(Duration::from_microseconds(microseconds_to_wait));
         }
     };
 

Kernel/FileSystem/DevPtsFS/Inode.cpp

@@ -38,7 +38,7 @@ InodeMetadata DevPtsFSInode::metadata() const
 {
     if (auto pty = m_pty.strong_ref()) {
         auto metadata = m_metadata;
-        metadata.mtime = Time::from_timespec({ pty->time_of_last_write(), 0 });
+        metadata.mtime = Duration::from_timespec({ pty->time_of_last_write(), 0 });
         return metadata;
     }
     return m_metadata;

Kernel/FileSystem/Ext2FS/Inode.cpp

@@ -474,10 +474,10 @@ InodeMetadata Ext2FSInode::metadata() const
     metadata.uid = m_raw_inode.i_uid;
     metadata.gid = m_raw_inode.i_gid;
     metadata.link_count = m_raw_inode.i_links_count;
-    metadata.atime = Time::from_timespec({ m_raw_inode.i_atime, 0 });
+    metadata.atime = Duration::from_timespec({ m_raw_inode.i_atime, 0 });
-    metadata.ctime = Time::from_timespec({ m_raw_inode.i_ctime, 0 });
+    metadata.ctime = Duration::from_timespec({ m_raw_inode.i_ctime, 0 });
-    metadata.mtime = Time::from_timespec({ m_raw_inode.i_mtime, 0 });
+    metadata.mtime = Duration::from_timespec({ m_raw_inode.i_mtime, 0 });
-    metadata.dtime = Time::from_timespec({ m_raw_inode.i_dtime, 0 });
+    metadata.dtime = Duration::from_timespec({ m_raw_inode.i_dtime, 0 });
     metadata.block_size = fs().block_size();
     metadata.block_count = m_raw_inode.i_blocks;
 
@@ -985,7 +985,7 @@ ErrorOr<NonnullRefPtr<Inode>> Ext2FSInode::lookup(StringView name)
     return fs().get_inode({ fsid(), inode_index });
 }
 
-ErrorOr<void> Ext2FSInode::update_timestamps(Optional<Time> atime, Optional<Time> ctime, Optional<Time> mtime)
+ErrorOr<void> Ext2FSInode::update_timestamps(Optional<Duration> atime, Optional<Duration> ctime, Optional<Duration> mtime)
 {
     MutexLocker locker(m_inode_lock);
     if (fs().is_readonly())

Kernel/FileSystem/Ext2FS/Inode.h

@@ -37,7 +37,7 @@ private:
     virtual ErrorOr<void> add_child(Inode& child, StringView name, mode_t) override;
     virtual ErrorOr<void> remove_child(StringView name) override;
     virtual ErrorOr<void> replace_child(StringView name, Inode& child) override;
-    virtual ErrorOr<void> update_timestamps(Optional<Time> atime, Optional<Time> ctime, Optional<Time> mtime) override;
+    virtual ErrorOr<void> update_timestamps(Optional<Duration> atime, Optional<Duration> ctime, Optional<Duration> mtime) override;
     virtual ErrorOr<void> increment_link_count() override;
     virtual ErrorOr<void> decrement_link_count() override;
     virtual ErrorOr<void> chmod(mode_t) override;

Kernel/FileSystem/ISO9660FS/Inode.cpp

@@ -145,7 +145,7 @@ ErrorOr<void> ISO9660Inode::truncate(u64)
     return EROFS;
 }
 
-ErrorOr<void> ISO9660Inode::update_timestamps(Optional<Time>, Optional<Time>, Optional<Time>)
+ErrorOr<void> ISO9660Inode::update_timestamps(Optional<Duration>, Optional<Duration>, Optional<Duration>)
 {
     return EROFS;
 }
@@ -169,7 +169,7 @@ void ISO9660Inode::create_metadata()
 {
     u32 data_length = LittleEndian { m_record.data_length.little };
     bool is_directory = has_flag(m_record.file_flags, ISO::FileFlags::Directory);
-    auto recorded_at = Time::from_timespec({ parse_numerical_date_time(m_record.recording_date_and_time), 0 });
+    auto recorded_at = Duration::from_timespec({ parse_numerical_date_time(m_record.recording_date_and_time), 0 });
 
     m_metadata = {
         .inode = identifier(),

Kernel/FileSystem/ISO9660FS/Inode.h

@@ -32,7 +32,7 @@ public:
     virtual ErrorOr<void> chmod(mode_t) override;
     virtual ErrorOr<void> chown(UserID, GroupID) override;
     virtual ErrorOr<void> truncate(u64) override;
-    virtual ErrorOr<void> update_timestamps(Optional<Time> atime, Optional<Time> ctime, Optional<Time> mtime) override;
+    virtual ErrorOr<void> update_timestamps(Optional<Duration> atime, Optional<Duration> ctime, Optional<Duration> mtime) override;
 
 private:
     // HACK: The base ISO 9660 standard says the maximum filename length is 37

Kernel/FileSystem/Inode.cpp

@@ -115,7 +115,7 @@ ErrorOr<size_t> Inode::read_until_filled_or_end(off_t offset, size_t length, Use
     return length - remaining_length;
 }
 
-ErrorOr<void> Inode::update_timestamps([[maybe_unused]] Optional<Time> atime, [[maybe_unused]] Optional<Time> ctime, [[maybe_unused]] Optional<Time> mtime)
+ErrorOr<void> Inode::update_timestamps([[maybe_unused]] Optional<Duration> atime, [[maybe_unused]] Optional<Duration> ctime, [[maybe_unused]] Optional<Duration> mtime)
 {
     return ENOTIMPL;
 }

Kernel/FileSystem/Inode.h

@@ -82,7 +82,7 @@ public:
 
     bool is_metadata_dirty() const { return m_metadata_dirty; }
 
-    virtual ErrorOr<void> update_timestamps(Optional<Time> atime, Optional<Time> ctime, Optional<Time> mtime);
+    virtual ErrorOr<void> update_timestamps(Optional<Duration> atime, Optional<Duration> ctime, Optional<Duration> mtime);
     virtual ErrorOr<void> increment_link_count();
     virtual ErrorOr<void> decrement_link_count();
 

Kernel/FileSystem/InodeMetadata.h

@@ -120,10 +120,10 @@ struct InodeMetadata {
     UserID uid { 0 };
     GroupID gid { 0 };
     nlink_t link_count { 0 };
-    Time atime {};
+    Duration atime {};
-    Time ctime {};
+    Duration ctime {};
-    Time mtime {};
+    Duration mtime {};
-    Time dtime {};
+    Duration dtime {};
     blkcnt_t block_count { 0 };
     blksize_t block_size { 0 };
     MajorNumber major_device { 0 };

Kernel/FileSystem/ProcFS/Inode.h

@@ -54,7 +54,7 @@ private:
 
     // ^Inode (Silent ignore handling)
     virtual ErrorOr<void> flush_metadata() override { return {}; }
-    virtual ErrorOr<void> update_timestamps(Optional<Time>, Optional<Time>, Optional<Time>) override { return {}; }
+    virtual ErrorOr<void> update_timestamps(Optional<Duration>, Optional<Duration>, Optional<Duration>) override { return {}; }
 
     // ^Inode
     virtual ErrorOr<void> attach(OpenFileDescription& description) override;

Kernel/FileSystem/RAMFS/Inode.cpp

@@ -381,7 +381,7 @@ ErrorOr<void> RAMFSInode::truncate(u64 size)
     return {};
 }
 
-ErrorOr<void> RAMFSInode::update_timestamps(Optional<Time> atime, Optional<Time> ctime, Optional<Time> mtime)
+ErrorOr<void> RAMFSInode::update_timestamps(Optional<Duration> atime, Optional<Duration> ctime, Optional<Duration> mtime)
 {
     MutexLocker locker(m_inode_lock);
 

Kernel/FileSystem/RAMFS/Inode.h

@@ -35,7 +35,7 @@ public:
     virtual ErrorOr<void> chmod(mode_t) override;
     virtual ErrorOr<void> chown(UserID, GroupID) override;
     virtual ErrorOr<void> truncate(u64) override;
-    virtual ErrorOr<void> update_timestamps(Optional<Time> atime, Optional<Time> ctime, Optional<Time> mtime) override;
+    virtual ErrorOr<void> update_timestamps(Optional<Duration> atime, Optional<Duration> ctime, Optional<Duration> mtime) override;
 
 private:
     RAMFSInode(RAMFS& fs, InodeMetadata const& metadata, LockWeakPtr<RAMFSInode> parent);

Kernel/FileSystem/SysFS/Inode.cpp

@@ -110,7 +110,7 @@ ErrorOr<void> SysFSInode::truncate(u64 size)
     return m_associated_component->truncate(size);
 }
 
-ErrorOr<void> SysFSInode::update_timestamps(Optional<Time>, Optional<Time>, Optional<Time>)
+ErrorOr<void> SysFSInode::update_timestamps(Optional<Duration>, Optional<Duration>, Optional<Duration>)
 {
     return {};
 }

Kernel/FileSystem/SysFS/Inode.h

@@ -35,7 +35,7 @@ protected:
     virtual ErrorOr<void> chmod(mode_t) override;
     virtual ErrorOr<void> chown(UserID, GroupID) override;
     virtual ErrorOr<void> truncate(u64) override;
-    virtual ErrorOr<void> update_timestamps(Optional<Time> atime, Optional<Time> ctime, Optional<Time> mtime) override;
+    virtual ErrorOr<void> update_timestamps(Optional<Duration> atime, Optional<Duration> ctime, Optional<Duration> mtime) override;
 
     virtual ErrorOr<void> attach(OpenFileDescription& description) override final;
     virtual void did_seek(OpenFileDescription&, off_t) override final;

Kernel/FileSystem/VirtualFileSystem.cpp

@@ -306,7 +306,7 @@ ErrorOr<void> VirtualFileSystem::utime(Credentials const& credentials, StringVie
     if (custody->is_readonly())
         return EROFS;
 
-    TRY(inode.update_timestamps(Time::from_timespec({ atime, 0 }), {}, Time::from_timespec({ mtime, 0 })));
+    TRY(inode.update_timestamps(Duration::from_timespec({ atime, 0 }), {}, Duration::from_timespec({ mtime, 0 })));
     return {};
 }
 
@@ -326,9 +326,9 @@ ErrorOr<void> VirtualFileSystem::do_utimens(Credentials const& credentials, Cust
 
     // NOTE: A standard ext2 inode cannot store nanosecond timestamps.
     TRY(inode.update_timestamps(
-        (atime.tv_nsec != UTIME_OMIT) ? Time::from_timespec(atime) : Optional<Time> {},
+        (atime.tv_nsec != UTIME_OMIT) ? Duration::from_timespec(atime) : Optional<Duration> {},
         {},
-        (mtime.tv_nsec != UTIME_OMIT) ? Time::from_timespec(mtime) : Optional<Time> {}));
+        (mtime.tv_nsec != UTIME_OMIT) ? Duration::from_timespec(mtime) : Optional<Duration> {}));
 
     return {};
 }

Kernel/Graphics/VMWare/Console.cpp

@@ -9,7 +9,7 @@
 
 namespace Kernel {
 
-constexpr static AK::Time refresh_interval = AK::Time::from_milliseconds(16);
+constexpr static AK::Duration refresh_interval = AK::Duration::from_milliseconds(16);
 
 NonnullLockRefPtr<VMWareFramebufferConsole> VMWareFramebufferConsole::initialize(VMWareDisplayConnector& parent_display_connector)
 {

Kernel/Graphics/VirtIOGPU/Console.cpp

@@ -10,7 +10,7 @@
 
 namespace Kernel::Graphics::VirtIOGPU {
 
-constexpr static AK::Time refresh_interval = AK::Time::from_milliseconds(16);
+constexpr static AK::Duration refresh_interval = AK::Duration::from_milliseconds(16);
 
 NonnullLockRefPtr<Console> Console::initialize(VirtIODisplayConnector& parent_display_connector)
 {

Kernel/Net/IPv4Socket.cpp

@@ -287,7 +287,7 @@ ErrorOr<size_t> IPv4Socket::receive_byte_buffered(OpenFileDescription& descripti
     return nreceived_or_error;
 }
 
-ErrorOr<size_t> IPv4Socket::receive_packet_buffered(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> addr, Userspace<socklen_t*> addr_length, Time& packet_timestamp, bool blocking)
+ErrorOr<size_t> IPv4Socket::receive_packet_buffered(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> addr, Userspace<socklen_t*> addr_length, Duration& packet_timestamp, bool blocking)
 {
     MutexLocker locker(mutex());
     ReceivedPacket taken_packet;
@@ -382,7 +382,7 @@ ErrorOr<size_t> IPv4Socket::receive_packet_buffered(OpenFileDescription& descrip
     return protocol_receive(packet->data->bytes(), buffer, buffer_length, flags);
 }
 
-ErrorOr<size_t> IPv4Socket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> user_addr, Userspace<socklen_t*> user_addr_length, Time& packet_timestamp, bool blocking)
+ErrorOr<size_t> IPv4Socket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*> user_addr, Userspace<socklen_t*> user_addr_length, Duration& packet_timestamp, bool blocking)
 {
     if (user_addr_length) {
         socklen_t addr_length;
@@ -415,7 +415,7 @@ ErrorOr<size_t> IPv4Socket::recvfrom(OpenFileDescription& description, UserOrKer
     return total_nreceived;
 }
 
-bool IPv4Socket::did_receive(IPv4Address const& source_address, u16 source_port, ReadonlyBytes packet, Time const& packet_timestamp)
+bool IPv4Socket::did_receive(IPv4Address const& source_address, u16 source_port, ReadonlyBytes packet, Duration const& packet_timestamp)
 {
     MutexLocker locker(mutex());
 

Kernel/Net/IPv4Socket.h

@@ -40,13 +40,13 @@ public:
     virtual bool can_read(OpenFileDescription const&, u64) const override;
     virtual bool can_write(OpenFileDescription const&, u64) const override;
     virtual ErrorOr<size_t> sendto(OpenFileDescription&, UserOrKernelBuffer const&, size_t, int, Userspace<sockaddr const*>, socklen_t) override;
-    virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&, bool blocking) override;
+    virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Duration&, bool blocking) override;
     virtual ErrorOr<void> setsockopt(int level, int option, Userspace<void const*>, socklen_t) override;
     virtual ErrorOr<void> getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
 
     virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
 
-    bool did_receive(IPv4Address const& peer_address, u16 peer_port, ReadonlyBytes, Time const&);
+    bool did_receive(IPv4Address const& peer_address, u16 peer_port, ReadonlyBytes, Duration const&);
 
     IPv4Address const& local_address() const { return m_local_address; }
     u16 local_port() const { return m_local_port; }
@@ -99,7 +99,7 @@ private:
     virtual bool is_ipv4() const override { return true; }
 
     ErrorOr<size_t> receive_byte_buffered(OpenFileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, bool blocking);
-    ErrorOr<size_t> receive_packet_buffered(OpenFileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&, bool blocking);
+    ErrorOr<size_t> receive_packet_buffered(OpenFileDescription&, UserOrKernelBuffer& buffer, size_t buffer_length, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Duration&, bool blocking);
 
     void set_can_read(bool);
 
@@ -112,7 +112,7 @@ private:
     struct ReceivedPacket {
         IPv4Address peer_address;
         u16 peer_port;
-        Time timestamp;
+        Duration timestamp;
         OwnPtr<KBuffer> data;
     };
 

Kernel/Net/LocalSocket.cpp

@@ -333,7 +333,7 @@ DoubleBuffer* LocalSocket::send_buffer_for(OpenFileDescription& description)
     return nullptr;
 }
 
-ErrorOr<size_t> LocalSocket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_size, int, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&, bool blocking)
+ErrorOr<size_t> LocalSocket::recvfrom(OpenFileDescription& description, UserOrKernelBuffer& buffer, size_t buffer_size, int, Userspace<sockaddr*>, Userspace<socklen_t*>, Duration&, bool blocking)
 {
     auto* socket_buffer = receive_buffer_for(description);
     if (!socket_buffer)

Kernel/Net/LocalSocket.h

@@ -47,7 +47,7 @@ public:
     virtual bool can_read(OpenFileDescription const&, u64) const override;
     virtual bool can_write(OpenFileDescription const&, u64) const override;
     virtual ErrorOr<size_t> sendto(OpenFileDescription&, UserOrKernelBuffer const&, size_t, int, Userspace<sockaddr const*>, socklen_t) override;
-    virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&, bool blocking) override;
+    virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Duration&, bool blocking) override;
     virtual ErrorOr<void> getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>) override;
     virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
     virtual ErrorOr<void> chown(Credentials const&, OpenFileDescription&, UserID, GroupID) override;

Kernel/Net/NetworkAdapter.cpp

@@ -95,7 +95,7 @@ void NetworkAdapter::did_receive(ReadonlyBytes payload)
         on_receive();
 }
 
-size_t NetworkAdapter::dequeue_packet(u8* buffer, size_t buffer_size, Time& packet_timestamp)
+size_t NetworkAdapter::dequeue_packet(u8* buffer, size_t buffer_size, Duration& packet_timestamp)
 {
     InterruptDisabler disabler;
     if (m_packet_queue.is_empty())

Kernel/Net/NetworkAdapter.h

@@ -29,7 +29,7 @@ class NetworkAdapter;
 using NetworkByteBuffer = AK::Detail::ByteBuffer<1500>;
 
 struct PacketWithTimestamp final : public AtomicRefCounted<PacketWithTimestamp> {
-    PacketWithTimestamp(NonnullOwnPtr<KBuffer> buffer, Time timestamp)
+    PacketWithTimestamp(NonnullOwnPtr<KBuffer> buffer, Duration timestamp)
         : buffer(move(buffer))
         , timestamp(timestamp)
     {
@@ -38,7 +38,7 @@ struct PacketWithTimestamp final : public AtomicRefCounted<PacketWithTimestamp>
     ReadonlyBytes bytes() { return buffer->bytes(); }
 
     NonnullOwnPtr<KBuffer> buffer;
-    Time timestamp;
+    Duration timestamp;
     IntrusiveListNode<PacketWithTimestamp, RefPtr<PacketWithTimestamp>> packet_node;
 };
 
@@ -79,7 +79,7 @@ public:
     void send(MACAddress const&, ARPPacket const&);
     void fill_in_ipv4_header(PacketWithTimestamp&, IPv4Address const&, MACAddress const&, IPv4Address const&, IPv4Protocol, size_t, u8 type_of_service, u8 ttl);
 
-    size_t dequeue_packet(u8* buffer, size_t buffer_size, Time& packet_timestamp);
+    size_t dequeue_packet(u8* buffer, size_t buffer_size, Duration& packet_timestamp);
 
     bool has_queued_packets() const { return !m_packet_queue.is_empty(); }
 

Kernel/Net/NetworkTask.cpp

@@ -26,10 +26,10 @@
 namespace Kernel {
 
 static void handle_arp(EthernetFrameHeader const&, size_t frame_size);
-static void handle_ipv4(EthernetFrameHeader const&, size_t frame_size, Time const& packet_timestamp);
+static void handle_ipv4(EthernetFrameHeader const&, size_t frame_size, Duration const& packet_timestamp);
-static void handle_icmp(EthernetFrameHeader const&, IPv4Packet const&, Time const& packet_timestamp);
+static void handle_icmp(EthernetFrameHeader const&, IPv4Packet const&, Duration const& packet_timestamp);
-static void handle_udp(IPv4Packet const&, Time const& packet_timestamp);
+static void handle_udp(IPv4Packet const&, Duration const& packet_timestamp);
-static void handle_tcp(IPv4Packet const&, Time const& packet_timestamp);
+static void handle_tcp(IPv4Packet const&, Duration const& packet_timestamp);
 static void send_delayed_tcp_ack(TCPSocket& socket);
 static void send_tcp_rst(IPv4Packet const& ipv4_packet, TCPPacket const& tcp_packet, RefPtr<NetworkAdapter> adapter);
 static void flush_delayed_tcp_acks();
@@ -74,7 +74,7 @@ void NetworkTask_main(void*)
         };
     });
 
-    auto dequeue_packet = [&pending_packets](u8* buffer, size_t buffer_size, Time& packet_timestamp) -> size_t {
+    auto dequeue_packet = [&pending_packets](u8* buffer, size_t buffer_size, Duration& packet_timestamp) -> size_t {
         if (pending_packets == 0)
             return 0;
         size_t packet_size = 0;
@@ -94,14 +94,14 @@ void NetworkTask_main(void*)
         TODO();
     auto buffer_region = region_or_error.release_value();
     auto buffer = (u8*)buffer_region->vaddr().get();
-    Time packet_timestamp;
+    Duration packet_timestamp;
 
     for (;;) {
         flush_delayed_tcp_acks();
         retransmit_tcp_packets();
         size_t packet_size = dequeue_packet(buffer, buffer_size, packet_timestamp);
         if (!packet_size) {
-            auto timeout_time = Time::from_milliseconds(500);
+            auto timeout_time = Duration::from_milliseconds(500);
             auto timeout = Thread::BlockTimeout { false, &timeout_time };
             [[maybe_unused]] auto result = packet_wait_queue.wait_on(timeout, "NetworkTask"sv);
             continue;
@@ -177,7 +177,7 @@ void handle_arp(EthernetFrameHeader const& eth, size_t frame_size)
     }
 }
 
-void handle_ipv4(EthernetFrameHeader const& eth, size_t frame_size, Time const& packet_timestamp)
+void handle_ipv4(EthernetFrameHeader const& eth, size_t frame_size, Duration const& packet_timestamp)
 {
     constexpr size_t minimum_ipv4_frame_size = sizeof(EthernetFrameHeader) + sizeof(IPv4Packet);
     if (frame_size < minimum_ipv4_frame_size) {
@@ -222,7 +222,7 @@ void handle_ipv4(EthernetFrameHeader const& eth, size_t frame_size, Time const&
     }
 }
 
-void handle_icmp(EthernetFrameHeader const& eth, IPv4Packet const& ipv4_packet, Time const& packet_timestamp)
+void handle_icmp(EthernetFrameHeader const& eth, IPv4Packet const& ipv4_packet, Duration const& packet_timestamp)
 {
     auto& icmp_header = *static_cast<ICMPHeader const*>(ipv4_packet.payload());
     dbgln_if(ICMP_DEBUG, "handle_icmp: source={}, destination={}, type={:#02x}, code={:#02x}", ipv4_packet.source().to_string(), ipv4_packet.destination().to_string(), icmp_header.type(), icmp_header.code());
@@ -273,7 +273,7 @@ void handle_icmp(EthernetFrameHeader const& eth, IPv4Packet const& ipv4_packet,
     }
 }
 
-void handle_udp(IPv4Packet const& ipv4_packet, Time const& packet_timestamp)
+void handle_udp(IPv4Packet const& ipv4_packet, Duration const& packet_timestamp)
 {
     if (ipv4_packet.payload_size() < sizeof(UDPPacket)) {
         dbgln("handle_udp: Packet too small ({}, need {})", ipv4_packet.payload_size(), sizeof(UDPPacket));
@@ -367,7 +367,7 @@ void send_tcp_rst(IPv4Packet const& ipv4_packet, TCPPacket const& tcp_packet, Re
     routing_decision.adapter->release_packet_buffer(*packet);
 }
 
-void handle_tcp(IPv4Packet const& ipv4_packet, Time const& packet_timestamp)
+void handle_tcp(IPv4Packet const& ipv4_packet, Duration const& packet_timestamp)
 {
     if (ipv4_packet.payload_size() < sizeof(TCPPacket)) {
         dbgln("handle_tcp: IPv4 payload is too small to be a TCP packet ({}, need {})", ipv4_packet.payload_size(), sizeof(TCPPacket));

Kernel/Net/Socket.cpp

@@ -245,7 +245,7 @@ ErrorOr<size_t> Socket::read(OpenFileDescription& description, u64, UserOrKernel
 {
     if (is_shut_down_for_reading())
         return 0;
-    Time t {};
+    Duration t {};
     return recvfrom(description, buffer, size, 0, {}, 0, t, description.is_blocking());
 }
 

Kernel/Net/Socket.h

@@ -79,7 +79,7 @@ public:
     virtual bool is_local() const { return false; }
     virtual bool is_ipv4() const { return false; }
     virtual ErrorOr<size_t> sendto(OpenFileDescription&, UserOrKernelBuffer const&, size_t, int flags, Userspace<sockaddr const*>, socklen_t) = 0;
-    virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Time&, bool blocking) = 0;
+    virtual ErrorOr<size_t> recvfrom(OpenFileDescription&, UserOrKernelBuffer&, size_t, int flags, Userspace<sockaddr*>, Userspace<socklen_t*>, Duration&, bool blocking) = 0;
 
     virtual ErrorOr<void> setsockopt(int level, int option, Userspace<void const*>, socklen_t);
     virtual ErrorOr<void> getsockopt(OpenFileDescription&, int level, int option, Userspace<void*>, Userspace<socklen_t*>);
@@ -100,11 +100,11 @@ public:
     virtual ErrorOr<struct stat> stat() const override;
     virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(OpenFileDescription const&) const override = 0;
 
-    bool has_receive_timeout() const { return m_receive_timeout != Time::zero(); }
+    bool has_receive_timeout() const { return m_receive_timeout != Duration::zero(); }
-    Time const& receive_timeout() const { return m_receive_timeout; }
+    Duration const& receive_timeout() const { return m_receive_timeout; }
 
-    bool has_send_timeout() const { return m_send_timeout != Time::zero(); }
+    bool has_send_timeout() const { return m_send_timeout != Duration::zero(); }
-    Time const& send_timeout() const { return m_send_timeout; }
+    Duration const& send_timeout() const { return m_send_timeout; }
 
     bool wants_timestamp() const { return m_timestamp; }
 
@@ -173,8 +173,8 @@ private:
 
     SpinlockProtected<RefPtr<NetworkAdapter>, LockRank::None> m_bound_interface;
 
-    Time m_receive_timeout {};
+    Duration m_receive_timeout {};
-    Time m_send_timeout {};
+    Duration m_send_timeout {};
     int m_timestamp { 0 };
 
     SpinlockProtected<Optional<ErrnoCode>, LockRank::None> m_so_error;

Kernel/Net/TCPSocket.cpp

@@ -354,7 +354,7 @@ bool TCPSocket::should_delay_next_ack() const
         return false;
 
     // RFC 1122 says we should not delay ACKs for more than 500 milliseconds.
-    if (kgettimeofday() >= m_last_ack_sent_time + Time::from_milliseconds(500))
+    if (kgettimeofday() >= m_last_ack_sent_time + Duration::from_milliseconds(500))
         return false;
 
     return true;
@@ -586,7 +586,7 @@ void TCPSocket::retransmit_packets()
     for (decltype(m_retransmit_attempts) i = 0; i < m_retransmit_attempts; i++)
         retransmit_interval *= 2;
 
-    if (m_last_retransmit_time > now - Time::from_seconds(retransmit_interval))
+    if (m_last_retransmit_time > now - Duration::from_seconds(retransmit_interval))
         return;
 
     dbgln_if(TCP_SOCKET_DEBUG, "TCPSocket({}) handling retransmit", this);

Kernel/Net/TCPSocket.h

@@ -216,11 +216,11 @@ private:
     u32 m_duplicate_acks { 0 };
 
     u32 m_last_ack_number_sent { 0 };
-    Time m_last_ack_sent_time;
+    Duration m_last_ack_sent_time;
 
     // FIXME: Make this configurable (sysctl)
     static constexpr u32 maximum_retransmits = 5;
-    Time m_last_retransmit_time;
+    Duration m_last_retransmit_time;
     u32 m_retransmit_attempts { 0 };
 
     // FIXME: Parse window size TCP option from the peer

Kernel/PerformanceManager.h

@@ -164,11 +164,11 @@ public:
 
     static void timer_tick(RegisterState const& regs)
     {
-        static Time last_wakeup;
+        static Duration last_wakeup;
         auto now = kgettimeofday();
-        constexpr auto ideal_interval = Time::from_microseconds(1000'000 / OPTIMAL_PROFILE_TICKS_PER_SECOND_RATE);
+        constexpr auto ideal_interval = Duration::from_microseconds(1000'000 / OPTIMAL_PROFILE_TICKS_PER_SECOND_RATE);
         auto expected_wakeup = last_wakeup + ideal_interval;
-        auto delay = (now > expected_wakeup) ? now - expected_wakeup : Time::from_microseconds(0);
+        auto delay = (now > expected_wakeup) ? now - expected_wakeup : Duration::from_microseconds(0);
         last_wakeup = now;
         auto* current_thread = Thread::current();
         // FIXME: We currently don't collect samples while idle.

Kernel/Process.cpp

@@ -635,7 +635,7 @@ ErrorOr<Process::ScopedDescriptionAllocation> Process::OpenFileDescriptions::all
     return EMFILE;
 }
 
-Time kgettimeofday()
+Duration kgettimeofday()
 {
     return TimeManagement::now();
 }

Kernel/Process.h

@@ -41,7 +41,7 @@
 namespace Kernel {
 
 MutexProtected<OwnPtr<KString>>& hostname();
-Time kgettimeofday();
+Duration kgettimeofday();
 
 #define ENUMERATE_PLEDGE_PROMISES         \
     __ENUMERATE_PLEDGE_PROMISE(stdio)     \

Kernel/StdLib.cpp

@@ -39,28 +39,28 @@ ErrorOr<NonnullOwnPtr<Kernel::KString>> try_copy_kstring_from_user(Userspace<cha
     return new_string;
 }
 
-ErrorOr<Time> copy_time_from_user(timespec const* ts_user)
+ErrorOr<Duration> copy_time_from_user(timespec const* ts_user)
 {
     timespec ts {};
     TRY(copy_from_user(&ts, ts_user, sizeof(timespec)));
-    return Time::from_timespec(ts);
+    return Duration::from_timespec(ts);
 }
 
-ErrorOr<Time> copy_time_from_user(timeval const* tv_user)
+ErrorOr<Duration> copy_time_from_user(timeval const* tv_user)
 {
     timeval tv {};
     TRY(copy_from_user(&tv, tv_user, sizeof(timeval)));
-    return Time::from_timeval(tv);
+    return Duration::from_timeval(tv);
 }
 
 template<>
-ErrorOr<Time> copy_time_from_user<timeval const>(Userspace<timeval const*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
+ErrorOr<Duration> copy_time_from_user<timeval const>(Userspace<timeval const*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
 template<>
-ErrorOr<Time> copy_time_from_user<timeval>(Userspace<timeval*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
+ErrorOr<Duration> copy_time_from_user<timeval>(Userspace<timeval*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
 template<>
-ErrorOr<Time> copy_time_from_user<timespec const>(Userspace<timespec const*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
+ErrorOr<Duration> copy_time_from_user<timespec const>(Userspace<timespec const*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
 template<>
-ErrorOr<Time> copy_time_from_user<timespec>(Userspace<timespec*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
+ErrorOr<Duration> copy_time_from_user<timespec>(Userspace<timespec*> src) { return copy_time_from_user(src.unsafe_userspace_ptr()); }
 
 Optional<u32> user_atomic_fetch_add_relaxed(u32 volatile* var, u32 val)
 {

Kernel/StdLib.h

@@ -15,10 +15,10 @@
 #include <Kernel/UnixTypes.h>
 
 ErrorOr<NonnullOwnPtr<Kernel::KString>> try_copy_kstring_from_user(Userspace<char const*>, size_t);
-ErrorOr<Time> copy_time_from_user(timespec const*);
+ErrorOr<Duration> copy_time_from_user(timespec const*);
-ErrorOr<Time> copy_time_from_user(timeval const*);
+ErrorOr<Duration> copy_time_from_user(timeval const*);
 template<typename T>
-ErrorOr<Time> copy_time_from_user(Userspace<T*>);
+ErrorOr<Duration> copy_time_from_user(Userspace<T*>);
 
 [[nodiscard]] Optional<u32> user_atomic_fetch_add_relaxed(u32 volatile* var, u32 val);
 [[nodiscard]] Optional<u32> user_atomic_exchange_relaxed(u32 volatile* var, u32 val);

Kernel/Storage/NVMe/NVMeController.cpp

@@ -50,7 +50,7 @@ UNMAP_AFTER_INIT ErrorOr<void> NVMeController::initialize(bool is_queue_polled)
     m_controller_regs = TRY(Memory::map_typed_writable<ControllerRegister volatile>(PhysicalAddress(m_bar)));
 
     auto caps = m_controller_regs->cap;
-    m_ready_timeout = Time::from_milliseconds((CAP_TO(caps) + 1) * 500); // CAP.TO is in 500ms units
+    m_ready_timeout = Duration::from_milliseconds((CAP_TO(caps) + 1) * 500); // CAP.TO is in 500ms units
 
     calculate_doorbell_stride();
     // IO queues + 1 admin queue

Kernel/Storage/NVMe/NVMeController.h

@@ -74,7 +74,7 @@ private:
     Memory::TypedMapping<ControllerRegister volatile> m_controller_regs;
     bool m_admin_queue_ready { false };
     size_t m_device_count { 0 };
-    AK::Time m_ready_timeout;
+    AK::Duration m_ready_timeout;
     u32 m_bar { 0 };
     u8 m_dbl_stride { 0 };
     PCI::InterruptType m_irq_type;

Kernel/Syscalls/alarm.cpp

@@ -20,7 +20,7 @@ ErrorOr<FlatPtr> Process::sys$alarm(unsigned seconds)
             bool was_in_use = false;
             if (TimerQueue::the().cancel_timer(*timer, &was_in_use)) {
                 // The timer hasn't fired. Round up the remaining time (if any)
-                Time remaining = timer->remaining() + Time::from_nanoseconds(999'999'999);
+                Duration remaining = timer->remaining() + Duration::from_nanoseconds(999'999'999);
                 previous_alarm_remaining = remaining.to_truncated_seconds();
             }
             // We had an existing alarm, must return a non-zero value here!
@@ -30,7 +30,7 @@ ErrorOr<FlatPtr> Process::sys$alarm(unsigned seconds)
 
         if (seconds > 0) {
             auto deadline = TimeManagement::the().current_time(CLOCK_REALTIME_COARSE);
-            deadline = deadline + Time::from_seconds(seconds);
+            deadline = deadline + Duration::from_seconds(seconds);
             if (!timer) {
                 timer = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Timer));
             }

Kernel/Syscalls/beep.cpp

@@ -21,7 +21,7 @@ ErrorOr<FlatPtr> Process::sys$beep(int tone)
         return EINVAL;
 #if ARCH(X86_64)
     PCSpeaker::tone_on(tone);
-    auto result = Thread::current()->sleep(Time::from_nanoseconds(200'000'000));
+    auto result = Thread::current()->sleep(Duration::from_nanoseconds(200'000'000));
     PCSpeaker::tone_off();
     if (result.was_interrupted())
         return EINTR;

Kernel/Syscalls/clock.cpp

@@ -82,7 +82,7 @@ ErrorOr<FlatPtr> Process::sys$clock_nanosleep(Userspace<Syscall::SC_clock_nanosl
     if (is_absolute) {
         was_interrupted = Thread::current()->sleep_until(params.clock_id, requested_sleep).was_interrupted();
     } else {
-        Time remaining_sleep;
+        Duration remaining_sleep;
         was_interrupted = Thread::current()->sleep(params.clock_id, requested_sleep, &remaining_sleep).was_interrupted();
         timespec remaining_sleep_ts = remaining_sleep.to_timespec();
         if (was_interrupted && params.remaining_sleep) {
@@ -123,7 +123,7 @@ ErrorOr<FlatPtr> Process::sys$adjtime(Userspace<timeval const*> user_delta, User
             return EPERM;
         auto delta = TRY(copy_time_from_user(user_delta));
 
-        // FIXME: Should use AK::Time internally
+        // FIXME: Should use AK::Duration internally
         TimeManagement::the().set_remaining_epoch_time_adjustment(delta.to_timespec());
     }
 

Kernel/Syscalls/resource.cpp

@@ -19,12 +19,12 @@ ErrorOr<FlatPtr> Process::sys$getrusage(int who, Userspace<rusage*> user_usage)
 
     switch (who) {
     case RUSAGE_SELF:
-        usage.ru_utime = Time::from_ticks(m_ticks_in_user, ticks_per_second).to_timeval();
+        usage.ru_utime = Duration::from_ticks(m_ticks_in_user, ticks_per_second).to_timeval();
-        usage.ru_stime = Time::from_ticks(m_ticks_in_kernel, ticks_per_second).to_timeval();
+        usage.ru_stime = Duration::from_ticks(m_ticks_in_kernel, ticks_per_second).to_timeval();
         break;
     case RUSAGE_CHILDREN:
-        usage.ru_utime = Time::from_ticks(m_ticks_in_user_for_dead_children, ticks_per_second).to_timeval();
+        usage.ru_utime = Duration::from_ticks(m_ticks_in_user_for_dead_children, ticks_per_second).to_timeval();
-        usage.ru_stime = Time::from_ticks(m_ticks_in_kernel_for_dead_children, ticks_per_second).to_timeval();
+        usage.ru_stime = Duration::from_ticks(m_ticks_in_kernel_for_dead_children, ticks_per_second).to_timeval();
         break;
     default:
         return EINVAL;

Kernel/Syscalls/socket.cpp

@@ -272,7 +272,7 @@ ErrorOr<FlatPtr> Process::sys$recvmsg(int sockfd, Userspace<struct msghdr*> user
         return 0;
 
     auto data_buffer = TRY(UserOrKernelBuffer::for_user_buffer((u8*)iovs[0].iov_base, iovs[0].iov_len));
-    Time timestamp {};
+    Duration timestamp {};
     bool blocking = (flags & MSG_DONTWAIT) ? false : description->is_blocking();
     auto result = socket.recvfrom(*description, data_buffer, iovs[0].iov_len, flags, user_addr, user_addr_length, timestamp, blocking);
 

Kernel/Tasks/SyncTask.cpp

@@ -18,7 +18,7 @@ UNMAP_AFTER_INIT void SyncTask::spawn()
         dbgln("VFS SyncTask is running");
         for (;;) {
             VirtualFileSystem::sync();
-            (void)Thread::current()->sleep(Time::from_seconds(1));
+            (void)Thread::current()->sleep(Duration::from_seconds(1));
         }
     }));
 }

Kernel/Thread.cpp

@@ -495,14 +495,14 @@ void Thread::relock_process(LockMode previous_locked, u32 lock_count_to_restore)
 }
 
 // NOLINTNEXTLINE(readability-make-member-function-const) False positive; We call block<SleepBlocker> which is not const
-auto Thread::sleep(clockid_t clock_id, Time const& duration, Time* remaining_time) -> BlockResult
+auto Thread::sleep(clockid_t clock_id, Duration const& duration, Duration* remaining_time) -> BlockResult
 {
     VERIFY(state() == Thread::State::Running);
     return Thread::current()->block<Thread::SleepBlocker>({}, Thread::BlockTimeout(false, &duration, nullptr, clock_id), remaining_time);
 }
 
 // NOLINTNEXTLINE(readability-make-member-function-const) False positive; We call block<SleepBlocker> which is not const
-auto Thread::sleep_until(clockid_t clock_id, Time const& deadline) -> BlockResult
+auto Thread::sleep_until(clockid_t clock_id, Duration const& deadline) -> BlockResult
 {
     VERIFY(state() == Thread::State::Running);
     return Thread::current()->block<Thread::SleepBlocker>({}, Thread::BlockTimeout(true, &deadline, nullptr, clock_id));

Kernel/Thread.h

@@ -159,16 +159,16 @@ public:
             : m_infinite(true)
         {
         }
-        explicit BlockTimeout(bool is_absolute, Time const* time, Time const* start_time = nullptr, clockid_t clock_id = CLOCK_MONOTONIC_COARSE);
+        explicit BlockTimeout(bool is_absolute, Duration const* time, Duration const* start_time = nullptr, clockid_t clock_id = CLOCK_MONOTONIC_COARSE);
 
-        Time const& absolute_time() const { return m_time; }
+        Duration const& absolute_time() const { return m_time; }
-        Time const* start_time() const { return !m_infinite ? &m_start_time : nullptr; }
+        Duration const* start_time() const { return !m_infinite ? &m_start_time : nullptr; }
         clockid_t clock_id() const { return m_clock_id; }
         bool is_infinite() const { return m_infinite; }
 
     private:
-        Time m_time {};
+        Duration m_time {};
-        Time m_start_time {};
+        Duration m_start_time {};
         clockid_t m_clock_id { CLOCK_MONOTONIC_COARSE };
         bool m_infinite { false };
     };
@@ -559,7 +559,7 @@ public:
 
     class SleepBlocker final : public Blocker {
     public:
-        explicit SleepBlocker(BlockTimeout const&, Time* = nullptr);
+        explicit SleepBlocker(BlockTimeout const&, Duration* = nullptr);
         virtual StringView state_string() const override { return "Sleeping"sv; }
         virtual Type blocker_type() const override { return Type::Sleep; }
         virtual BlockTimeout const& override_timeout(BlockTimeout const&) override;
@@ -571,7 +571,7 @@ public:
         void calculate_remaining();
 
         BlockTimeout m_deadline;
-        Time* m_remaining;
+        Duration* m_remaining;
     };
 
     class SelectBlocker final : public FileBlocker {
@@ -824,13 +824,13 @@ public:
         return block<Thread::WaitQueueBlocker>(timeout, wait_queue, forward<Args>(args)...);
     }
 
-    BlockResult sleep(clockid_t, Time const&, Time* = nullptr);
+    BlockResult sleep(clockid_t, Duration const&, Duration* = nullptr);
-    BlockResult sleep(Time const& duration, Time* remaining_time = nullptr)
+    BlockResult sleep(Duration const& duration, Duration* remaining_time = nullptr)
     {
         return sleep(CLOCK_MONOTONIC_COARSE, duration, remaining_time);
     }
-    BlockResult sleep_until(clockid_t, Time const&);
+    BlockResult sleep_until(clockid_t, Duration const&);
-    BlockResult sleep_until(Time const& duration)
+    BlockResult sleep_until(Duration const& duration)
     {
         return sleep_until(CLOCK_MONOTONIC_COARSE, duration);
     }

Kernel/ThreadBlockers.cpp

@@ -15,13 +15,13 @@
 
 namespace Kernel {
 
-Thread::BlockTimeout::BlockTimeout(bool is_absolute, Time const* time, Time const* start_time, clockid_t clock_id)
+Thread::BlockTimeout::BlockTimeout(bool is_absolute, Duration const* time, Duration const* start_time, clockid_t clock_id)
     : m_clock_id(clock_id)
     , m_infinite(!time)
 {
     if (m_infinite)
         return;
-    if (*time > Time::zero())
+    if (*time > Duration::zero())
         m_time = *time;
     m_start_time = start_time ? *start_time : TimeManagement::the().current_time(clock_id);
     if (!is_absolute)
@@ -272,7 +272,7 @@ auto Thread::WriteBlocker::override_timeout(BlockTimeout const& timeout) -> Bloc
     if (description.is_socket()) {
         auto const& socket = *description.socket();
         if (socket.has_send_timeout()) {
-            Time send_timeout = socket.send_timeout();
+            Duration send_timeout = socket.send_timeout();
             m_timeout = BlockTimeout(false, &send_timeout, timeout.start_time(), timeout.clock_id());
             if (timeout.is_infinite() || (!m_timeout.is_infinite() && m_timeout.absolute_time() < timeout.absolute_time()))
                 return m_timeout;
@@ -292,7 +292,7 @@ auto Thread::ReadBlocker::override_timeout(BlockTimeout const& timeout) -> Block
     if (description.is_socket()) {
         auto const& socket = *description.socket();
         if (socket.has_receive_timeout()) {
-            Time receive_timeout = socket.receive_timeout();
+            Duration receive_timeout = socket.receive_timeout();
             m_timeout = BlockTimeout(false, &receive_timeout, timeout.start_time(), timeout.clock_id());
             if (timeout.is_infinite() || (!m_timeout.is_infinite() && m_timeout.absolute_time() < timeout.absolute_time()))
                 return m_timeout;
@@ -301,7 +301,7 @@ auto Thread::ReadBlocker::override_timeout(BlockTimeout const& timeout) -> Block
     return timeout;
 }
 
-Thread::SleepBlocker::SleepBlocker(BlockTimeout const& deadline, Time* remaining)
+Thread::SleepBlocker::SleepBlocker(BlockTimeout const& deadline, Duration* remaining)
     : m_deadline(deadline)
     , m_remaining(remaining)
 {

Kernel/Time/TimeManagement.cpp

@@ -77,7 +77,7 @@ ErrorOr<void> TimeManagement::validate_clock_id(clockid_t clock_id)
     };
 }
 
-Time TimeManagement::current_time(clockid_t clock_id) const
+Duration TimeManagement::current_time(clockid_t clock_id) const
 {
     switch (clock_id) {
     case CLOCK_MONOTONIC:
@@ -101,15 +101,15 @@ bool TimeManagement::is_system_timer(HardwareTimerBase const& timer) const
     return &timer == m_system_timer.ptr();
 }
 
-void TimeManagement::set_epoch_time(Time ts)
+void TimeManagement::set_epoch_time(Duration ts)
 {
     InterruptDisabler disabler;
-    // FIXME: Should use AK::Time internally
+    // FIXME: Should use AK::Duration internally
     m_epoch_time = ts.to_timespec();
     m_remaining_epoch_time_adjustment = { 0, 0 };
 }
 
-Time TimeManagement::monotonic_time(TimePrecision precision) const
+Duration TimeManagement::monotonic_time(TimePrecision precision) const
 {
     // This is the time when last updated by an interrupt.
     u64 seconds;
@@ -144,10 +144,10 @@ Time TimeManagement::monotonic_time(TimePrecision precision) const
     VERIFY(ticks < m_time_ticks_per_second);
     u64 ns = ((u64)ticks * 1000000000ull) / m_time_ticks_per_second;
     VERIFY(ns < 1000000000ull);
-    return Time::from_timespec({ (i64)seconds, (i32)ns });
+    return Duration::from_timespec({ (i64)seconds, (i32)ns });
 }
 
-Time TimeManagement::epoch_time(TimePrecision) const
+Duration TimeManagement::epoch_time(TimePrecision) const
 {
     // TODO: Take into account precision
     timespec ts;
@@ -156,7 +156,7 @@ Time TimeManagement::epoch_time(TimePrecision) const
         update_iteration = m_update1.load(AK::MemoryOrder::memory_order_acquire);
         ts = m_epoch_time;
     } while (update_iteration != m_update2.load(AK::MemoryOrder::memory_order_acquire));
-    return Time::from_timespec(ts);
+    return Duration::from_timespec(ts);
 }
 
 u64 TimeManagement::uptime_ms() const
@@ -186,14 +186,14 @@ UNMAP_AFTER_INIT void TimeManagement::initialize([[maybe_unused]] u32 cpu)
             // would trigger a deadlock trying to get the s_the instance while
             // creating it.
             if (auto* apic_timer = APIC::the().initialize_timers(*s_the->m_system_timer)) {
-                dmesgln("Time: Using APIC timer as system timer");
+                dmesgln("Duration: Using APIC timer as system timer");
                 s_the->set_system_timer(*apic_timer);
             }
         }
     } else {
         VERIFY(s_the.is_initialized());
         if (auto* apic_timer = APIC::the().get_timer()) {
-            dmesgln("Time: Enable APIC timer on CPU #{}", cpu);
+            dmesgln("Duration: Enable APIC timer on CPU #{}", cpu);
             apic_timer->enable_local_timer();
         }
     }
@@ -226,26 +226,26 @@ time_t TimeManagement::ticks_per_second() const
     return m_time_keeper_timer->ticks_per_second();
 }
 
-Time TimeManagement::boot_time()
+Duration TimeManagement::boot_time()
 {
 #if ARCH(X86_64)
     return RTC::boot_time();
 #elif ARCH(AARCH64)
     // FIXME: Return correct boot time
-    return Time::from_seconds(0);
+    return Duration::from_seconds(0);
 #else
 #    error Unknown architecture
 #endif
 }
 
-Time TimeManagement::clock_resolution() const
+Duration TimeManagement::clock_resolution() const
 {
     long nanoseconds_per_tick = 1'000'000'000 / m_time_keeper_timer->ticks_per_second();
-    return Time::from_nanoseconds(nanoseconds_per_tick);
+    return Duration::from_nanoseconds(nanoseconds_per_tick);
 }
 
 UNMAP_AFTER_INIT TimeManagement::TimeManagement()
-    : m_time_page_region(MM.allocate_kernel_region(PAGE_SIZE, "Time page"sv, Memory::Region::Access::ReadWrite, AllocationStrategy::AllocateNow).release_value_but_fixme_should_propagate_errors())
+    : m_time_page_region(MM.allocate_kernel_region(PAGE_SIZE, "Duration page"sv, Memory::Region::Access::ReadWrite, AllocationStrategy::AllocateNow).release_value_but_fixme_should_propagate_errors())
 {
 #if ARCH(X86_64)
     bool probe_non_legacy_hardware_timers = !(kernel_command_line().is_legacy_time_enabled());
@@ -275,7 +275,7 @@ UNMAP_AFTER_INIT TimeManagement::TimeManagement()
 #endif
 }
 
-Time TimeManagement::now()
+Duration TimeManagement::now()
 {
     return s_the.ptr()->epoch_time();
 }
@@ -283,7 +283,7 @@ Time TimeManagement::now()
 UNMAP_AFTER_INIT Vector<HardwareTimerBase*> TimeManagement::scan_and_initialize_periodic_timers()
 {
     bool should_enable = is_hpet_periodic_mode_allowed();
-    dbgln("Time: Scanning for periodic timers");
+    dbgln("Duration: Scanning for periodic timers");
     Vector<HardwareTimerBase*> timers;
     for (auto& hardware_timer : m_hardware_timers) {
         if (hardware_timer->is_periodic_capable()) {
@@ -297,7 +297,7 @@ UNMAP_AFTER_INIT Vector<HardwareTimerBase*> TimeManagement::scan_and_initialize_
 
 UNMAP_AFTER_INIT Vector<HardwareTimerBase*> TimeManagement::scan_for_non_periodic_timers()
 {
-    dbgln("Time: Scanning for non-periodic timers");
+    dbgln("Duration: Scanning for non-periodic timers");
     Vector<HardwareTimerBase*> timers;
     for (auto& hardware_timer : m_hardware_timers) {
         if (!hardware_timer->is_periodic_capable())

Kernel/Time/TimeManagement.h

@@ -41,18 +41,18 @@ public:
     static u64 scheduler_current_time();
 
     static ErrorOr<void> validate_clock_id(clockid_t);
-    Time current_time(clockid_t) const;
+    Duration current_time(clockid_t) const;
-    Time monotonic_time(TimePrecision = TimePrecision::Coarse) const;
+    Duration monotonic_time(TimePrecision = TimePrecision::Coarse) const;
-    Time monotonic_time_raw() const
+    Duration monotonic_time_raw() const
     {
         // TODO: implement
         return monotonic_time(TimePrecision::Precise);
     }
-    Time epoch_time(TimePrecision = TimePrecision::Precise) const;
+    Duration epoch_time(TimePrecision = TimePrecision::Precise) const;
-    void set_epoch_time(Time);
+    void set_epoch_time(Duration);
     time_t ticks_per_second() const;
-    static Time boot_time();
+    static Duration boot_time();
-    Time clock_resolution() const;
+    Duration clock_resolution() const;
 
     bool is_system_timer(HardwareTimerBase const&) const;
 
@@ -64,12 +64,12 @@ public:
     bool disable_profile_timer();
 
     u64 uptime_ms() const;
-    static Time now();
+    static Duration now();
 
-    // FIXME: Should use AK::Time internally
+    // FIXME: Should use AK::Duration internally
     // FIXME: Also, most likely broken, because it does not check m_update[12] for in-progress updates.
     timespec remaining_epoch_time_adjustment() const { return m_remaining_epoch_time_adjustment; }
-    // FIXME: Should use AK::Time internally
+    // FIXME: Should use AK::Duration internally
     // FIXME: Also, most likely broken, because it does not check m_update[12] for in-progress updates.
     void set_remaining_epoch_time_adjustment(timespec const& adjustment) { m_remaining_epoch_time_adjustment = adjustment; }
 
@@ -102,7 +102,7 @@ private:
     Atomic<u32> m_update1 { 0 };
     u32 m_ticks_this_second { 0 };
     u64 m_seconds_since_boot { 0 };
-    // FIXME: Should use AK::Time internally
+    // FIXME: Should use AK::Duration internally
     timespec m_epoch_time { 0, 0 };
     timespec m_remaining_epoch_time_adjustment { 0, 0 };
     Atomic<u32> m_update2 { 0 };

Kernel/TimerQueue.cpp

@@ -16,12 +16,12 @@ namespace Kernel {
 static Singleton<TimerQueue> s_the;
 static Spinlock<LockRank::None> g_timerqueue_lock {};
 
-Time Timer::remaining() const
+Duration Timer::remaining() const
 {
     return m_remaining;
 }
 
-Time Timer::now(bool is_firing) const
+Duration Timer::now(bool is_firing) const
 {
     // NOTE: If is_firing is true then TimePrecision::Precise isn't really useful here.
     // We already have a quite precise time stamp because we just updated the time in the
@@ -55,7 +55,7 @@ UNMAP_AFTER_INIT TimerQueue::TimerQueue()
     m_ticks_per_second = TimeManagement::the().ticks_per_second();
 }
 
-bool TimerQueue::add_timer_without_id(NonnullRefPtr<Timer> timer, clockid_t clock_id, Time const& deadline, Function<void()>&& callback)
+bool TimerQueue::add_timer_without_id(NonnullRefPtr<Timer> timer, clockid_t clock_id, Duration const& deadline, Function<void()>&& callback)
 {
     if (deadline <= TimeManagement::the().current_time(clock_id))
         return false;
@@ -86,7 +86,7 @@ TimerId TimerQueue::add_timer(NonnullRefPtr<Timer>&& timer)
 
 void TimerQueue::add_timer_locked(NonnullRefPtr<Timer> timer)
 {
-    Time timer_expiration = timer->m_expires;
+    Duration timer_expiration = timer->m_expires;
 
     timer->clear_cancelled();
     timer->clear_callback_finished();

Kernel/TimerQueue.h

@@ -22,7 +22,7 @@ class Timer final : public AtomicRefCounted<Timer> {
     friend class TimerQueue;
 
 public:
-    void setup(clockid_t clock_id, Time expires, Function<void()>&& callback)
+    void setup(clockid_t clock_id, Duration expires, Function<void()>&& callback)
     {
         VERIFY(!is_queued());
         m_clock_id = clock_id;
@@ -35,13 +35,13 @@ public:
         VERIFY(!is_queued());
     }
 
-    Time remaining() const;
+    Duration remaining() const;
 
 private:
     TimerId m_id;
     clockid_t m_clock_id;
-    Time m_expires;
+    Duration m_expires;
-    Time m_remaining {};
+    Duration m_remaining {};
     Function<void()> m_callback;
     Atomic<bool> m_cancelled { false };
     Atomic<bool> m_callback_finished { false };
@@ -71,7 +71,7 @@ private:
     void clear_callback_finished() { m_callback_finished.store(false, AK::memory_order_release); }
     void set_callback_finished() { m_callback_finished.store(true, AK::memory_order_release); }
 
-    Time now(bool) const;
+    Duration now(bool) const;
 
     bool is_queued() const { return m_list_node.is_in_list(); }
 
@@ -88,14 +88,14 @@ public:
     static TimerQueue& the();
 
     TimerId add_timer(NonnullRefPtr<Timer>&&);
-    bool add_timer_without_id(NonnullRefPtr<Timer>, clockid_t, Time const&, Function<void()>&&);
+    bool add_timer_without_id(NonnullRefPtr<Timer>, clockid_t, Duration const&, Function<void()>&&);
     bool cancel_timer(Timer& timer, bool* was_in_use = nullptr);
     void fire();
 
 private:
     struct Queue {
         Timer::List list;
-        Time next_timer_due {};
+        Duration next_timer_due {};
     };
     void remove_timer_locked(Queue&, Timer&);
     void update_next_timer_due(Queue&);

Meta/Lagom/Tools/CodeGenerators/LibTimeZone/GenerateTimeZoneData.cpp

@@ -110,7 +110,7 @@ struct AK::Formatter<DaylightSavingsOffset> : Formatter<FormatString> {
     ErrorOr<void> format(FormatBuilder& builder, DaylightSavingsOffset const& dst_offset)
     {
         auto format_time = [&](auto year) {
-            return DeprecatedString::formatted("AK::Time::from_timestamp({}, 1, 1, 0, 0, 0, 0)", year);
+            return DeprecatedString::formatted("AK::Duration::from_timestamp({}, 1, 1, 0, 0, 0, 0)", year);
         };
 
         static DeprecatedString max_year_as_time("max_year_as_time"sv);
@@ -494,13 +494,13 @@ static ErrorOr<void> generate_time_zone_data_implementation(Core::InputBufferedF
 
 namespace TimeZone {
 
-static constexpr auto max_year_as_time = AK::Time::from_timestamp(NumericLimits<u16>::max(), 1, 1, 0, 0, 0, 0);
+static constexpr auto max_year_as_time = AK::Duration::from_timestamp(NumericLimits<u16>::max(), 1, 1, 0, 0, 0, 0);
 
 struct DateTime {
-    AK::Time time_since_epoch() const
+    AK::Duration time_since_epoch() const
     {
         // FIXME: This implementation does not take last_weekday, after_weekday, or before_weekday into account.
-        return AK::Time::from_timestamp(year, month, day, hour, minute, second, 0);
+        return AK::Duration::from_timestamp(year, month, day, hour, minute, second, 0);
     }
 
     u16 year { 0 };
@@ -530,7 +530,7 @@ struct TimeZoneOffset {
 };
 
 struct DaylightSavingsOffset {
-    AK::Time time_in_effect(AK::Time time) const
+    AK::Duration time_in_effect(AK::Duration time) const
     {
         auto in_effect = this->in_effect;
         in_effect.year = seconds_since_epoch_to_year(time.to_seconds());
@@ -539,8 +539,8 @@ struct DaylightSavingsOffset {
     }
 
     i64 offset { 0 };
-    AK::Time year_from {};
+    AK::Duration year_from {};
-    AK::Time year_to {};
+    AK::Duration year_to {};
     DateTime in_effect {};
 
     @string_index_type@ format { 0 };
@@ -635,7 +635,7 @@ static constexpr Array<Location, @size@> s_time_zone_locations { {
     TRY(append_string_conversions("Region"sv, "region"sv, time_zone_data.time_zone_region_names));
 
     generator.append(R"~~~(
-static Array<DaylightSavingsOffset const*, 2> find_dst_offsets(TimeZoneOffset const& time_zone_offset, AK::Time time)
+static Array<DaylightSavingsOffset const*, 2> find_dst_offsets(TimeZoneOffset const& time_zone_offset, AK::Duration time)
 {
     auto const& dst_rules = s_dst_offsets[time_zone_offset.dst_rule];
 
@@ -677,7 +677,7 @@ static Array<DaylightSavingsOffset const*, 2> find_dst_offsets(TimeZoneOffset co
     return { standard_offset, daylight_offset ? daylight_offset : standard_offset };
 }
 
-static Offset get_active_dst_offset(TimeZoneOffset const& time_zone_offset, AK::Time time)
+static Offset get_active_dst_offset(TimeZoneOffset const& time_zone_offset, AK::Duration time)
 {
     auto offsets = find_dst_offsets(time_zone_offset, time);
     if (offsets[0] == offsets[1])
@@ -697,7 +697,7 @@ static Offset get_active_dst_offset(TimeZoneOffset const& time_zone_offset, AK::
     return { offsets[1]->offset, InDST::Yes };
 }
 
-static TimeZoneOffset const& find_time_zone_offset(TimeZone time_zone, AK::Time time)
+static TimeZoneOffset const& find_time_zone_offset(TimeZone time_zone, AK::Duration time)
 {
     auto const& time_zone_offsets = s_time_zone_offsets[to_underlying(time_zone)];
 
@@ -713,7 +713,7 @@ static TimeZoneOffset const& find_time_zone_offset(TimeZone time_zone, AK::Time
     return time_zone_offsets[index];
 }
 
-Optional<Offset> get_time_zone_offset(TimeZone time_zone, AK::Time time)
+Optional<Offset> get_time_zone_offset(TimeZone time_zone, AK::Duration time)
 {
     auto const& time_zone_offset = find_time_zone_offset(time_zone, time);
 
@@ -729,7 +729,7 @@ Optional<Offset> get_time_zone_offset(TimeZone time_zone, AK::Time time)
     return dst_offset;
 }
 
-Optional<Array<NamedOffset, 2>> get_named_time_zone_offsets(TimeZone time_zone, AK::Time time)
+Optional<Array<NamedOffset, 2>> get_named_time_zone_offsets(TimeZone time_zone, AK::Duration time)
 {
     auto const& time_zone_offset = find_time_zone_offset(time_zone, time);
     Array<NamedOffset, 2> named_offsets;

Ports/SDL2/patches/0001-Add-SerenityOS-platform-support.patch

@@ -316,7 +316,7 @@ index 0000000000000000000000000000000000000000..e1cd5348b67c23c49b25f99f4f36e020
 +        return (static_cast<double>(input) - NumericLimits<i16>::min()) / NumericLimits<u16>::max() * 2. - 1.;
 +    };
 +
-+    auto const sleep_spec = Time::from_nanoseconds(100).to_timespec();
++    auto const sleep_spec = Duration::from_nanoseconds(100).to_timespec();
 +    auto input_buffer = reinterpret_cast<i16*>(h->mixbuf);
 +    auto input_samples = h->mixlen / that->spec.channels / sizeof(i16);
 +    size_t input_position = 0;

Tests/AK/CMakeLists.txt

@@ -74,7 +74,7 @@ set(AK_TEST_SOURCES
     TestStringFloatingPointConversions.cpp
     TestStringUtils.cpp
     TestStringView.cpp
-    TestTime.cpp
+    TestDuration.cpp
     TestTrie.cpp
     TestTuple.cpp
     TestTypeTraits.cpp

Tests/AK/TestDuration.cpp

@@ -9,7 +9,7 @@
 #include <AK/Time.h>
 #include <sys/time.h>
 
-#define EXPECT_TIME(t, s, ns)        \
+#define EXPECT_DURATION(t, s, ns)    \
     do {                             \
         auto ts = (t).to_timespec(); \
         EXPECT_EQ(ts.tv_sec, (s));   \
@@ -18,116 +18,116 @@
 
 TEST_CASE(is_sane)
 {
-    auto t0 = Time::from_seconds(0);
+    auto t0 = Duration::from_seconds(0);
-    auto t2 = Time::from_seconds(2);
+    auto t2 = Duration::from_seconds(2);
-    auto t5 = Time::from_seconds(5);
+    auto t5 = Duration::from_seconds(5);
-    auto tn3 = Time::from_seconds(-3);
+    auto tn3 = Duration::from_seconds(-3);
     EXPECT(t0 == t0);
     EXPECT(t2 == t2);
     EXPECT(t5 == t5);
     EXPECT(t0 != t2);
     EXPECT(t2 != tn3);
     EXPECT(t2 != t5);
-    EXPECT_TIME(t0, 0, 0);
+    EXPECT_DURATION(t0, 0, 0);
-    EXPECT_TIME(t2, 2, 0);
+    EXPECT_DURATION(t2, 2, 0);
-    EXPECT_TIME(t5, 5, 0);
+    EXPECT_DURATION(t5, 5, 0);
-    EXPECT_TIME(t2 + t5, 7, 0);
+    EXPECT_DURATION(t2 + t5, 7, 0);
-    EXPECT_TIME(tn3 + t2, -1, 0);
+    EXPECT_DURATION(tn3 + t2, -1, 0);
-    EXPECT_TIME(tn3 + t5, 2, 0);
+    EXPECT_DURATION(tn3 + t5, 2, 0);
 }
 
 TEST_CASE(limits)
 {
-    EXPECT_TIME(Time::min(), (i64)-0x8000'0000'0000'0000, 0);
+    EXPECT_DURATION(Duration::min(), (i64)-0x8000'0000'0000'0000, 0);
-    EXPECT_TIME(Time::max(), 0x7fff'ffff'ffff'ffff, 999'999'999);
+    EXPECT_DURATION(Duration::max(), 0x7fff'ffff'ffff'ffff, 999'999'999);
 }
 
 TEST_CASE(seconds_parsing)
 {
-    EXPECT_TIME(Time::from_seconds(0), 0, 0);
+    EXPECT_DURATION(Duration::from_seconds(0), 0, 0);
-    EXPECT_TIME(Time::from_seconds(42), 42, 0);
+    EXPECT_DURATION(Duration::from_seconds(42), 42, 0);
-    EXPECT_TIME(Time::from_seconds(-1), -1, 0);
+    EXPECT_DURATION(Duration::from_seconds(-1), -1, 0);
 
     // "6.4.4.1.5: The type of an integer constant is the first of the corresponding list in which its value can be represented."
     // In the case of "0x8000'0000", the list is "int, unsigned int, …", and unsigned int (u32) matches.
     // Then the unary minus: On unsigned 32-bit integers, -0x8000'0000 == 0x8000'0000, which only then is made signed again.
     // So we would pass a medium-large *positive* number to 'from_seconds', which is not what we want to test here.
     // That's why this is the only place that needs an "LL" suffix.
-    EXPECT_TIME(Time::from_seconds(-0x8000'0000LL), -0x8000'0000LL, 0);
+    EXPECT_DURATION(Duration::from_seconds(-0x8000'0000LL), -0x8000'0000LL, 0);
-    EXPECT_TIME(Time::from_seconds(-0x8000'0000'0000'0000), (i64)-0x8000'0000'0000'0000, 0);
+    EXPECT_DURATION(Duration::from_seconds(-0x8000'0000'0000'0000), (i64)-0x8000'0000'0000'0000, 0);
-    EXPECT_TIME(Time::from_seconds(0x7fff'ffff'ffff'ffff), 0x7fff'ffff'ffff'ffff, 0);
+    EXPECT_DURATION(Duration::from_seconds(0x7fff'ffff'ffff'ffff), 0x7fff'ffff'ffff'ffff, 0);
 }
 
 TEST_CASE(timespec_parsing)
 {
-    EXPECT_TIME(Time::from_timespec(timespec { 2, 4 }), 2, 4);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 2, 4 }), 2, 4);
-    EXPECT_TIME(Time::from_timespec(timespec { 1234, 5678 }), 1234, 5678);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 1234, 5678 }), 1234, 5678);
 
-    EXPECT_TIME(Time::from_timespec(timespec { 0, 1'000'000'000 }), 1, 0);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 0, 1'000'000'000 }), 1, 0);
-    EXPECT_TIME(Time::from_timespec(timespec { 8, 2'000'000'000 }), 10, 0);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 8, 2'000'000'000 }), 10, 0);
-    EXPECT_TIME(Time::from_timespec(timespec { 0, 2'147'483'647 }), 2, 147'483'647);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 0, 2'147'483'647 }), 2, 147'483'647);
 
-    EXPECT_TIME(Time::from_timespec(timespec { 1, -1 }), 0, 999'999'999);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 1, -1 }), 0, 999'999'999);
-    EXPECT_TIME(Time::from_timespec(timespec { 0, -1 }), -1, 999'999'999);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 0, -1 }), -1, 999'999'999);
-    EXPECT_TIME(Time::from_timespec(timespec { -1, 0 }), -1, 0);
+    EXPECT_DURATION(Duration::from_timespec(timespec { -1, 0 }), -1, 0);
-    EXPECT_TIME(Time::from_timespec(timespec { -1, 1'000'000'001 }), 0, 1);
+    EXPECT_DURATION(Duration::from_timespec(timespec { -1, 1'000'000'001 }), 0, 1);
-    EXPECT_TIME(Time::from_timespec(timespec { -2, 2'000'000'003 }), 0, 3);
+    EXPECT_DURATION(Duration::from_timespec(timespec { -2, 2'000'000'003 }), 0, 3);
-    EXPECT_TIME(Time::from_timespec(timespec { -2, 1'999'999'999 }), -1, 999'999'999);
+    EXPECT_DURATION(Duration::from_timespec(timespec { -2, 1'999'999'999 }), -1, 999'999'999);
 
-    EXPECT_TIME(Time::from_timespec(timespec { 0x7fff'ffff'ffff'fffe, 999'999'998 }), 0x7fff'ffff'ffff'fffe, 999'999'998);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 0x7fff'ffff'ffff'fffe, 999'999'998 }), 0x7fff'ffff'ffff'fffe, 999'999'998);
-    EXPECT_TIME(Time::from_timespec(timespec { 0x7fff'ffff'ffff'fffe, 1'999'999'998 }), 0x7fff'ffff'ffff'ffff, 999'999'998);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 0x7fff'ffff'ffff'fffe, 1'999'999'998 }), 0x7fff'ffff'ffff'ffff, 999'999'998);
-    EXPECT_TIME(Time::from_timespec(timespec { 0x7fff'ffff'ffff'fffe, 1'999'999'999 }), 0x7fff'ffff'ffff'ffff, 999'999'999);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 0x7fff'ffff'ffff'fffe, 1'999'999'999 }), 0x7fff'ffff'ffff'ffff, 999'999'999);
-    EXPECT_TIME(Time::from_timespec(timespec { 0x7fff'ffff'ffff'fffe, 2'000'000'000 }), 0x7fff'ffff'ffff'ffff, 999'999'999);
+    EXPECT_DURATION(Duration::from_timespec(timespec { 0x7fff'ffff'ffff'fffe, 2'000'000'000 }), 0x7fff'ffff'ffff'ffff, 999'999'999);
 
-    EXPECT_TIME(Time::from_timespec(timespec { -0x7fff'ffff'ffff'fffe, -1 }), -0x7fff'ffff'ffff'ffff, 999'999'999);
+    EXPECT_DURATION(Duration::from_timespec(timespec { -0x7fff'ffff'ffff'fffe, -1 }), -0x7fff'ffff'ffff'ffff, 999'999'999);
-    EXPECT_TIME(Time::from_timespec(timespec { -0x7fff'ffff'ffff'fffe, -999'999'999 }), -0x7fff'ffff'ffff'ffff, 1);
+    EXPECT_DURATION(Duration::from_timespec(timespec { -0x7fff'ffff'ffff'fffe, -999'999'999 }), -0x7fff'ffff'ffff'ffff, 1);
-    EXPECT_TIME(Time::from_timespec(timespec { -0x7fff'ffff'ffff'fffe, -1'999'999'999 }), (i64)-0x8000'0000'0000'0000, 1);
+    EXPECT_DURATION(Duration::from_timespec(timespec { -0x7fff'ffff'ffff'fffe, -1'999'999'999 }), (i64)-0x8000'0000'0000'0000, 1);
-    EXPECT_TIME(Time::from_timespec(timespec { -0x7fff'ffff'ffff'fffe, -2'000'000'000 }), (i64)-0x8000'0000'0000'0000, 0);
+    EXPECT_DURATION(Duration::from_timespec(timespec { -0x7fff'ffff'ffff'fffe, -2'000'000'000 }), (i64)-0x8000'0000'0000'0000, 0);
-    EXPECT_TIME(Time::from_timespec(timespec { -0x7fff'ffff'ffff'fffe, -2'000'000'001 }), (i64)-0x8000'0000'0000'0000, 0);
+    EXPECT_DURATION(Duration::from_timespec(timespec { -0x7fff'ffff'ffff'fffe, -2'000'000'001 }), (i64)-0x8000'0000'0000'0000, 0);
 }
 
 TEST_CASE(timeval_parsing)
 {
-    EXPECT_TIME(Time::from_timeval(timeval { 2, 4 }), 2, 4'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 2, 4 }), 2, 4'000);
-    EXPECT_TIME(Time::from_timeval(timeval { 1234, 5'678 }), 1234, 5'678'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 1234, 5'678 }), 1234, 5'678'000);
-    EXPECT_TIME(Time::from_timeval(timeval { -123, -45'678 }), -124, 954'322'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { -123, -45'678 }), -124, 954'322'000);
 
-    EXPECT_TIME(Time::from_timeval(timeval { 0, 1'000'000 }), 1, 0);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 0, 1'000'000 }), 1, 0);
-    EXPECT_TIME(Time::from_timeval(timeval { 0, 1'000'000'000 }), 1'000, 0);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 0, 1'000'000'000 }), 1'000, 0);
-    EXPECT_TIME(Time::from_timeval(timeval { 8, 2'000'000 }), 10, 0);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 8, 2'000'000 }), 10, 0);
-    EXPECT_TIME(Time::from_timeval(timeval { 0, 2'147'483'647 }), 2'147, 483'647'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 0, 2'147'483'647 }), 2'147, 483'647'000);
 
-    EXPECT_TIME(Time::from_timeval(timeval { 1, -1 }), 0, 999'999'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 1, -1 }), 0, 999'999'000);
-    EXPECT_TIME(Time::from_timeval(timeval { 0, -1 }), -1, 999'999'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 0, -1 }), -1, 999'999'000);
-    EXPECT_TIME(Time::from_timeval(timeval { -1, 0 }), -1, 0);
+    EXPECT_DURATION(Duration::from_timeval(timeval { -1, 0 }), -1, 0);
-    EXPECT_TIME(Time::from_timeval(timeval { -1, 1'000'001 }), 0, 1'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { -1, 1'000'001 }), 0, 1'000);
-    EXPECT_TIME(Time::from_timeval(timeval { -2, 2'000'003 }), 0, 3'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { -2, 2'000'003 }), 0, 3'000);
-    EXPECT_TIME(Time::from_timeval(timeval { -2, 1'999'999 }), -1, 999'999'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { -2, 1'999'999 }), -1, 999'999'000);
 
-    EXPECT_TIME(Time::from_timeval(timeval { 0x7fff'ffff'ffff'fffe, 999'998 }), 0x7fff'ffff'ffff'fffe, 999'998'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 0x7fff'ffff'ffff'fffe, 999'998 }), 0x7fff'ffff'ffff'fffe, 999'998'000);
-    EXPECT_TIME(Time::from_timeval(timeval { 0x7fff'ffff'ffff'fffe, 1'999'998 }), 0x7fff'ffff'ffff'ffff, 999'998'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 0x7fff'ffff'ffff'fffe, 1'999'998 }), 0x7fff'ffff'ffff'ffff, 999'998'000);
-    EXPECT_TIME(Time::from_timeval(timeval { 0x7fff'ffff'ffff'fffe, 1'999'999 }), 0x7fff'ffff'ffff'ffff, 999'999'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 0x7fff'ffff'ffff'fffe, 1'999'999 }), 0x7fff'ffff'ffff'ffff, 999'999'000);
-    EXPECT_TIME(Time::from_timeval(timeval { 0x7fff'ffff'ffff'fffe, 2'000'000 }), 0x7fff'ffff'ffff'ffff, 999'999'999);
+    EXPECT_DURATION(Duration::from_timeval(timeval { 0x7fff'ffff'ffff'fffe, 2'000'000 }), 0x7fff'ffff'ffff'ffff, 999'999'999);
 
-    EXPECT_TIME(Time::from_timeval(timeval { -0x7fff'ffff'ffff'fffe, -1 }), -0x7fff'ffff'ffff'ffff, 999'999'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { -0x7fff'ffff'ffff'fffe, -1 }), -0x7fff'ffff'ffff'ffff, 999'999'000);
-    EXPECT_TIME(Time::from_timeval(timeval { -0x7fff'ffff'ffff'fffe, -999'999 }), -0x7fff'ffff'ffff'ffff, 1'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { -0x7fff'ffff'ffff'fffe, -999'999 }), -0x7fff'ffff'ffff'ffff, 1'000);
-    EXPECT_TIME(Time::from_timeval(timeval { -0x7fff'ffff'ffff'fffe, -1'999'999 }), (i64)-0x8000'0000'0000'0000, 1'000);
+    EXPECT_DURATION(Duration::from_timeval(timeval { -0x7fff'ffff'ffff'fffe, -1'999'999 }), (i64)-0x8000'0000'0000'0000, 1'000);
-    EXPECT_TIME(Time::from_timeval(timeval { -0x7fff'ffff'ffff'fffe, -2'000'000 }), (i64)-0x8000'0000'0000'0000, 0);
+    EXPECT_DURATION(Duration::from_timeval(timeval { -0x7fff'ffff'ffff'fffe, -2'000'000 }), (i64)-0x8000'0000'0000'0000, 0);
-    EXPECT_TIME(Time::from_timeval(timeval { -0x7fff'ffff'ffff'fffe, -2'000'001 }), (i64)-0x8000'0000'0000'0000, 0);
+    EXPECT_DURATION(Duration::from_timeval(timeval { -0x7fff'ffff'ffff'fffe, -2'000'001 }), (i64)-0x8000'0000'0000'0000, 0);
 }
 
-#define TIME(s, ns) \
+#define DURATION(s, ns) \
-    Time::from_timespec(timespec { (s), (ns) })
+    Duration::from_timespec(timespec { (s), (ns) })
 
 TEST_CASE(addition)
 {
 #define EXPECT_ADDITION(s1, ns1, s2, ns2, sr, nsr)                       \
     do {                                                                 \
-        EXPECT_TIME(TIME(s1, ns1) + TIME(s2, ns2), sr, nsr); \
+        EXPECT_DURATION(DURATION(s1, ns1) + DURATION(s2, ns2), sr, nsr); \
-        EXPECT_TIME(TIME(s2, ns2) + TIME(s1, ns1), sr, nsr); \
+        EXPECT_DURATION(DURATION(s2, ns2) + DURATION(s1, ns1), sr, nsr); \
-        auto t = TIME(s1, ns1);                              \
+        auto t = DURATION(s1, ns1);                                      \
-        t += TIME(s2, ns2);                                  \
+        t += DURATION(s2, ns2);                                          \
-        EXPECT_TIME(t, sr, nsr);                             \
+        EXPECT_DURATION(t, sr, nsr);                                     \
     } while (0)
 
     EXPECT_ADDITION(11, 123'456'789, 22, 900'000'000, 34, 23'456'789);
@@ -158,10 +158,10 @@ TEST_CASE(subtraction)
 {
 #define EXPECT_SUBTRACTION(s1, ns1, s2, ns2, sr, nsr)                    \
     do {                                                                 \
-        EXPECT_TIME(TIME(s1, ns1) - TIME(s2, ns2), sr, nsr); \
+        EXPECT_DURATION(DURATION(s1, ns1) - DURATION(s2, ns2), sr, nsr); \
-        auto t = TIME(s1, ns1);                              \
+        auto t = DURATION(s1, ns1);                                      \
-        t -= TIME(s2, ns2);                                  \
+        t -= DURATION(s2, ns2);                                          \
-        EXPECT_TIME(t, sr, nsr);                             \
+        EXPECT_DURATION(t, sr, nsr);                                     \
     } while (0)
 
     EXPECT_SUBTRACTION(5, 0, 3, 0, 2, 0);
@@ -194,78 +194,78 @@ TEST_CASE(subtraction)
 
 TEST_CASE(rounding)
 {
-    EXPECT_EQ(TIME(2, 800'800'800).to_seconds(), 3);
+    EXPECT_EQ(DURATION(2, 800'800'800).to_seconds(), 3);
-    EXPECT_EQ(TIME(2, 800'800'800).to_milliseconds(), 2'801);
+    EXPECT_EQ(DURATION(2, 800'800'800).to_milliseconds(), 2'801);
-    EXPECT_EQ(TIME(2, 800'800'800).to_microseconds(), 2'800'801);
+    EXPECT_EQ(DURATION(2, 800'800'800).to_microseconds(), 2'800'801);
-    EXPECT_EQ(TIME(2, 800'800'800).to_nanoseconds(), 2'800'800'800);
+    EXPECT_EQ(DURATION(2, 800'800'800).to_nanoseconds(), 2'800'800'800);
-    EXPECT_EQ(TIME(-2, 800'800'800).to_seconds(), -2);
+    EXPECT_EQ(DURATION(-2, 800'800'800).to_seconds(), -2);
-    EXPECT_EQ(TIME(-2, 800'800'800).to_milliseconds(), -1'200);
+    EXPECT_EQ(DURATION(-2, 800'800'800).to_milliseconds(), -1'200);
-    EXPECT_EQ(TIME(-2, 800'800'800).to_microseconds(), -1'199'200);
+    EXPECT_EQ(DURATION(-2, 800'800'800).to_microseconds(), -1'199'200);
-    EXPECT_EQ(TIME(-2, 800'800'800).to_nanoseconds(), -1'199'199'200);
+    EXPECT_EQ(DURATION(-2, 800'800'800).to_nanoseconds(), -1'199'199'200);
 
-    EXPECT_EQ(TIME(0, 0).to_seconds(), 0);
+    EXPECT_EQ(DURATION(0, 0).to_seconds(), 0);
-    EXPECT_EQ(TIME(0, 0).to_milliseconds(), 0);
+    EXPECT_EQ(DURATION(0, 0).to_milliseconds(), 0);
-    EXPECT_EQ(TIME(0, 0).to_microseconds(), 0);
+    EXPECT_EQ(DURATION(0, 0).to_microseconds(), 0);
-    EXPECT_EQ(TIME(0, 0).to_nanoseconds(), 0);
+    EXPECT_EQ(DURATION(0, 0).to_nanoseconds(), 0);
 
-    EXPECT_EQ(TIME(0, 1).to_seconds(), 1);
+    EXPECT_EQ(DURATION(0, 1).to_seconds(), 1);
-    EXPECT_EQ(TIME(0, 1).to_milliseconds(), 1);
+    EXPECT_EQ(DURATION(0, 1).to_milliseconds(), 1);
-    EXPECT_EQ(TIME(0, 1).to_microseconds(), 1);
+    EXPECT_EQ(DURATION(0, 1).to_microseconds(), 1);
-    EXPECT_EQ(TIME(0, 1).to_nanoseconds(), 1);
+    EXPECT_EQ(DURATION(0, 1).to_nanoseconds(), 1);
-    EXPECT_EQ(TIME(0, -1).to_seconds(), -1);
+    EXPECT_EQ(DURATION(0, -1).to_seconds(), -1);
-    EXPECT_EQ(TIME(0, -1).to_milliseconds(), -1);
+    EXPECT_EQ(DURATION(0, -1).to_milliseconds(), -1);
-    EXPECT_EQ(TIME(0, -1).to_microseconds(), -1);
+    EXPECT_EQ(DURATION(0, -1).to_microseconds(), -1);
-    EXPECT_EQ(TIME(0, -1).to_nanoseconds(), -1);
+    EXPECT_EQ(DURATION(0, -1).to_nanoseconds(), -1);
 
-    EXPECT_EQ(TIME(-9223372037, 145'224'191).to_nanoseconds(), (i64)-0x8000'0000'0000'0000);
+    EXPECT_EQ(DURATION(-9223372037, 145'224'191).to_nanoseconds(), (i64)-0x8000'0000'0000'0000);
-    EXPECT_EQ(TIME(-9223372037, 145'224'192).to_nanoseconds(), (i64)-0x8000'0000'0000'0000);
+    EXPECT_EQ(DURATION(-9223372037, 145'224'192).to_nanoseconds(), (i64)-0x8000'0000'0000'0000);
-    EXPECT_EQ(TIME(-9223372037, 145'224'193).to_nanoseconds(), -0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(-9223372037, 145'224'193).to_nanoseconds(), -0x7fff'ffff'ffff'ffff);
-    EXPECT_EQ(TIME(9223372036, 854'775'806).to_nanoseconds(), 0x7fff'ffff'ffff'fffe);
+    EXPECT_EQ(DURATION(9223372036, 854'775'806).to_nanoseconds(), 0x7fff'ffff'ffff'fffe);
-    EXPECT_EQ(TIME(9223372036, 854'775'807).to_nanoseconds(), 0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(9223372036, 854'775'807).to_nanoseconds(), 0x7fff'ffff'ffff'ffff);
-    EXPECT_EQ(TIME(9223372036, 854'775'808).to_nanoseconds(), 0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(9223372036, 854'775'808).to_nanoseconds(), 0x7fff'ffff'ffff'ffff);
 }
 
 TEST_CASE(truncation)
 {
     // Sanity
-    EXPECT_EQ(TIME(2, 0).to_truncated_seconds(), 2);
+    EXPECT_EQ(DURATION(2, 0).to_truncated_seconds(), 2);
-    EXPECT_EQ(TIME(-2, 0).to_truncated_seconds(), -2);
+    EXPECT_EQ(DURATION(-2, 0).to_truncated_seconds(), -2);
-    EXPECT_EQ(TIME(2, 800'800'800).to_truncated_seconds(), 2);
+    EXPECT_EQ(DURATION(2, 800'800'800).to_truncated_seconds(), 2);
-    EXPECT_EQ(TIME(2, 800'800'800).to_truncated_milliseconds(), 2'800);
+    EXPECT_EQ(DURATION(2, 800'800'800).to_truncated_milliseconds(), 2'800);
-    EXPECT_EQ(TIME(2, 800'800'800).to_truncated_microseconds(), 2'800'800);
+    EXPECT_EQ(DURATION(2, 800'800'800).to_truncated_microseconds(), 2'800'800);
-    EXPECT_EQ(TIME(-2, -800'800'800).to_truncated_seconds(), -2);
+    EXPECT_EQ(DURATION(-2, -800'800'800).to_truncated_seconds(), -2);
-    EXPECT_EQ(TIME(-2, -800'800'800).to_truncated_milliseconds(), -2'800);
+    EXPECT_EQ(DURATION(-2, -800'800'800).to_truncated_milliseconds(), -2'800);
-    EXPECT_EQ(TIME(-2, -800'800'800).to_truncated_microseconds(), -2'800'800);
+    EXPECT_EQ(DURATION(-2, -800'800'800).to_truncated_microseconds(), -2'800'800);
 
     // Overflow, seconds
-    EXPECT_EQ(Time::min().to_truncated_seconds(), (i64)-0x8000'0000'0000'0000);
+    EXPECT_EQ(Duration::min().to_truncated_seconds(), (i64)-0x8000'0000'0000'0000);
-    EXPECT_EQ(Time::max().to_truncated_seconds(), 0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(Duration::max().to_truncated_seconds(), 0x7fff'ffff'ffff'ffff);
 
     // Overflow, milliseconds
-    EXPECT_EQ(TIME(-9223372036854776, 191'000'000).to_truncated_milliseconds(), (i64)-0x8000'0000'0000'0000);
+    EXPECT_EQ(DURATION(-9223372036854776, 191'000'000).to_truncated_milliseconds(), (i64)-0x8000'0000'0000'0000);
-    EXPECT_EQ(TIME(-9223372036854776, 192'000'000).to_truncated_milliseconds(), (i64)-0x8000'0000'0000'0000);
+    EXPECT_EQ(DURATION(-9223372036854776, 192'000'000).to_truncated_milliseconds(), (i64)-0x8000'0000'0000'0000);
-    EXPECT_EQ(TIME(-9223372036854776, 192'000'001).to_truncated_milliseconds(), -0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(-9223372036854776, 192'000'001).to_truncated_milliseconds(), -0x7fff'ffff'ffff'ffff);
-    EXPECT_EQ(TIME(-9223372036854776, 193'000'000).to_truncated_milliseconds(), -0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(-9223372036854776, 193'000'000).to_truncated_milliseconds(), -0x7fff'ffff'ffff'ffff);
-    EXPECT_EQ(TIME(9223372036854775, 806'000'000).to_truncated_milliseconds(), 0x7fff'ffff'ffff'fffe);
+    EXPECT_EQ(DURATION(9223372036854775, 806'000'000).to_truncated_milliseconds(), 0x7fff'ffff'ffff'fffe);
-    EXPECT_EQ(TIME(9223372036854775, 806'999'999).to_truncated_milliseconds(), 0x7fff'ffff'ffff'fffe);
+    EXPECT_EQ(DURATION(9223372036854775, 806'999'999).to_truncated_milliseconds(), 0x7fff'ffff'ffff'fffe);
-    EXPECT_EQ(TIME(9223372036854775, 807'000'000).to_truncated_milliseconds(), 0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(9223372036854775, 807'000'000).to_truncated_milliseconds(), 0x7fff'ffff'ffff'ffff);
-    EXPECT_EQ(TIME(9223372036854775, 808'000'000).to_truncated_milliseconds(), 0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(9223372036854775, 808'000'000).to_truncated_milliseconds(), 0x7fff'ffff'ffff'ffff);
 
     // Overflow, microseconds
-    EXPECT_EQ(TIME(-9223372036855, 224'191'000).to_truncated_microseconds(), (i64)-0x8000'0000'0000'0000);
+    EXPECT_EQ(DURATION(-9223372036855, 224'191'000).to_truncated_microseconds(), (i64)-0x8000'0000'0000'0000);
-    EXPECT_EQ(TIME(-9223372036855, 224'192'000).to_truncated_microseconds(), (i64)-0x8000'0000'0000'0000);
+    EXPECT_EQ(DURATION(-9223372036855, 224'192'000).to_truncated_microseconds(), (i64)-0x8000'0000'0000'0000);
-    EXPECT_EQ(TIME(-9223372036855, 224'192'001).to_truncated_microseconds(), (i64)-0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(-9223372036855, 224'192'001).to_truncated_microseconds(), (i64)-0x7fff'ffff'ffff'ffff);
-    EXPECT_EQ(TIME(-9223372036855, 224'193'000).to_truncated_microseconds(), (i64)-0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(-9223372036855, 224'193'000).to_truncated_microseconds(), (i64)-0x7fff'ffff'ffff'ffff);
-    EXPECT_EQ(TIME(9223372036854, 775'806'000).to_truncated_microseconds(), 0x7fff'ffff'ffff'fffe);
+    EXPECT_EQ(DURATION(9223372036854, 775'806'000).to_truncated_microseconds(), 0x7fff'ffff'ffff'fffe);
-    EXPECT_EQ(TIME(9223372036854, 775'806'999).to_truncated_microseconds(), 0x7fff'ffff'ffff'fffe);
+    EXPECT_EQ(DURATION(9223372036854, 775'806'999).to_truncated_microseconds(), 0x7fff'ffff'ffff'fffe);
-    EXPECT_EQ(TIME(9223372036854, 775'807'000).to_truncated_microseconds(), 0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(9223372036854, 775'807'000).to_truncated_microseconds(), 0x7fff'ffff'ffff'ffff);
-    EXPECT_EQ(TIME(9223372036854, 775'808'000).to_truncated_microseconds(), 0x7fff'ffff'ffff'ffff);
+    EXPECT_EQ(DURATION(9223372036854, 775'808'000).to_truncated_microseconds(), 0x7fff'ffff'ffff'ffff);
 }
 
 TEST_CASE(is_negative)
 {
-    auto small = Time::from_nanoseconds(10);
+    auto small = Duration::from_nanoseconds(10);
-    auto large = Time::from_nanoseconds(15);
+    auto large = Duration::from_nanoseconds(15);
     auto result = small - large;
     EXPECT_EQ(result.to_nanoseconds(), -5);
     EXPECT(result.is_negative());
@@ -479,7 +479,7 @@ TEST_CASE(years_to_days_since_epoch_span)
 TEST_CASE(user_defined_literals)
 {
     using namespace AK::TimeLiterals;
-    static_assert(Time::from_nanoseconds(123) == 123_ns, "Factory is same as UDL");
+    static_assert(Duration::from_nanoseconds(123) == 123_ns, "Factory is same as UDL");
 
     static_assert(100_ms > 10_ms, "LT UDL");
     static_assert(1000_ns == 1_us, "EQ UDL");

Tests/Kernel/TestKernelAlarm.cpp

@@ -17,7 +17,7 @@ public:
 
     static Core::ElapsedTimer signal_timer;
 
-    static constexpr auto timer_value = Time::from_seconds(1);
+    static constexpr auto timer_value = Duration::from_seconds(1);
 
     static void test_signal_handler(int signal)
     {
@@ -25,7 +25,7 @@ public:
         auto expected_duration = SuccessContext::timer_value;
 
         // Add a small buffer to allow for latency on the system.
-        constexpr auto buffer_duration = Time::from_milliseconds(50);
+        constexpr auto buffer_duration = Duration::from_milliseconds(50);
 
         dbgln("Signal Times - Actual: {} Expected: {}", actual_duration.to_milliseconds(), expected_duration.to_milliseconds());
         EXPECT(actual_duration >= expected_duration);
@@ -47,7 +47,7 @@ TEST_CASE(success_case)
     auto previous_time = alarm(SuccessContext::timer_value.to_seconds());
     EXPECT_EQ(previous_time, 0u);
 
-    auto sleep_time = SuccessContext::timer_value + Time::from_seconds(1);
+    auto sleep_time = SuccessContext::timer_value + Duration::from_seconds(1);
     sleep(sleep_time.to_seconds());
 
     EXPECT(SuccessContext::alarm_fired);
@@ -57,7 +57,7 @@ TEST_CASE(success_case)
 // See: https://github.com/SerenityOS/serenity/issues/9071
 TEST_CASE(regression_inifinite_loop)
 {
-    constexpr auto hour_long_timer_value = Time::from_seconds(60 * 60);
+    constexpr auto hour_long_timer_value = Duration::from_seconds(60 * 60);
 
     // Create an alarm timer significantly far into the future.
     auto previous_time = alarm(hour_long_timer_value.to_seconds());

Tests/LibLocale/TestDateTimeFormat.cpp

@@ -72,7 +72,7 @@ TEST_CASE(time_zone_name)
         TestData { "ar"sv, Locale::CalendarPatternStyle::ShortGeneric, "Africa/Accra"sv, "غرينتش"sv },
     };
 
-    constexpr auto jan_1_2022 = AK::Time::from_seconds(1640995200); // Saturday, January 1, 2022 12:00:00 AM
+    constexpr auto jan_1_2022 = AK::Duration::from_seconds(1640995200); // Saturday, January 1, 2022 12:00:00 AM
 
     for (auto const& test : test_data) {
         auto time_zone = MUST(Locale::format_time_zone(test.locale, test.time_zone, test.style, jan_1_2022));
@@ -122,7 +122,7 @@ TEST_CASE(time_zone_name_dst)
         TestData { "ar"sv, Locale::CalendarPatternStyle::Short, "Africa/Accra"sv, "غرينتش"sv },
     };
 
-    constexpr auto sep_19_2022 = AK::Time::from_seconds(1663553728); // Monday, September 19, 2022 2:15:28 AM
+    constexpr auto sep_19_2022 = AK::Duration::from_seconds(1663553728); // Monday, September 19, 2022 2:15:28 AM
 
     for (auto const& test : test_data) {
         auto time_zone = MUST(Locale::format_time_zone(test.locale, test.time_zone, test.style, sep_19_2022));
@@ -132,13 +132,13 @@ TEST_CASE(time_zone_name_dst)
 
 TEST_CASE(format_time_zone_offset)
 {
-    constexpr auto jan_1_1833 = AK::Time::from_seconds(-4323283200); // Tuesday, January 1, 1833 12:00:00 AM
+    constexpr auto jan_1_1833 = AK::Duration::from_seconds(-4323283200); // Tuesday, January 1, 1833 12:00:00 AM
-    constexpr auto jan_1_2022 = AK::Time::from_seconds(1640995200);  // Saturday, January 1, 2022 12:00:00 AM
+    constexpr auto jan_1_2022 = AK::Duration::from_seconds(1640995200);  // Saturday, January 1, 2022 12:00:00 AM
 
     struct TestData {
         StringView locale;
         Locale::CalendarPatternStyle style;
-        AK::Time time;
+        AK::Duration time;
         StringView time_zone;
         StringView expected_result;
     };

Tests/LibTimeZone/TestTimeZone.cpp

@@ -14,7 +14,7 @@ using enum TimeZone::InDST;
 
 static void test_offset(StringView time_zone, i64 time, i64 expected_offset, TimeZone::InDST expected_in_dst)
 {
-    auto actual_offset = TimeZone::get_time_zone_offset(time_zone, AK::Time::from_seconds(time));
+    auto actual_offset = TimeZone::get_time_zone_offset(time_zone, AK::Duration::from_seconds(time));
     VERIFY(actual_offset.has_value());
     EXPECT_EQ(actual_offset->seconds, expected_offset);
     EXPECT_EQ(actual_offset->in_dst, expected_in_dst);
@@ -183,7 +183,7 @@ TEST_CASE(get_time_zone_offset_with_dst)
 TEST_CASE(get_named_time_zone_offsets)
 {
     auto test_named_offsets = [](auto time_zone, i64 time, i64 expected_standard_offset, i64 expected_daylight_offset, auto expected_standard_name, auto expected_daylight_name) {
-        auto actual_offsets = TimeZone::get_named_time_zone_offsets(time_zone, AK::Time::from_seconds(time));
+        auto actual_offsets = TimeZone::get_named_time_zone_offsets(time_zone, AK::Duration::from_seconds(time));
         VERIFY(actual_offsets.has_value());
 
         EXPECT_EQ(actual_offsets->at(0).seconds, expected_standard_offset);

Userland/Applications/3DFileViewer/main.cpp

@@ -115,7 +115,7 @@ private:
     float m_rotation_speed = 60.f;
     bool m_show_frame_rate = false;
     int m_cycles = 0;
-    Time m_accumulated_time = {};
+    Duration m_accumulated_time = {};
     RefPtr<GUI::Label> m_stats;
     GLint m_wrap_s_mode = GL_REPEAT;
     GLint m_wrap_t_mode = GL_REPEAT;

Userland/Applications/Browser/CookieJar.cpp

@@ -286,7 +286,7 @@ void CookieJar::store_cookie(Web::Cookie::ParsedCookie const& parsed_cookie, con
 
     // 2. Create a new cookie with name cookie-name, value cookie-value. Set the creation-time and the last-access-time to the current date and time.
     Web::Cookie::Cookie cookie { parsed_cookie.name, parsed_cookie.value, parsed_cookie.same_site_attribute };
-    cookie.creation_time = Time::now_realtime();
+    cookie.creation_time = Duration::now_realtime();
     cookie.last_access_time = cookie.creation_time;
 
     if (parsed_cookie.expiry_time_from_max_age_attribute.has_value()) {
@@ -302,7 +302,7 @@ void CookieJar::store_cookie(Web::Cookie::ParsedCookie const& parsed_cookie, con
     } else {
         // Set the cookie's persistent-flag to false. Set the cookie's expiry-time to the latest representable date.
         cookie.persistent = false;
-        cookie.expiry_time = Time::max();
+        cookie.expiry_time = Duration::max();
     }
 
     // 4. If the cookie-attribute-list contains an attribute with an attribute-name of "Domain":
@@ -421,7 +421,7 @@ Vector<Web::Cookie::Cookie> CookieJar::get_matching_cookies(const URL& url, Depr
     });
 
     // 3. Update the last-access-time of each cookie in the cookie-list to the current date and time.
-    auto now = Time::now_realtime();
+    auto now = Duration::now_realtime();
 
     for (auto& cookie : cookie_list) {
         cookie.last_access_time = now;
@@ -462,7 +462,7 @@ static ErrorOr<Web::Cookie::Cookie> parse_cookie(ReadonlySpan<SQL::Value> row)
             return Error::from_string_view(name);
 
         auto time = value.to_int<i64>().value();
-        field = Time::from_seconds(time);
+        field = Duration::from_seconds(time);
         return {};
     };
 
@@ -624,7 +624,7 @@ void CookieJar::select_all_cookies_from_database(OnSelectAllCookiesResult on_res
 
 void CookieJar::purge_expired_cookies()
 {
-    auto now = Time::now_realtime().to_seconds();
+    auto now = Duration::now_realtime().to_seconds();
 
     m_storage.visit(
         [&](PersistedStorage& storage) {

Userland/Applications/Browser/StorageWidget.cpp

@@ -130,7 +130,7 @@ void StorageWidget::clear_session_storage_entries()
 void StorageWidget::delete_cookie(Web::Cookie::Cookie cookie)
 {
     // Delete cookie by making its expiry time in the past.
-    cookie.expiry_time = Time::from_seconds(0);
+    cookie.expiry_time = Duration::from_seconds(0);
     if (on_update_cookie)
         on_update_cookie(move(cookie));
 }

Userland/Applications/ClockSettings/TimeZoneSettingsWidget.cpp

@@ -133,7 +133,7 @@ void TimeZoneSettingsWidget::set_time_zone_location()
     m_time_zone_location = compute_time_zone_location();
 
     auto locale = Locale::default_locale();
-    auto now = AK::Time::now_realtime();
+    auto now = AK::Duration::now_realtime();
 
     auto name = Locale::format_time_zone(locale, m_time_zone, Locale::CalendarPatternStyle::Long, now).release_value_but_fixme_should_propagate_errors();
     auto offset = Locale::format_time_zone(locale, m_time_zone, Locale::CalendarPatternStyle::LongOffset, now).release_value_but_fixme_should_propagate_errors();

Userland/Applications/HexEditor/HexDocument.cpp

@@ -229,7 +229,7 @@ bool HexDocumentUndoCommand::merge_with(GUI::Command const& other)
             m_old[relative_start + i] = typed_other.m_old[i];
     }
 
-    m_timestamp = Time::now_monotonic();
+    m_timestamp = Duration::now_monotonic();
     return true;
 }
 

Userland/Applications/HexEditor/HexDocument.h

@@ -15,7 +15,7 @@
 #include <LibCore/Forward.h>
 #include <LibGUI/Command.h>
 
-constexpr Time COMMAND_COMMIT_TIME = Time::from_milliseconds(400);
+constexpr Duration COMMAND_COMMIT_TIME = Duration::from_milliseconds(400);
 
 class HexDocument : public Weakable<HexDocument> {
 public:
@@ -103,9 +103,9 @@ public:
     ErrorOr<void> try_add_changed_bytes(ByteBuffer old_values, ByteBuffer new_values);
 
 private:
-    bool commit_time_expired() const { return Time::now_monotonic() - m_timestamp >= COMMAND_COMMIT_TIME; }
+    bool commit_time_expired() const { return Duration::now_monotonic() - m_timestamp >= COMMAND_COMMIT_TIME; }
 
-    Time m_timestamp = Time::now_monotonic();
+    Duration m_timestamp = Duration::now_monotonic();
     WeakPtr<HexDocument> m_document;
     size_t m_position;
     ByteBuffer m_old;

Userland/Applications/Piano/AudioPlayerLoop.cpp

@@ -112,7 +112,7 @@ ErrorOr<void> AudioPlayerLoop::send_audio_to_server()
 
     auto sample_rate = static_cast<double>(m_resampler->target());
     auto buffer_play_time_ns = 1'000'000'000.0 / (sample_rate / static_cast<double>(Audio::AUDIO_BUFFER_SIZE));
-    auto good_sleep_time = Time::from_nanoseconds(static_cast<unsigned>(buffer_play_time_ns)).to_timespec();
+    auto good_sleep_time = Duration::from_nanoseconds(static_cast<unsigned>(buffer_play_time_ns)).to_timespec();
 
     size_t start_of_chunk_to_write = 0;
     while (start_of_chunk_to_write + Audio::AUDIO_BUFFER_SIZE <= m_remaining_samples.size()) {

Userland/Applications/ThemeEditor/MainWidget.cpp

@@ -347,7 +347,7 @@ void MainWidget::save_to_file(String const& filename, NonnullOwnPtr<Core::File>
     if (sync_result.is_error()) {
         GUI::MessageBox::show_error(window(), DeprecatedString::formatted("Failed to save theme file: {}", sync_result.error()));
     } else {
-        m_last_modified_time = Time::now_monotonic();
+        m_last_modified_time = Duration::now_monotonic();
         set_path(filename.to_deprecated_string());
         window()->set_modified(false);
     }
@@ -643,7 +643,7 @@ ErrorOr<void> MainWidget::load_from_file(String const& filename, NonnullOwnPtr<C
     ENUMERATE_PATH_ROLES(__ENUMERATE_PATH_ROLE)
 #undef __ENUMERATE_PATH_ROLE
 
-    m_last_modified_time = Time::now_monotonic();
+    m_last_modified_time = Duration::now_monotonic();
     window()->set_modified(false);
     return {};
 }

Userland/Applications/ThemeEditor/MainWidget.h

@@ -124,7 +124,7 @@ private:
 
     Optional<DeprecatedString> m_path;
     Gfx::Palette m_current_palette;
-    Time m_last_modified_time { Time::now_monotonic() };
+    Duration m_last_modified_time { Duration::now_monotonic() };
 
     RefPtr<AlignmentModel> m_alignment_model;
 

Userland/Applications/VideoPlayer/VideoPlayerWidget.cpp

@@ -59,7 +59,7 @@ ErrorOr<void> VideoPlayerWidget::setup_interface()
         update_seek_slider_max();
         auto progress = value / static_cast<double>(m_seek_slider->max());
         auto duration = m_playback_manager->duration().to_milliseconds();
-        Time timestamp = Time::from_milliseconds(static_cast<i64>(round(progress * static_cast<double>(duration))));
+        Duration timestamp = Duration::from_milliseconds(static_cast<i64>(round(progress * static_cast<double>(duration))));
         auto seek_mode_to_use = m_seek_slider->knob_dragging() ? seek_mode() : Video::PlaybackManager::SeekMode::Accurate;
         m_playback_manager->seek_to_timestamp(timestamp, seek_mode_to_use);
         set_current_timestamp(m_playback_manager->current_playback_time());
@@ -252,7 +252,7 @@ void VideoPlayerWidget::update_seek_slider_max()
     m_seek_slider->set_enabled(true);
 }
 
-void VideoPlayerWidget::set_current_timestamp(Time timestamp)
+void VideoPlayerWidget::set_current_timestamp(Duration timestamp)
 {
     set_time_label(timestamp);
     if (!m_playback_manager)
@@ -261,10 +261,10 @@ void VideoPlayerWidget::set_current_timestamp(Time timestamp)
     m_seek_slider->set_value(static_cast<int>(round(progress * m_seek_slider->max())), GUI::AllowCallback::No);
 }
 
-void VideoPlayerWidget::set_time_label(Time timestamp)
+void VideoPlayerWidget::set_time_label(Duration timestamp)
 {
     StringBuilder string_builder;
-    auto append_time = [&](Time time) {
+    auto append_time = [&](Duration time) {
         auto seconds = (time.to_milliseconds() + 500) / 1000;
         string_builder.append(human_readable_digital_time(seconds));
     };

Userland/Applications/VideoPlayer/VideoPlayerWidget.h

@@ -45,8 +45,8 @@ private:
     ErrorOr<void> setup_interface();
     void update_play_pause_icon();
     void update_seek_slider_max();
-    void set_current_timestamp(Time);
+    void set_current_timestamp(Duration);
-    void set_time_label(Time);
+    void set_time_label(Duration);
     void on_decoding_error(Video::DecoderError const&);
 
     void cycle_sizing_modes();

Userland/DevTools/HackStudio/LanguageClient.cpp

@@ -197,7 +197,7 @@ void ConnectionToServerWrapper::on_crash()
     show_crash_notification();
     m_connection.clear();
 
-    static constexpr Time max_crash_frequency = 10_sec;
+    static constexpr Duration max_crash_frequency = 10_sec;
     if (m_last_crash_timer.is_valid() && m_last_crash_timer.elapsed_time() < max_crash_frequency) {
         dbgln("LanguageServer crash frequency is too high");
         m_respawn_allowed = false;

Userland/Games/BrickGame/BrickGame.cpp

@@ -355,7 +355,7 @@ public:
                 break;
             m_level = i;
         }
-        auto const now { Time::now_realtime() };
+        auto const now { Duration::now_realtime() };
         auto const delay = s_level_map[m_level].m_delay;
         if (now - m_last_update > delay) {
             m_last_update = now;
@@ -372,7 +372,7 @@ public:
         m_block.random_shape();
         m_next_block.random_shape();
         update_shadow_hint_block();
-        m_last_update = Time::now_realtime();
+        m_last_update = Duration::now_realtime();
         m_state = GameState::Active;
     }
 
@@ -384,28 +384,28 @@ private:
     unsigned m_level {};
     unsigned m_score {};
     GameState m_state { GameState::GameOver };
-    Time m_last_update {};
+    Duration m_last_update {};
 
     struct LevelMap final {
         unsigned const m_score;
-        Time const m_delay;
+        Duration const m_delay;
     };
 
     static constexpr Array<LevelMap, 14> s_level_map = {
-        LevelMap { 0, Time::from_milliseconds(38000 / 60) },
+        LevelMap { 0, Duration::from_milliseconds(38000 / 60) },
-        LevelMap { 1000, Time::from_milliseconds(34000 / 60) },
+        LevelMap { 1000, Duration::from_milliseconds(34000 / 60) },
-        LevelMap { 2000, Time::from_milliseconds(29000 / 60) },
+        LevelMap { 2000, Duration::from_milliseconds(29000 / 60) },
-        LevelMap { 3000, Time::from_milliseconds(25000 / 60) },
+        LevelMap { 3000, Duration::from_milliseconds(25000 / 60) },
-        LevelMap { 4000, Time::from_milliseconds(22000 / 60) },
+        LevelMap { 4000, Duration::from_milliseconds(22000 / 60) },
-        LevelMap { 5000, Time::from_milliseconds(18000 / 60) },
+        LevelMap { 5000, Duration::from_milliseconds(18000 / 60) },
-        LevelMap { 6000, Time::from_milliseconds(15000 / 60) },
+        LevelMap { 6000, Duration::from_milliseconds(15000 / 60) },
-        LevelMap { 7000, Time::from_milliseconds(11000 / 60) },
+        LevelMap { 7000, Duration::from_milliseconds(11000 / 60) },
-        LevelMap { 8000, Time::from_milliseconds(7000 / 60) },
+        LevelMap { 8000, Duration::from_milliseconds(7000 / 60) },
-        LevelMap { 9000, Time::from_milliseconds(5000 / 60) },
+        LevelMap { 9000, Duration::from_milliseconds(5000 / 60) },
-        LevelMap { 10000, Time::from_milliseconds(4000 / 60) },
+        LevelMap { 10000, Duration::from_milliseconds(4000 / 60) },
-        LevelMap { 20000, Time::from_milliseconds(3000 / 60) },
+        LevelMap { 20000, Duration::from_milliseconds(3000 / 60) },
-        LevelMap { 30000, Time::from_milliseconds(2000 / 60) },
+        LevelMap { 30000, Duration::from_milliseconds(2000 / 60) },
-        LevelMap { 10000000, Time::from_milliseconds(1000 / 60) }
+        LevelMap { 10000000, Duration::from_milliseconds(1000 / 60) }
     };
 
     [[nodiscard]] RenderRequest set_current_block(Block const& block)

Userland/Libraries/LibAudio/ConnectionToServer.cpp

@@ -88,7 +88,7 @@ void ConnectionToServer::update_good_sleep_time()
     auto sample_rate = static_cast<double>(get_sample_rate());
     auto buffer_play_time_ns = 1'000'000'000.0 / (sample_rate / static_cast<double>(AUDIO_BUFFER_SIZE));
     // A factor of 1 should be good for now.
-    m_good_sleep_time = Time::from_nanoseconds(static_cast<unsigned>(buffer_play_time_ns)).to_timespec();
+    m_good_sleep_time = Duration::from_nanoseconds(static_cast<unsigned>(buffer_play_time_ns)).to_timespec();
 }
 
 // Non-realtime audio writing loop

Userland/Libraries/LibC/time.cpp

@@ -117,7 +117,7 @@ static struct tm* time_to_tm(struct tm* tm, time_t t, StringView time_zone)
         return nullptr;
     }
 
-    if (auto offset = TimeZone::get_time_zone_offset(time_zone, AK::Time::from_seconds(t)); offset.has_value()) {
+    if (auto offset = TimeZone::get_time_zone_offset(time_zone, AK::Duration::from_seconds(t)); offset.has_value()) {
         tm->tm_isdst = offset->in_dst == TimeZone::InDST::Yes;
         t += offset->seconds;
     }
@@ -171,12 +171,12 @@ static time_t tm_to_time(struct tm* tm, StringView time_zone)
     auto timestamp = ((days_since_epoch * 24 + tm->tm_hour) * 60 + tm->tm_min) * 60 + tm->tm_sec;
 
     if (tm->tm_isdst < 0) {
-        if (auto offset = TimeZone::get_time_zone_offset(time_zone, AK::Time::from_seconds(timestamp)); offset.has_value())
+        if (auto offset = TimeZone::get_time_zone_offset(time_zone, AK::Duration::from_seconds(timestamp)); offset.has_value())
             timestamp -= offset->seconds;
     } else {
         auto index = tm->tm_isdst == 0 ? 0 : 1;
 
-        if (auto offsets = TimeZone::get_named_time_zone_offsets(time_zone, AK::Time::from_seconds(timestamp)); offsets.has_value())
+        if (auto offsets = TimeZone::get_named_time_zone_offsets(time_zone, AK::Duration::from_seconds(timestamp)); offsets.has_value())
             timestamp -= offsets->at(index).seconds;
     }
 
@@ -407,7 +407,7 @@ void tzset()
         tzname[1] = const_cast<char*>(__utc);
     };
 
-    if (auto offsets = TimeZone::get_named_time_zone_offsets(__tzname, AK::Time::now_realtime()); offsets.has_value()) {
+    if (auto offsets = TimeZone::get_named_time_zone_offsets(__tzname, AK::Duration::now_realtime()); offsets.has_value()) {
         if (!offsets->at(0).name.copy_characters_to_buffer(__tzname_standard, TZNAME_MAX))
             return set_default_values();
         if (!offsets->at(1).name.copy_characters_to_buffer(__tzname_daylight, TZNAME_MAX))

Userland/Libraries/LibCore/ElapsedTimer.cpp

@@ -20,7 +20,7 @@ ElapsedTimer ElapsedTimer::start_new()
 void ElapsedTimer::start()
 {
     m_valid = true;
-    m_origin_time = m_precise ? Time::now_monotonic() : Time::now_monotonic_coarse();
+    m_origin_time = m_precise ? Duration::now_monotonic() : Duration::now_monotonic_coarse();
 }
 
 void ElapsedTimer::reset()
@@ -34,10 +34,10 @@ i64 ElapsedTimer::elapsed_milliseconds() const
     return elapsed_time().to_milliseconds();
 }
 
-Time ElapsedTimer::elapsed_time() const
+Duration ElapsedTimer::elapsed_time() const
 {
     VERIFY(is_valid());
-    auto now = m_precise ? Time::now_monotonic() : Time::now_monotonic_coarse();
+    auto now = m_precise ? Duration::now_monotonic() : Duration::now_monotonic_coarse();
     return now - m_origin_time;
 }
 

Userland/Libraries/LibCore/ElapsedTimer.h

@@ -24,7 +24,7 @@ public:
     void reset();
 
     i64 elapsed_milliseconds() const;
-    Time elapsed_time() const;
+    Duration elapsed_time() const;
 
     // FIXME: Move callers to elapsed_milliseconds(), remove this.
     i64 elapsed() const // milliseconds
@@ -32,10 +32,10 @@ public:
         return elapsed_milliseconds();
     }
 
-    Time const& origin_time() const { return m_origin_time; }
+    Duration const& origin_time() const { return m_origin_time; }
 
 private:
-    Time m_origin_time {};
+    Duration m_origin_time {};
     bool m_precise { false };
     bool m_valid { false };
 };

Userland/Libraries/LibCore/EventLoopImplementationUnix.cpp

@@ -29,14 +29,14 @@ thread_local ThreadData* s_thread_data;
 
 struct EventLoopTimer {
     int timer_id { 0 };
-    Time interval;
+    Duration interval;
-    Time fire_time;
+    Duration fire_time;
     bool should_reload { false };
     TimerShouldFireWhenNotVisible fire_when_not_visible { TimerShouldFireWhenNotVisible::No };
     WeakPtr<Object> owner;
 
-    void reload(Time const& now) { fire_time = now + interval; }
+    void reload(Duration const& now) { fire_time = now + interval; }
-    bool has_expired(Time const& now) const { return now > fire_time; }
+    bool has_expired(Duration const& now) const { return now > fire_time; }
 };
 
 struct ThreadData {
@@ -171,16 +171,16 @@ retry:
 
     // Figure out how long to wait at maximum.
     // This mainly depends on the PumpMode and whether we have pending events, but also the next expiring timer.
-    Time now;
+    Duration now;
     struct timeval timeout = { 0, 0 };
     bool should_wait_forever = false;
     if (mode == EventLoopImplementation::PumpMode::WaitForEvents && !has_pending_events) {
         auto next_timer_expiration = get_next_timer_expiration();
         if (next_timer_expiration.has_value()) {
-            now = Time::now_monotonic_coarse();
+            now = Duration::now_monotonic_coarse();
             auto computed_timeout = next_timer_expiration.value() - now;
             if (computed_timeout.is_negative())
-                computed_timeout = Time::zero();
+                computed_timeout = Duration::zero();
             timeout = computed_timeout.to_timeval();
         } else {
             should_wait_forever = true;
@@ -231,7 +231,7 @@ try_select_again:
     }
 
     if (!thread_data.timers.is_empty()) {
-        now = Time::now_monotonic_coarse();
+        now = Duration::now_monotonic_coarse();
     }
 
     // Handle expired timers.
@@ -349,10 +349,10 @@ void EventLoopImplementationUnix::notify_forked_and_in_child()
     thread_data.pid = getpid();
 }
 
-Optional<Time> EventLoopManagerUnix::get_next_timer_expiration()
+Optional<Duration> EventLoopManagerUnix::get_next_timer_expiration()
 {
-    auto now = Time::now_monotonic_coarse();
+    auto now = Duration::now_monotonic_coarse();
-    Optional<Time> soonest {};
+    Optional<Duration> soonest {};
     for (auto& it : ThreadData::the().timers) {
         auto& fire_time = it.value->fire_time;
         auto owner = it.value->owner.strong_ref();
@@ -489,8 +489,8 @@ int EventLoopManagerUnix::register_timer(Object& object, int milliseconds, bool
     auto& thread_data = ThreadData::the();
     auto timer = make<EventLoopTimer>();
     timer->owner = object;
-    timer->interval = Time::from_milliseconds(milliseconds);
+    timer->interval = Duration::from_milliseconds(milliseconds);
-    timer->reload(Time::now_monotonic_coarse());
+    timer->reload(Duration::now_monotonic_coarse());
     timer->should_reload = should_reload;
     timer->fire_when_not_visible = fire_when_not_visible;
     int timer_id = thread_data.id_allocator.allocate();

Userland/Libraries/LibCore/EventLoopImplementationUnix.h

@@ -28,7 +28,7 @@ public:
     virtual void unregister_signal(int handler_id) override;
 
     void wait_for_events(EventLoopImplementation::PumpMode);
-    static Optional<Time> get_next_timer_expiration();
+    static Optional<Duration> get_next_timer_expiration();
 
 private:
     void dispatch_signal(int signal_number);

Userland/Libraries/LibCore/FileWatcherMacOS.mm

@@ -18,10 +18,13 @@
 static_assert(false, "This file must only be used for macOS");
 #endif
 
-#define FixedPoint FixedPointMacOS // AK::FixedPoint conflicts with FixedPoint from MacTypes.h.
+// Several AK types conflict with MacOS types.
+#define FixedPoint FixedPointMacOS
+#define Duration DurationMacOS
 #include <CoreServices/CoreServices.h>
 #include <dispatch/dispatch.h>
 #undef FixedPoint
+#undef Duration
 
 namespace Core {
 

Userland/Libraries/LibCore/Socket.cpp

@@ -177,7 +177,7 @@ ErrorOr<void> PosixSocketHelper::set_close_on_exec(bool enabled)
     return {};
 }
 
-ErrorOr<void> PosixSocketHelper::set_receive_timeout(Time timeout)
+ErrorOr<void> PosixSocketHelper::set_receive_timeout(Duration timeout)
 {
     auto timeout_spec = timeout.to_timespec();
     return System::setsockopt(m_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout_spec, sizeof(timeout_spec));
@@ -231,13 +231,13 @@ ErrorOr<size_t> PosixSocketHelper::pending_bytes() const
     return static_cast<size_t>(value);
 }
 
-ErrorOr<NonnullOwnPtr<UDPSocket>> UDPSocket::connect(DeprecatedString const& host, u16 port, Optional<Time> timeout)
+ErrorOr<NonnullOwnPtr<UDPSocket>> UDPSocket::connect(DeprecatedString const& host, u16 port, Optional<Duration> timeout)
 {
     auto ip_address = TRY(resolve_host(host, SocketType::Datagram));
     return connect(SocketAddress { ip_address, port }, timeout);
 }
 
-ErrorOr<NonnullOwnPtr<UDPSocket>> UDPSocket::connect(SocketAddress const& address, Optional<Time> timeout)
+ErrorOr<NonnullOwnPtr<UDPSocket>> UDPSocket::connect(SocketAddress const& address, Optional<Duration> timeout)
 {
     auto socket = TRY(adopt_nonnull_own_or_enomem(new (nothrow) UDPSocket()));
 

Userland/Libraries/LibCore/Socket.h

@@ -141,7 +141,7 @@ public:
 
     ErrorOr<void> set_blocking(bool enabled);
     ErrorOr<void> set_close_on_exec(bool enabled);
-    ErrorOr<void> set_receive_timeout(Time timeout);
+    ErrorOr<void> set_receive_timeout(Duration timeout);
 
     void setup_notifier();
     RefPtr<Core::Notifier> notifier() { return m_notifier; }
@@ -215,8 +215,8 @@ private:
 
 class UDPSocket final : public Socket {
 public:
-    static ErrorOr<NonnullOwnPtr<UDPSocket>> connect(DeprecatedString const& host, u16 port, Optional<Time> timeout = {});
+    static ErrorOr<NonnullOwnPtr<UDPSocket>> connect(DeprecatedString const& host, u16 port, Optional<Duration> timeout = {});
-    static ErrorOr<NonnullOwnPtr<UDPSocket>> connect(SocketAddress const& address, Optional<Time> timeout = {});
+    static ErrorOr<NonnullOwnPtr<UDPSocket>> connect(SocketAddress const& address, Optional<Duration> timeout = {});
 
     UDPSocket(UDPSocket&& other)
         : Socket(static_cast<Socket&&>(other))

Userland/Libraries/LibDesktop/Screensaver.cpp

@@ -40,7 +40,7 @@ void Screensaver::mousedown_event(GUI::MouseEvent&)
 
 void Screensaver::mousemove_event(GUI::MouseEvent& event)
 {
-    auto now = AK::Time::now_monotonic();
+    auto now = AK::Duration::now_monotonic();
     if ((now - m_start_time).to_milliseconds() < mouse_tracking_delay_milliseconds)
         return;
 

Userland/Libraries/LibDesktop/Screensaver.h

@@ -30,7 +30,7 @@ public:
 
 protected:
     Screensaver()
-        : m_start_time(AK::Time::now_monotonic())
+        : m_start_time(AK::Duration::now_monotonic())
     {
     }
 
@@ -38,7 +38,7 @@ private:
     void trigger_exit();
 
     Optional<Gfx::IntPoint> m_mouse_origin;
-    AK::Time m_start_time;
+    AK::Duration m_start_time;
 };
 
 }

Userland/Libraries/LibGUI/MessageBox.cpp

@@ -63,12 +63,12 @@ ErrorOr<Dialog::ExecResult> MessageBox::try_show_error(Window* parent_window, St
     return TRY(try_show(parent_window, text, "Error"sv, GUI::MessageBox::Type::Error, GUI::MessageBox::InputType::OK));
 }
 
-Dialog::ExecResult MessageBox::ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<Time> last_unmodified_timestamp)
+Dialog::ExecResult MessageBox::ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<Duration> last_unmodified_timestamp)
 {
     return MUST(try_ask_about_unsaved_changes(parent_window, path, last_unmodified_timestamp));
 }
 
-ErrorOr<Dialog::ExecResult> MessageBox::try_ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<Time> last_unmodified_timestamp)
+ErrorOr<Dialog::ExecResult> MessageBox::try_ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<Duration> last_unmodified_timestamp)
 {
     StringBuilder builder;
     TRY(builder.try_append("Save changes to "sv));
@@ -79,7 +79,7 @@ ErrorOr<Dialog::ExecResult> MessageBox::try_ask_about_unsaved_changes(Window* pa
     TRY(builder.try_append(" before closing?"sv));
 
     if (!path.is_empty() && last_unmodified_timestamp.has_value()) {
-        auto age = (Time::now_monotonic() - *last_unmodified_timestamp).to_seconds();
+        auto age = (Duration::now_monotonic() - *last_unmodified_timestamp).to_seconds();
         auto readable_time = human_readable_time(age);
         TRY(builder.try_appendff("\nLast saved {} ago.", readable_time));
     }

Userland/Libraries/LibGUI/MessageBox.h

@@ -40,12 +40,12 @@ public:
 
     static ExecResult show(Window* parent_window, StringView text, StringView title, Type type = Type::None, InputType input_type = InputType::OK);
     static ExecResult show_error(Window* parent_window, StringView text);
-    static ExecResult ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<Time> last_unmodified_timestamp = {});
+    static ExecResult ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<Duration> last_unmodified_timestamp = {});
 
     static ErrorOr<ExecResult> try_show(Badge<FileSystemAccessServer::ConnectionFromClient>, i32 window_server_client_id, i32 parent_window_id, StringView text, StringView title);
     static ErrorOr<ExecResult> try_show(Window* parent_window, StringView text, StringView title, Type type = Type::None, InputType input_type = InputType::OK);
     static ErrorOr<ExecResult> try_show_error(Window* parent_window, StringView text);
-    static ErrorOr<ExecResult> try_ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<Time> last_unmodified_timestamp = {});
+    static ErrorOr<ExecResult> try_ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<Duration> last_unmodified_timestamp = {});
 
     static ErrorOr<NonnullRefPtr<MessageBox>> create(Window* parent_window, StringView text, StringView title, Type type = Type::None, InputType input_type = InputType::OK);
 

Userland/Libraries/LibGUI/TextDocument.cpp

@@ -894,7 +894,7 @@ bool InsertTextCommand::merge_with(GUI::Command const& other)
     m_text = builder.to_deprecated_string();
     m_range.set_end(typed_other.m_range.end());
 
-    m_timestamp = Time::now_monotonic();
+    m_timestamp = Duration::now_monotonic();
     return true;
 }
 
@@ -994,7 +994,7 @@ bool RemoveTextCommand::merge_with(GUI::Command const& other)
     m_text = builder.to_deprecated_string();
     m_range.set_start(typed_other.m_range.start());
 
-    m_timestamp = Time::now_monotonic();
+    m_timestamp = Duration::now_monotonic();
     return true;
 }
 

Userland/Libraries/LibGUI/TextDocument.h

@@ -26,7 +26,7 @@
 
 namespace GUI {
 
-constexpr Time COMMAND_COMMIT_TIME = Time::from_milliseconds(400);
+constexpr Duration COMMAND_COMMIT_TIME = Duration::from_milliseconds(400);
 
 struct TextDocumentSpan {
     TextRange range;
@@ -228,9 +228,9 @@ public:
     }
 
 protected:
-    bool commit_time_expired() const { return Time::now_monotonic() - m_timestamp >= COMMAND_COMMIT_TIME; }
+    bool commit_time_expired() const { return Duration::now_monotonic() - m_timestamp >= COMMAND_COMMIT_TIME; }
 
-    Time m_timestamp = Time::now_monotonic();
+    Duration m_timestamp = Duration::now_monotonic();
     TextDocument& m_document;
     TextDocument::Client const* m_client { nullptr };
 };

Userland/Libraries/LibGUI/UndoStack.cpp

@@ -81,7 +81,7 @@ void UndoStack::set_current_unmodified()
         return;
 
     m_clean_index = m_stack_index;
-    m_last_unmodified_timestamp = Time::now_monotonic();
+    m_last_unmodified_timestamp = Duration::now_monotonic();
 
     if (on_state_change)
         on_state_change();

Userland/Libraries/LibGUI/UndoStack.h

@@ -31,7 +31,7 @@ public:
     void set_current_unmodified();
     bool is_current_modified() const;
 
-    Optional<Time> last_unmodified_timestamp() const { return m_last_unmodified_timestamp; }
+    Optional<Duration> last_unmodified_timestamp() const { return m_last_unmodified_timestamp; }
 
     void clear();
 
@@ -44,7 +44,7 @@ private:
     Vector<NonnullOwnPtr<Command>> m_stack;
     size_t m_stack_index { 0 };
     Optional<size_t> m_clean_index;
-    Optional<Time> m_last_unmodified_timestamp;
+    Optional<Duration> m_last_unmodified_timestamp;
 };
 
 }

Userland/Libraries/LibIPC/Decoder.cpp

@@ -70,10 +70,10 @@ ErrorOr<JsonValue> decode(Decoder& decoder)
 }
 
 template<>
-ErrorOr<Time> decode(Decoder& decoder)
+ErrorOr<Duration> decode(Decoder& decoder)
 {
     auto nanoseconds = TRY(decoder.decode<i64>());
-    return AK::Time::from_nanoseconds(nanoseconds);
+    return AK::Duration::from_nanoseconds(nanoseconds);
 }
 
 template<>

Userland/Libraries/LibIPC/Decoder.h

@@ -94,7 +94,7 @@ template<>
 ErrorOr<JsonValue> decode(Decoder&);
 
 template<>
-ErrorOr<Time> decode(Decoder&);
+ErrorOr<Duration> decode(Decoder&);
 
 template<>
 ErrorOr<URL> decode(Decoder&);

Userland/Libraries/LibIPC/Encoder.cpp

@@ -85,7 +85,7 @@ ErrorOr<void> encode(Encoder& encoder, JsonValue const& value)
 }
 
 template<>
-ErrorOr<void> encode(Encoder& encoder, Time const& value)
+ErrorOr<void> encode(Encoder& encoder, Duration const& value)
 {
     return encoder.encode(value.to_nanoseconds());
 }

Userland/Libraries/LibIPC/Encoder.h

@@ -123,7 +123,7 @@ template<>
 ErrorOr<void> encode(Encoder&, JsonValue const&);
 
 template<>
-ErrorOr<void> encode(Encoder&, Time const&);
+ErrorOr<void> encode(Encoder&, Duration const&);
 
 template<>
 ErrorOr<void> encode(Encoder&, URL const&);

Userland/Libraries/LibJS/Bytecode/PassManager.h

@@ -38,7 +38,7 @@ public:
 
 protected:
     Core::ElapsedTimer m_timer;
-    Time m_time_difference {};
+    Duration m_time_difference {};
 };
 
 class PassManager : public Pass {