system/serenity
system/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity synced 2024-07-21 18:15:58 +00:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

Everywhere: Use MonotonicTime instead of Duration

Browse source 
This is easily identifiable by anyone who uses Duration::now_monotonic,
and any downstream users of that data.
This commit is contained in:
kleines Filmröllchen 2023-03-17 19:50:39 +01:00 committed by Jelle Raaijmakers
parent b2e7b8cdff
commit fc5cab5c21
29 changed files with 79 additions and 80 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
AK/Format.cpp
View file

@ -916,14 +916,14 @@ void vdbg(StringView fmtstr, TypeErasedFormatParams& params, bool newline)
#ifdef AK_OS_SERENITY
# ifdef KERNEL
if (Kernel::Processor::is_initialized() && TimeManagement::is_initialized()) {
struct timespec ts = TimeManagement::the().monotonic_time(TimePrecision::Coarse).to_timespec();
auto time = TimeManagement::the().monotonic_time(TimePrecision::Coarse);
if (Kernel::Thread::current()) {
auto& thread = *Kernel::Thread::current();
thread.process().name().with([&](auto& process_name) {
builder.appendff("{}.{:03} \033[34;1m[#{} {}({}:{})]\033[0m: ", ts.tv_sec, ts.tv_nsec / 1000000, Kernel::Processor::current_id(), process_name->view(), thread.pid().value(), thread.tid().value());
builder.appendff("{}.{:03} \033[34;1m[#{} {}({}:{})]\033[0m: ", time.truncated_seconds(), time.nanoseconds_within_second() / 1000000, Kernel::Processor::current_id(), process_name->view(), thread.pid().value(), thread.tid().value());
});
} else {
builder.appendff("{}.{:03} \033[34;1m[#{} Kernel]\033[0m: ", ts.tv_sec, ts.tv_nsec / 1000000, Kernel::Processor::current_id());
builder.appendff("{}.{:03} \033[34;1m[#{} Kernel]\033[0m: ", time.truncated_seconds(), time.nanoseconds_within_second() / 1000000, Kernel::Processor::current_id());
}
} else {
builder.appendff("\033[34;1m[Kernel]\033[0m: ");
@ -968,18 +968,16 @@ void vdmesgln(StringView fmtstr, TypeErasedFormatParams& params)
StringBuilder builder;
# ifdef AK_OS_SERENITY
struct timespec ts = {};
if (TimeManagement::is_initialized()) {
ts = TimeManagement::the().monotonic_time(TimePrecision::Coarse).to_timespec();
auto time = TimeManagement::the().monotonic_time(TimePrecision::Coarse);
if (Kernel::Processor::is_initialized() && Kernel::Thread::current()) {
auto& thread = *Kernel::Thread::current();
thread.process().name().with([&](auto& process_name) {
builder.appendff("{}.{:03} \033[34;1m[{}({}:{})]\033[0m: ", ts.tv_sec, ts.tv_nsec / 1000000, process_name->view(), thread.pid().value(), thread.tid().value());
builder.appendff("{}.{:03} \033[34;1m[{}({}:{})]\033[0m: ", time.truncated_seconds(), time.nanoseconds_within_second() / 1000000, process_name->view(), thread.pid().value(), thread.tid().value());
});
} else {
builder.appendff("{}.{:03} \033[34;1m[Kernel]\033[0m: ", ts.tv_sec, ts.tv_nsec / 1000000);
builder.appendff("{}.{:03} \033[34;1m[Kernel]\033[0m: ", time.truncated_seconds(), time.nanoseconds_within_second() / 1000000);
}
} else {
builder.appendff("\033[34;1m[Kernel]\033[0m: ");

6
Kernel/Devices/Audio/IntelHDA/Controller.cpp
View file

@ -328,12 +328,12 @@ ErrorOr<u32> Controller::get_pcm_output_sample_rate(size_t channel_index)
ErrorOr<void> wait_until(size_t delay_in_microseconds, size_t timeout_in_microseconds, Function<ErrorOr<bool>()> condition)
{
auto const timeout = Duration::from_microseconds(static_cast<i64>(timeout_in_microseconds));
auto const& time_management = TimeManagement::the();
// FIXME: Use monotonic time instead.
u64 start_microseconds = time_management.now().offset_to_epoch().to_microseconds();
auto start = time_management.monotonic_time(TimePrecision::Precise);
while (!TRY(condition())) {
microseconds_delay(delay_in_microseconds);
if ((time_management.now().offset_to_epoch().to_microseconds() - start_microseconds) >= timeout_in_microseconds)
if (time_management.monotonic_time(TimePrecision::Precise) - start >= timeout)
return ETIMEDOUT;
}
return {};

6
Kernel/Storage/SD/SDHostController.cpp
View file

@ -25,9 +25,9 @@ namespace Kernel {
static void delay(i64 nanoseconds)
{
auto start = TimeManagement::the().monotonic_time().to_nanoseconds();
auto end = start + nanoseconds;
while (TimeManagement::the().monotonic_time().to_nanoseconds() < end)
auto start = TimeManagement::the().monotonic_time();
auto end = start + Duration::from_nanoseconds(nanoseconds);
while (TimeManagement::the().monotonic_time() < end)
Processor::pause();
}

16
Kernel/Time/TimeManagement.cpp
View file

@ -54,7 +54,7 @@ static u64 (*s_scheduler_current_time)();
static u64 current_time_monotonic()
{
// We always need a precise timestamp here, we cannot rely on a coarse timestamp
return (u64)TimeManagement::the().monotonic_time(TimePrecision::Precise).to_nanoseconds();
return (u64)TimeManagement::the().monotonic_time(TimePrecision::Precise).nanoseconds();
}
u64 TimeManagement::scheduler_current_time()
@ -81,11 +81,11 @@ Duration TimeManagement::current_time(clockid_t clock_id) const
{
switch (clock_id) {
case CLOCK_MONOTONIC:
return monotonic_time(TimePrecision::Precise);
return monotonic_time(TimePrecision::Precise).time_since_start({});
case CLOCK_MONOTONIC_COARSE:
return monotonic_time(TimePrecision::Coarse);
return monotonic_time(TimePrecision::Coarse).time_since_start({});
case CLOCK_MONOTONIC_RAW:
return monotonic_time_raw();
return monotonic_time_raw().time_since_start({});
case CLOCK_REALTIME:
return epoch_time(TimePrecision::Precise).offset_to_epoch();
case CLOCK_REALTIME_COARSE:
@ -110,7 +110,7 @@ void TimeManagement::set_epoch_time(UnixDateTime ts)
m_remaining_epoch_time_adjustment = {};
}
Duration TimeManagement::monotonic_time(TimePrecision precision) const
MonotonicTime TimeManagement::monotonic_time(TimePrecision precision) const
{
// This is the time when last updated by an interrupt.
u64 seconds;
@ -145,7 +145,7 @@ Duration 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 Duration::from_timespec({ (i64)seconds, (i32)ns });
return MonotonicTime::from_hardware_time({}, seconds, ns);
}
UnixDateTime TimeManagement::epoch_time(TimePrecision) const
@ -162,7 +162,7 @@ UnixDateTime TimeManagement::epoch_time(TimePrecision) const
u64 TimeManagement::uptime_ms() const
{
auto mtime = monotonic_time().to_timespec();
auto mtime = monotonic_time().time_since_start({}).to_timespec();
// This overflows after 292 million years of uptime.
// Since this is only used for performance timestamps and sys$times, that's probably enough.
u64 ms = mtime.tv_sec * 1000ull;
@ -539,7 +539,7 @@ void TimeManagement::update_time_page()
auto& page = time_page();
u32 update_iteration = AK::atomic_fetch_add(&page.update2, 1u, AK::MemoryOrder::memory_order_acquire);
page.clocks[CLOCK_REALTIME_COARSE] = m_epoch_time.to_timespec();
page.clocks[CLOCK_MONOTONIC_COARSE] = monotonic_time(TimePrecision::Coarse).to_timespec();
page.clocks[CLOCK_MONOTONIC_COARSE] = monotonic_time(TimePrecision::Coarse).time_since_start({}).to_timespec();
AK::atomic_store(&page.update1, update_iteration + 1u, AK::MemoryOrder::memory_order_release);
}

5
Kernel/Time/TimeManagement.h
View file

@ -41,9 +41,10 @@ public:
static u64 scheduler_current_time();
static ErrorOr<void> validate_clock_id(clockid_t);
// This API cannot distinguish returned time types; prefer the clock-specific functions instead.
Duration current_time(clockid_t) const;
Duration monotonic_time(TimePrecision = TimePrecision::Coarse) const;
Duration monotonic_time_raw() const
MonotonicTime monotonic_time(TimePrecision = TimePrecision::Coarse) const;
MonotonicTime monotonic_time_raw() const
{
// TODO: implement
return monotonic_time(TimePrecision::Precise);

2
Userland/Applications/HexEditor/HexDocument.cpp
View file

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

4
Userland/Applications/HexEditor/HexDocument.h
View file

@ -103,9 +103,9 @@ public:
ErrorOr<void> try_add_changed_bytes(ByteBuffer old_values, ByteBuffer new_values);
private:
bool commit_time_expired() const { return Duration::now_monotonic() - m_timestamp >= COMMAND_COMMIT_TIME; }
bool commit_time_expired() const { return MonotonicTime::now() - m_timestamp >= COMMAND_COMMIT_TIME; }
Duration m_timestamp = Duration::now_monotonic();
MonotonicTime m_timestamp = MonotonicTime::now();
WeakPtr<HexDocument> m_document;
size_t m_position;
ByteBuffer m_old;

4
Userland/Applications/ThemeEditor/MainWidget.cpp
View file

@ -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 = Duration::now_monotonic();
m_last_modified_time = MonotonicTime::now();
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 = Duration::now_monotonic();
m_last_modified_time = MonotonicTime::now();
window()->set_modified(false);
return {};
}

2
Userland/Applications/ThemeEditor/MainWidget.h
View file

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

5
Userland/Libraries/LibCore/ElapsedTimer.cpp
View file

@ -20,13 +20,12 @@ ElapsedTimer ElapsedTimer::start_new()
void ElapsedTimer::start()
{
m_valid = true;
m_origin_time = m_precise ? Duration::now_monotonic() : Duration::now_monotonic_coarse();
m_origin_time = m_precise ? MonotonicTime::now() : MonotonicTime::now_coarse();
}
void ElapsedTimer::reset()
{
m_valid = false;
m_origin_time = {};
}
i64 ElapsedTimer::elapsed_milliseconds() const
@ -37,7 +36,7 @@ i64 ElapsedTimer::elapsed_milliseconds() const
Duration ElapsedTimer::elapsed_time() const
{
VERIFY(is_valid());
auto now = m_precise ? Duration::now_monotonic() : Duration::now_monotonic_coarse();
auto now = m_precise ? MonotonicTime::now() : MonotonicTime::now_coarse();
return now - m_origin_time;
}

4
Userland/Libraries/LibCore/ElapsedTimer.h
View file

@ -32,10 +32,10 @@ public:
return elapsed_milliseconds();
}
Duration const& origin_time() const { return m_origin_time; }
MonotonicTime const& origin_time() const { return m_origin_time; }
private:
Duration m_origin_time {};
MonotonicTime m_origin_time { MonotonicTime::now() };
bool m_precise { false };
bool m_valid { false };
};

20
Userland/Libraries/LibCore/EventLoopImplementationUnix.cpp
View file

@ -30,13 +30,13 @@ thread_local ThreadData* s_thread_data;
struct EventLoopTimer {
int timer_id { 0 };
Duration interval;
Duration fire_time;
MonotonicTime fire_time { MonotonicTime::now_coarse() };
bool should_reload { false };
TimerShouldFireWhenNotVisible fire_when_not_visible { TimerShouldFireWhenNotVisible::No };
WeakPtr<Object> owner;
void reload(Duration const& now) { fire_time = now + interval; }
bool has_expired(Duration const& now) const { return now > fire_time; }
void reload(MonotonicTime const& now) { fire_time = now + interval; }
bool has_expired(MonotonicTime const& now) const { return now > fire_time; }
};
struct ThreadData {
@ -171,13 +171,13 @@ 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.
Duration now;
MonotonicTime now = MonotonicTime::now_coarse();
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 = Duration::now_monotonic_coarse();
now = MonotonicTime::now();
auto computed_timeout = next_timer_expiration.value() - now;
if (computed_timeout.is_negative())
computed_timeout = Duration::zero();
@ -231,7 +231,7 @@ try_select_again:
}
if (!thread_data.timers.is_empty()) {
now = Duration::now_monotonic_coarse();
now = MonotonicTime::now_coarse();
}
// Handle expired timers.
@ -349,10 +349,10 @@ void EventLoopImplementationUnix::notify_forked_and_in_child()
thread_data.pid = getpid();
}
Optional<Duration> EventLoopManagerUnix::get_next_timer_expiration()
Optional<MonotonicTime> EventLoopManagerUnix::get_next_timer_expiration()
{
auto now = Duration::now_monotonic_coarse();
Optional<Duration> soonest {};
auto now = MonotonicTime::now_coarse();
Optional<MonotonicTime> soonest {};
for (auto& it : ThreadData::the().timers) {
auto& fire_time = it.value->fire_time;
auto owner = it.value->owner.strong_ref();
@ -490,7 +490,7 @@ int EventLoopManagerUnix::register_timer(Object& object, int milliseconds, bool
auto timer = make<EventLoopTimer>();
timer->owner = object;
timer->interval = Duration::from_milliseconds(milliseconds);
timer->reload(Duration::now_monotonic_coarse());
timer->reload(MonotonicTime::now_coarse());
timer->should_reload = should_reload;
timer->fire_when_not_visible = fire_when_not_visible;
int timer_id = thread_data.id_allocator.allocate();

3
Userland/Libraries/LibCore/EventLoopImplementationUnix.h
View file

@ -6,6 +6,7 @@
#pragma once
#include <AK/Time.h>
#include <LibCore/EventLoopImplementation.h>
namespace Core {
@ -28,7 +29,7 @@ public:
virtual void unregister_signal(int handler_id) override;
void wait_for_events(EventLoopImplementation::PumpMode);
static Optional<Duration> get_next_timer_expiration();
static Optional<MonotonicTime> get_next_timer_expiration();
private:
void dispatch_signal(int signal_number);

2
Userland/Libraries/LibDesktop/Screensaver.cpp
View file

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

4
Userland/Libraries/LibDesktop/Screensaver.h
View file

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

8
Userland/Libraries/LibGUI/MessageBox.cpp
View file

@ -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<Duration> last_unmodified_timestamp)
Dialog::ExecResult MessageBox::ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<MonotonicTime> last_unmodified_timestamp)
{
return MUST(try_ask_about_unsaved_changes(parent_window, path, last_unmodified_timestamp));
return MUST(try_ask_about_unsaved_changes(parent_window, path, move(last_unmodified_timestamp)));
}
ErrorOr<Dialog::ExecResult> MessageBox::try_ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<Duration> last_unmodified_timestamp)
ErrorOr<Dialog::ExecResult> MessageBox::try_ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<MonotonicTime> 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 = (Duration::now_monotonic() - *last_unmodified_timestamp).to_seconds();
auto age = (MonotonicTime::now() - *last_unmodified_timestamp).to_seconds();
auto readable_time = human_readable_time(age);
TRY(builder.try_appendff("\nLast saved {} ago.", readable_time));
}

4
Userland/Libraries/LibGUI/MessageBox.h
View file

@ -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<Duration> last_unmodified_timestamp = {});
static ExecResult ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<MonotonicTime> 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<Duration> last_unmodified_timestamp = {});
static ErrorOr<ExecResult> try_ask_about_unsaved_changes(Window* parent_window, StringView path, Optional<MonotonicTime> last_unmodified_timestamp = {});
static ErrorOr<NonnullRefPtr<MessageBox>> create(Window* parent_window, StringView text, StringView title, Type type = Type::None, InputType input_type = InputType::OK);

4
Userland/Libraries/LibGUI/TextDocument.cpp
View file

@ -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 = Duration::now_monotonic();
m_timestamp = MonotonicTime::now();
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 = Duration::now_monotonic();
m_timestamp = MonotonicTime::now();
return true;
}

4
Userland/Libraries/LibGUI/TextDocument.h
View file

@ -228,9 +228,9 @@ public:
}
protected:
bool commit_time_expired() const { return Duration::now_monotonic() - m_timestamp >= COMMAND_COMMIT_TIME; }
bool commit_time_expired() const { return MonotonicTime::now() - m_timestamp >= COMMAND_COMMIT_TIME; }
Duration m_timestamp = Duration::now_monotonic();
MonotonicTime m_timestamp = MonotonicTime::now();
TextDocument& m_document;
TextDocument::Client const* m_client { nullptr };
};

2
Userland/Libraries/LibGUI/UndoStack.cpp
View file

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

4
Userland/Libraries/LibGUI/UndoStack.h
View file

@ -31,7 +31,7 @@ public:
void set_current_unmodified();
bool is_current_modified() const;
Optional<Duration> last_unmodified_timestamp() const { return m_last_unmodified_timestamp; }
Optional<MonotonicTime> 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<Duration> m_last_unmodified_timestamp;
Optional<MonotonicTime> m_last_unmodified_timestamp;
};
}

4
Userland/Libraries/LibJS/Contrib/Test262/AgentObject.cpp
View file

@ -33,8 +33,8 @@ JS::ThrowCompletionOr<void> AgentObject::initialize(JS::Realm& realm)
JS_DEFINE_NATIVE_FUNCTION(AgentObject::monotonic_now)
{
auto time = Duration::now_monotonic();
auto milliseconds = time.to_milliseconds();
auto time = MonotonicTime::now();
auto milliseconds = time.milliseconds();
return Value(static_cast<double>(milliseconds));
}

14
Userland/Libraries/LibVideo/PlaybackManager.cpp
View file

@ -67,7 +67,7 @@ DecoderErrorOr<NonnullOwnPtr<PlaybackManager>> PlaybackManager::create(NonnullOw
},
"Media Decoder"sv));
playback_manager->m_playback_handler = make<SeekingStateHandler>(*playback_manager, false, Time::zero(), SeekMode::Fast);
playback_manager->m_playback_handler = make<SeekingStateHandler>(*playback_manager, false, Duration::zero(), SeekMode::Fast);
DECODER_TRY_ALLOC(playback_manager->m_playback_handler->on_enter());
playback_manager->m_decode_thread->start();
@ -217,7 +217,7 @@ void PlaybackManager::restart_playback()
void PlaybackManager::decode_and_queue_one_sample()
{
#if PLAYBACK_MANAGER_DEBUG
auto start_time = Duration::now_monotonic();
auto start_time = MonotonicTime::now();
#endif
FrameQueueItem item_to_enqueue;
@ -292,7 +292,7 @@ void PlaybackManager::decode_and_queue_one_sample()
VERIFY(!item_to_enqueue.is_empty());
#if PLAYBACK_MANAGER_DEBUG
dbgln("Media Decoder: Sample at {}ms took {}ms to decode, queue contains ~{} items", item_to_enqueue.timestamp().to_milliseconds(), (Time::now_monotonic() - start_time).to_milliseconds(), m_frame_queue.weak_used());
dbgln("Media Decoder: Sample at {}ms took {}ms to decode, queue contains ~{} items", item_to_enqueue.timestamp().to_milliseconds(), (MonotonicTime::now() - start_time).to_milliseconds(), m_frame_queue.weak_used());
#endif
auto wait = [&] {
@ -408,7 +408,7 @@ public:
private:
ErrorOr<void> on_enter() override
{
m_last_present_in_real_time = Duration::now_monotonic();
m_last_present_in_real_time = MonotonicTime::now();
return do_timed_state_update();
}
@ -429,7 +429,7 @@ private:
Duration current_time() const override
{
return manager().m_last_present_in_media_time + (Duration::now_monotonic() - m_last_present_in_real_time);
return manager().m_last_present_in_media_time + (MonotonicTime::now() - m_last_present_in_real_time);
}
ErrorOr<void> do_timed_state_update() override
@ -498,7 +498,7 @@ private:
// If we have a frame, send it for presentation.
if (should_present_frame) {
auto now = Duration::now_monotonic();
auto now = MonotonicTime::now();
manager().m_last_present_in_media_time += now - m_last_present_in_real_time;
m_last_present_in_real_time = now;
@ -520,7 +520,7 @@ private:
return {};
}
Duration m_last_present_in_real_time = Duration::zero();
MonotonicTime m_last_present_in_real_time = MonotonicTime::now_coarse();
};
class PlaybackManager::PausedStateHandler : public PlaybackManager::PlaybackStateHandler {

4
Userland/Libraries/LibWeb/HTML/HTMLMediaElement.cpp
View file

@ -1585,7 +1585,7 @@ WebIDL::ExceptionOr<void> HTMLMediaElement::dispatch_time_update_event()
ScopeGuard guard { [this] { m_running_time_update_event_handler = false; } };
m_running_time_update_event_handler = true;
m_last_time_update_event_time = Duration::now_monotonic();
m_last_time_update_event_time = MonotonicTime::now();
dispatch_event(TRY(DOM::Event::create(realm(), HTML::EventNames::timeupdate)));
return {};
@ -1617,7 +1617,7 @@ void HTMLMediaElement::time_marches_on(TimeMarchesOnReason reason)
auto dispatch_event = true;
if (m_last_time_update_event_time.has_value()) {
auto time_since_last_event = Duration::now_monotonic() - *m_last_time_update_event_time;
auto time_since_last_event = MonotonicTime::now() - *m_last_time_update_event_time;
dispatch_event = time_since_last_event.to_milliseconds() > 250;
}

2
Userland/Libraries/LibWeb/HTML/HTMLMediaElement.h
View file

@ -211,7 +211,7 @@ private:
Optional<DOM::DocumentLoadEventDelayer> m_delaying_the_load_event;
bool m_running_time_update_event_handler { false };
Optional<Duration> m_last_time_update_event_time;
Optional<MonotonicTime> m_last_time_update_event_time;
JS::GCPtr<DOM::DocumentObserver> m_document_observer;

2
Userland/Libraries/LibWeb/HighResolutionTime/Performance.cpp
View file

@ -51,7 +51,7 @@ JS::GCPtr<NavigationTiming::PerformanceTiming> Performance::timing()
double Performance::time_origin() const
{
return static_cast<double>(m_timer.origin_time().to_milliseconds());
return static_cast<double>(m_timer.origin_time().milliseconds());
}
// https://w3c.github.io/user-timing/#mark-method

2
Userland/Libraries/LibWeb/HighResolutionTime/TimeOrigin.cpp
View file

@ -55,7 +55,7 @@ DOMHighResTimeStamp coarsened_shared_current_time(bool cross_origin_isolated_cap
DOMHighResTimeStamp unsafe_shared_current_time()
{
// The unsafe shared current time must return the current value of the shared monotonic clock.
return Duration::now_monotonic().to_nanoseconds() / 1e6;
return MonotonicTime::now().truncated_seconds();
}
}

4
Userland/Libraries/LibWeb/WebDriver/ExecuteScript.cpp
View file

@ -329,7 +329,7 @@ ExecuteScriptResultSerialized execute_async_script(Web::Page& page, DeprecatedSt
auto* window = page.top_level_browsing_context().active_window();
auto& realm = window->realm();
auto& vm = window->vm();
auto start = Duration::now_monotonic();
auto start = MonotonicTime::now();
// 4. Let promise be a new Promise.
auto promise = JS::Promise::create(realm);
@ -383,7 +383,7 @@ ExecuteScriptResultSerialized execute_async_script(Web::Page& page, DeprecatedSt
vm.custom_data()->spin_event_loop_until([&] {
if (script_promise.state() != JS::Promise::State::Pending)
return true;
if (timeout.has_value() && (Duration::now_monotonic() - start) > Duration::from_seconds(static_cast<i64>(*timeout)))
if (timeout.has_value() && (MonotonicTime::now() - start) > Duration::from_seconds(static_cast<i64>(*timeout)))
return true;
return false;
});

4
Userland/Services/WebContent/WebDriverConnection.cpp
View file

@ -1958,7 +1958,7 @@ Gfx::IntRect WebDriverConnection::iconify_the_window()
ErrorOr<JsonArray, Web::WebDriver::Error> WebDriverConnection::find(StartNodeGetter&& start_node_getter, Web::WebDriver::LocationStrategy using_, StringView value)
{
// 1. Let end time be the current time plus the session implicit wait timeout.
auto end_time = Duration::now_monotonic() + Duration::from_milliseconds(static_cast<i64>(m_timeouts_configuration.implicit_wait_timeout));
auto end_time = MonotonicTime::now() + Duration::from_milliseconds(static_cast<i64>(m_timeouts_configuration.implicit_wait_timeout));
// 2. Let location strategy be equal to using.
auto location_strategy = using_;
@ -1985,7 +1985,7 @@ ErrorOr<JsonArray, Web::WebDriver::Error> WebDriverConnection::find(StartNodeGet
return true;
// 6. If elements returned is empty and the current time is less than end time return to step 4. Otherwise, continue to the next step.
return maybe_elements.value()->length() != 0 || Duration::now_monotonic() >= end_time;
return maybe_elements.value()->length() != 0 || MonotonicTime::now() >= end_time;
});
auto elements = TRY(maybe_elements);