LibWeb: Use enum instead of bool for CanUseCrossOriginIsolatedAPIs

Change the parameters types of the functions `coarsen_time` and
`coarsened_shared_current_time` from `bool` to
`CanUseCrossOriginIsolatedAPIs` for more coherence with the surrounding
code.

Author: NiccoloAntonelliDziri

Libraries/LibWeb/DOM/Document.cpp

@@ -377,7 +377,7 @@ WebIDL::ExceptionOr<GC::Ref<Document>> Document::create_and_initialize(Type type
     // AD-HOC: The response object no longer has an associated timing info object. For now, we use response's non-standard response time property,
     //         which represents the time that the time that the response object was created.
     auto response_creation_time = navigation_params.response->monotonic_response_time().nanoseconds() / 1e6;
-    load_timing_info.navigation_start_time = HighResolutionTime::coarsen_time(response_creation_time, HTML::relevant_settings_object(*window).cross_origin_isolated_capability() == HTML::CanUseCrossOriginIsolatedAPIs::Yes);
+    load_timing_info.navigation_start_time = HighResolutionTime::coarsen_time(response_creation_time, HTML::relevant_settings_object(*window).cross_origin_isolated_capability());
 
     // 9. Let document be a new Document, with
     //    type: type

Libraries/LibWeb/Fetch/Fetching/Fetching.cpp

@@ -190,7 +190,7 @@ GC::Ref<Infrastructure::FetchController> fetch(JS::Realm& realm, Infrastructure:
     //    shared current time given crossOriginIsolatedCapability, and render-blocking is set to request’s
     //    render-blocking.
     auto timing_info = Infrastructure::FetchTimingInfo::create(vm);
-    auto now = HighResolutionTime::coarsened_shared_current_time(cross_origin_isolated_capability == HTML::CanUseCrossOriginIsolatedAPIs::Yes);
+    auto now = HighResolutionTime::coarsened_shared_current_time(cross_origin_isolated_capability);
     timing_info->set_start_time(now);
     timing_info->set_post_redirect_start_time(now);
     timing_info->set_render_blocking(request.render_blocking());
@@ -1166,7 +1166,7 @@ GC::Ref<PendingResponse> http_fetch(JS::Realm& realm, Infrastructure::FetchParam
 
         // 3. Let serviceWorkerStartTime be the coarsened shared current time given fetchParams’s cross-origin isolated
         //    capability.
-        auto service_worker_start_time = HighResolutionTime::coarsened_shared_current_time(fetch_params.cross_origin_isolated_capability() == HTML::CanUseCrossOriginIsolatedAPIs::Yes);
+        auto service_worker_start_time = HighResolutionTime::coarsened_shared_current_time(fetch_params.cross_origin_isolated_capability());
 
         // FIXME: 4. Set response to the result of invoking handle fetch for requestForServiceWorker, with fetchParams’s
         //           controller and fetchParams’s cross-origin isolated capability.
@@ -1468,7 +1468,7 @@ GC::Ptr<PendingResponse> http_redirect_fetch(JS::Realm& realm, Infrastructure::F
 
     // 16. Set timingInfo’s redirect end time and post-redirect start time to the coarsened shared current time given
     //     fetchParams’s cross-origin isolated capability.
-    auto now = HighResolutionTime::coarsened_shared_current_time(fetch_params.cross_origin_isolated_capability() == HTML::CanUseCrossOriginIsolatedAPIs::Yes);
+    auto now = HighResolutionTime::coarsened_shared_current_time(fetch_params.cross_origin_isolated_capability());
     timing_info->set_redirect_end_time(now);
     timing_info->set_post_redirect_start_time(now);
 

Libraries/LibWeb/Fetch/Infrastructure/FetchTimingInfo.cpp

@@ -39,22 +39,20 @@ GC::Ref<FetchTimingInfo> create_opaque_timing_info(JS::VM& vm, FetchTimingInfo c
 
 void FetchTimingInfo::update_final_timings(Requests::RequestTimingInfo const& final_timings, HTML::CanUseCrossOriginIsolatedAPIs cross_origin_isolated_capability)
 {
-    bool has_cross_origin_isolated_capability = cross_origin_isolated_capability == HTML::CanUseCrossOriginIsolatedAPIs::Yes;
-
     auto domain_lookup_start_time_milliseconds = m_start_time + (static_cast<HighResolutionTime::DOMHighResTimeStamp>(final_timings.domain_lookup_start_microseconds) / 1000.0);
-    auto coarsened_domain_lookup_start_time = HighResolutionTime::coarsen_time(domain_lookup_start_time_milliseconds, has_cross_origin_isolated_capability);
+    auto coarsened_domain_lookup_start_time = HighResolutionTime::coarsen_time(domain_lookup_start_time_milliseconds, cross_origin_isolated_capability);
 
     auto domain_lookup_end_time_milliseconds = m_start_time + (static_cast<HighResolutionTime::DOMHighResTimeStamp>(final_timings.domain_lookup_end_microseconds) / 1000.0);
-    auto coarsened_domain_lookup_end_time = HighResolutionTime::coarsen_time(domain_lookup_end_time_milliseconds, has_cross_origin_isolated_capability);
+    auto coarsened_domain_lookup_end_time = HighResolutionTime::coarsen_time(domain_lookup_end_time_milliseconds, cross_origin_isolated_capability);
 
     auto connect_start_time_milliseconds = m_start_time + (static_cast<HighResolutionTime::DOMHighResTimeStamp>(final_timings.connect_start_microseconds) / 1000.0);
-    auto coarsened_connection_start_time = HighResolutionTime::coarsen_time(connect_start_time_milliseconds, has_cross_origin_isolated_capability);
+    auto coarsened_connection_start_time = HighResolutionTime::coarsen_time(connect_start_time_milliseconds, cross_origin_isolated_capability);
 
     auto connect_end_time_milliseconds = m_start_time + (static_cast<HighResolutionTime::DOMHighResTimeStamp>(final_timings.connect_end_microseconds) / 1000.0);
-    auto coarsened_connection_end_time = HighResolutionTime::coarsen_time(connect_end_time_milliseconds, has_cross_origin_isolated_capability);
+    auto coarsened_connection_end_time = HighResolutionTime::coarsen_time(connect_end_time_milliseconds, cross_origin_isolated_capability);
 
     auto secure_connect_start_time_milliseconds = m_start_time + (static_cast<HighResolutionTime::DOMHighResTimeStamp>(final_timings.secure_connect_start_microseconds) / 1000.0);
-    auto coarsened_secure_connection_start_time = HighResolutionTime::coarsen_time(secure_connect_start_time_milliseconds, has_cross_origin_isolated_capability);
+    auto coarsened_secure_connection_start_time = HighResolutionTime::coarsen_time(secure_connect_start_time_milliseconds, cross_origin_isolated_capability);
 
     m_final_connection_timing_info = ConnectionTimingInfo {
         .domain_lookup_start_time = coarsened_domain_lookup_start_time,
@@ -66,11 +64,11 @@ void FetchTimingInfo::update_final_timings(Requests::RequestTimingInfo const& fi
     };
 
     auto request_start_time_milliseconds = m_start_time + (static_cast<HighResolutionTime::DOMHighResTimeStamp>(final_timings.request_start_microseconds) / 1000.0);
-    auto coarsened_request_start_time = HighResolutionTime::coarsen_time(request_start_time_milliseconds, has_cross_origin_isolated_capability);
+    auto coarsened_request_start_time = HighResolutionTime::coarsen_time(request_start_time_milliseconds, cross_origin_isolated_capability);
     m_final_network_request_start_time = coarsened_request_start_time;
 
     auto response_start_time_milliseconds = m_start_time + (static_cast<HighResolutionTime::DOMHighResTimeStamp>(final_timings.response_start_microseconds) / 1000.0);
-    auto coarsened_response_start_time = HighResolutionTime::coarsen_time(response_start_time_milliseconds, has_cross_origin_isolated_capability);
+    auto coarsened_response_start_time = HighResolutionTime::coarsen_time(response_start_time_milliseconds, cross_origin_isolated_capability);
     m_final_network_response_start_time = coarsened_response_start_time;
 }
 

Libraries/LibWeb/HTML/BrowsingContext.cpp

@@ -204,7 +204,7 @@ WebIDL::ExceptionOr<BrowsingContext::BrowsingContextAndDocument> BrowsingContext
     auto load_timing_info = DOM::DocumentLoadTimingInfo();
     load_timing_info.navigation_start_time = HighResolutionTime::coarsen_time(
         unsafe_context_creation_time,
-        as<WindowEnvironmentSettingsObject>(Bindings::principal_host_defined_environment_settings_object(window->realm())).cross_origin_isolated_capability() == CanUseCrossOriginIsolatedAPIs::Yes);
+        as<WindowEnvironmentSettingsObject>(Bindings::principal_host_defined_environment_settings_object(window->realm())).cross_origin_isolated_capability());
 
     // 15. Let document be a new Document, with:
     auto document = HTML::HTMLDocument::create(window->realm());

Libraries/LibWeb/HTML/Scripting/Environments.h

@@ -154,7 +154,7 @@ struct WEB_API EnvironmentSettingsObject : public Environment {
         auto unsafe_walltime = HighResolutionTime::wall_clock_unsafe_current_time();
 
         // 2. Return the result of calling coarsen time with unsafeWallTime and settingsObject's cross-origin isolated capability.
-        return HighResolutionTime::coarsen_time(unsafe_walltime, cross_origin_isolated_capability() == HTML::CanUseCrossOriginIsolatedAPIs::Yes);
+        return HighResolutionTime::coarsen_time(unsafe_walltime, cross_origin_isolated_capability());
     }
 
 protected:

Libraries/LibWeb/HTML/Scripting/WorkerEnvironmentSettingsObject.cpp

@@ -114,7 +114,7 @@ CanUseCrossOriginIsolatedAPIs WorkerEnvironmentSettingsObject::cross_origin_isol
 double WorkerEnvironmentSettingsObject::time_origin() const
 {
     // Return the result of coarsening unsafeWorkerCreationTime with worker global scope's cross-origin isolated capability.
-    return HighResolutionTime::coarsen_time(m_unsafe_worker_creation_time, cross_origin_isolated_capability() == CanUseCrossOriginIsolatedAPIs::Yes);
+    return HighResolutionTime::coarsen_time(m_unsafe_worker_creation_time, cross_origin_isolated_capability());
 }
 
 void WorkerEnvironmentSettingsObject::visit_edges(JS::Cell::Visitor& visitor)

Libraries/LibWeb/HighResolutionTime/TimeOrigin.cpp

@@ -45,13 +45,13 @@ DOMHighResTimeStamp get_time_origin_timestamp(JS::Object const& global)
 }
 
 // https://w3c.github.io/hr-time/#dfn-coarsen-time
-DOMHighResTimeStamp coarsen_time(DOMHighResTimeStamp timestamp, bool cross_origin_isolated_capability)
+DOMHighResTimeStamp coarsen_time(DOMHighResTimeStamp timestamp, HTML::CanUseCrossOriginIsolatedAPIs cross_origin_isolated_capability)
 {
     // 1. Let time resolution be 100 microseconds, or a higher implementation-defined value.
     auto time_resolution_milliseconds = 0.1;
 
     // 2. If crossOriginIsolatedCapability is true, set time resolution to be 5 microseconds, or a higher implementation-defined value.
-    if (cross_origin_isolated_capability)
+    if (cross_origin_isolated_capability == HTML::CanUseCrossOriginIsolatedAPIs::Yes)
         time_resolution_milliseconds = 0.005;
 
     // 3. In an implementation-defined manner, coarsen and potentially jitter timestamp such that its resolution will not exceed time resolution
@@ -79,7 +79,7 @@ DOMHighResTimeStamp relative_high_resolution_time(DOMHighResTimeStamp time, JS::
     auto& settings = HTML::relevant_principal_settings_object(global);
 
     // 2. Let coarse time be the result of calling coarsen time with time and settings's cross-origin isolated capability.
-    auto coarse_time = coarsen_time(time, settings.cross_origin_isolated_capability() == HTML::CanUseCrossOriginIsolatedAPIs::Yes);
+    auto coarse_time = coarsen_time(time, settings.cross_origin_isolated_capability());
 
     // 2. Return the relative high resolution coarse time for coarse time and global.
     return relative_high_resolution_coarsen_time(coarse_time, global);
@@ -94,7 +94,7 @@ DOMHighResTimeStamp relative_high_resolution_coarsen_time(DOMHighResTimeStamp co
 }
 
 // https://w3c.github.io/hr-time/#dfn-coarsened-shared-current-time
-DOMHighResTimeStamp coarsened_shared_current_time(bool cross_origin_isolated_capability)
+DOMHighResTimeStamp coarsened_shared_current_time(HTML::CanUseCrossOriginIsolatedAPIs cross_origin_isolated_capability)
 {
     // The coarsened shared current time given an optional boolean crossOriginIsolatedCapability (default false), must return the result of calling coarsen time with the unsafe shared current time and crossOriginIsolatedCapability.
     return coarsen_time(unsafe_shared_current_time(), cross_origin_isolated_capability);

Libraries/LibWeb/HighResolutionTime/TimeOrigin.h

@@ -9,17 +9,18 @@
 
 #include <LibJS/Forward.h>
 #include <LibWeb/Export.h>
+#include <LibWeb/HTML/Scripting/SerializedEnvironmentSettingsObject.h>
 #include <LibWeb/HighResolutionTime/DOMHighResTimeStamp.h>
 
 namespace Web::HighResolutionTime {
 
 DOMHighResTimeStamp estimated_monotonic_time_of_the_unix_epoch();
 DOMHighResTimeStamp get_time_origin_timestamp(JS::Object const&);
-DOMHighResTimeStamp coarsen_time(DOMHighResTimeStamp timestamp, bool cross_origin_isolated_capability = false);
+DOMHighResTimeStamp coarsen_time(DOMHighResTimeStamp timestamp, HTML::CanUseCrossOriginIsolatedAPIs cross_origin_isolated_capability = HTML::CanUseCrossOriginIsolatedAPIs::No);
 DOMHighResTimeStamp current_high_resolution_time(JS::Object const&);
 DOMHighResTimeStamp relative_high_resolution_time(DOMHighResTimeStamp, JS::Object const&);
 DOMHighResTimeStamp relative_high_resolution_coarsen_time(DOMHighResTimeStamp, JS::Object const&);
-WEB_API DOMHighResTimeStamp coarsened_shared_current_time(bool cross_origin_isolated_capability = false);
+WEB_API DOMHighResTimeStamp coarsened_shared_current_time(HTML::CanUseCrossOriginIsolatedAPIs cross_origin_isolated_capability = HTML::CanUseCrossOriginIsolatedAPIs::No);
 DOMHighResTimeStamp wall_clock_unsafe_current_time();
 WEB_API DOMHighResTimeStamp unsafe_shared_current_time();