fergal@chromium.org bfcache-dev@chromium.org Records the reason why the page is evicted from the back-forward cache but after the document is restored. This happens when there is a race between eviction and restoring. This also records when the page is restored to calculate how often this eviction happens. This is recorded for all websites regardless whether back-forward cache is enabled or not. fergal@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history, this records whether the page was restored from the BackForwardCache or not. This is recorded for all websites regardless whether back-forward cache is enabled or not. fergal@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history, this records what blocklisted features were used when the page was loaded and prevented this page from being stored in the back-forward cache. Multiple blocklisted features can be recorded for the same page. This is recorded for all websites regardless whether back-forward cache is enabled or not. fergal@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history and the BackForwardCache wasn't used because of the other active WebContents objects in the BrowsingInstance, this records the reason why the browsing instance wasn't swapped. This is recorded for all websites regardless whether back-forward cache is enabled or not. fergal@chromium.org rakina@chromium.org bfcache-dev@chromium.org For history navigations, records the reason passed to BackForwardCache::DisableForRenderFrameHost calls. The metric is recorded when a history navigation commits and emits a sample for each reason. Compare this with BackForwardCache.HistoryNavigationOutcome, which contains the total number of navigations which where not cached This is recorded for all websites regardless whether back-forward cache is enabled or not. fergal@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history, record why it wasn't restored from the cache. The page might not have entered the back-forward in the first place based on the features used, or it might have been evicted while being in the cache. This is recorded for all websites regardless of whether back-forward cache is enabled or not. leimy@chromium.org bfcache-dev@chromium.org Logs the cause of a cookie change for a page. This is recorded every time when a page receives cookie change if it's listening for it. leimy@chromium.org bfcache-dev@chromium.org Logs the {CountType} cookie change details for a page. This is recorded during navigation away from any page configured with Cache-Control: no-store, at the moment the browser checks if the page can be stored in the BFCache. leimy@chromium.org bfcache-dev@chromium.org Logs the whether ThreadableLoader request includes the credentials. This is recorded every time when the ThreadableLoader receives response that contains Cache-control: no-store header (i.e. it will potentially evict the page which was loaded with Cache-control: no-store from BFCache). fergal@chromium.org bfcache-dev@chromium.org Records the reason why the page is evicted from the back-forward cache but after the document is restored. This happens when there is a race between eviction and restoring. This also records when the page is restored to calculate how often this eviction happens. This is recorded when back-forward cache is enabled for this navigation (back-forward cache feature is enabled and the domain is in the scope of the experiment). rakina@chromium.org bfcache-dev@chromium.org Records the reason of renderer-initiated back-forward cache eviction. Emitted when renderer evicts the page from back-forward cache. fergal@chromium.org bfcache-dev@chromium.org Records the time duration between the last time when the entry goes to the back-forward cache and the time when the process is killed. fergal@chromium.org bfcache-dev@chromium.org Track number of times an unexpected IPC message is posted to frames in the renderer process while they are frozen in the back-forward cache. IPC tasks are denoted by md5 hash of the mojo bindings method name or message hash for legacy IPCs. Recorded when an IPC task is posted to frames that have already been stored in the back-forward cache, after a 15 second delay to account for completion of all freezing-related operations. fergal@chromium.org bfcache-dev@chromium.org Duration between start of page being stored in the back-forward cache and when the unexpected IPC call is received by a frame while in the cache. Recorded when an IPC task is posted to frames that have already been stored in the back-forward cache, after a 15 second delay to account for completion of all freezing-related operations. annasato@chromium.org bfcache-dev@chromium.org Records the result of matching the committed navigation URL against existing entries in BackForwardCache. Records whether the cache was empty, if no match was found, if a URL match was found (but with a different history index), or if an exact match (URL and history index) was found. Recorded when a navigation commits (excluding BackForwardCache restores). annasato@chromium.org bfcache-dev@chromium.org Records the number of BackForwardCache entries that are forward of the new committed entry. Recorded when a history back navigation commits (including navigations restored from BackForwardCache). rakina@chromium.org bfcache-dev@chromium.org Records whether a history navigation committed a new page that matches a page in BFCache (the URL, origin, and security properties match). Recorded when a history navigation committed a new page. fergal@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history, this records whether the page was restored from the BackForwardCache or not. This is recorded when back-forward cache is enabled for this navigation (back-forward cache feature is enabled and the domain is in the scope of the experiment). fergal@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history, this records what blocklisted features were used when the page was loaded and prevented this page from being stored in the back-forward cache. Multiple blocklisted features can be recorded for the same page. This is recorded when back-forward cache is enabled for this navigation (back-forward cache feature is enabled and the domain is in the scope of the experiment). fergal@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history and the BackForwardCache wasn't used because of the other active WebContents objects in the BrowsingInstance, this records the reason why the browsing instance wasn't swapped. This is recorded when back-forward cache is enabled for this navigation (back-forward cache feature is enabled and the domain is in the scope of the experiment). fergal@chromium.org bfcache-dev@chromium.org For history navigations, records the reason passed to BackForwardCache::DisableForRenderFrameHost calls. The metric is recorded when a history navigation commits and emits a sample for each reason. Compare this with BackForwardCache.HistoryNavigationOutcome, which contains the total number of navigations which where not cached This is recorded for all websites regardless whether back-forward cache is enabled or not. fergal@chromium.org bfcache-dev@chromium.org For history navigations, records the reason passed to RenderFrameHost::IsInactiveAndDisallowActivation calls. The metric is recorded when a history navigation commits and emits a sample for each reason. Compare this with BackForwardCache.HistoryNavigationOutcome, which contains the total number of navigations which where not cached This is recorded for all websites regardless whether back-forward cache is enabled or not. Warning: this histogram was expired from 2024-07-07 to 2024-12-04; data may be missing. fergal@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history, record why it wasn't restored from the cache. The page might not have entered the back-forward in the first place based on the features used, or it might have been evicted while being in the cache. This is recorded when back-forward cache is enabled for this navigation (back-forward cache feature is enabled and the domain is in the scope of the experiment). rakina@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history and the BackForwardCache wasn't used because of other active WebContents objects in the BrowsingInstance, this records the number of other active pages/related active contents using the same BrowsingInstance. rakina@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history and the BackForwardCache wasn't used because of other active WebContents objects in the BrowsingInstance, this Records whether the page was potentially synchronously accessible by other pages/related active contents using the same BrowsingInstance, at the time the page was navigated away from. rakina@chromium.org bfcache-dev@chromium.org Records whether a non-history non-session-restore non-reload navigation committed a new page that matches a page in BFCache (the URL, origin, and security properties match). Recorded when a non-history non-session-restore non-reload navigation committed a new page. rakina@chromium.org bfcache-dev@chromium.org Records whether a non-history non-session-restore non-reload navigation committed a new page that matches a page in BFCache (the URL, origin, and security properties match) that has no subframes. Recorded when a non-history non-session-restore non-reload navigation committed a new page. rakina@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history that does not restore a page from the back/forward cache, this records the history navigation direction (back/forward/same entry). This is recorded when committing a navigation where the back/forward cache is enabled for this navigation (back/forward cache feature is enabled and the domain is in the scope of the experiment) but the navigation does not restore a page from back/forward cache. wenyufu@chromium.org bfcache-dev@chromium.org Record for a page that has form attached is about to restored from the back forward cache, to understand the success rate for bfcaching a page that has form / input entry attached. This is recorded for page with form attached only. Recorded during a cross-page history navigation. If a page with form is restored from the cache, "PageRestored" will be recorded; if the page is not egligible to be restored due to any reason, "PageNotRestored" will be recorded. wenyufu@chromium.org bfcache-dev@chromium.org Record for a page that has form attached is egligible to be stored in back forwad cache, to understand the success rate for bfcaching a page that has form / input entry attached. This is recorded for page with form attached only. Recorded when a navigation is committed. If a page has form attached "PageSeen" will be recorded; if the page is egligible to be stored in the back forward cache, "PageStored" will be recorded. rakina@chromium.org bfcache-dev@chromium.org Whether a back/forward cached page shares the same process as the page that we're navigating to (i.e. whether the new active page reuses the process of the back/forward cached page). Recorded when navigating away from a page, after the navigation commits and we're about to put the previous page into the back/forward cache. leimy@chromium.org bfcache-dev@chromium.org The total number of back/forward cache entries before the pruning happens. This is recorded when the back/forward cache entries are pruned (e.g. when the memory pressure signal is received). leimy@chromium.org bfcache-dev@chromium.org The total number of tabs that contains at least one non-active main frame nodes before the pruning happens. This is recorded when the back/forward cache entries are pruned (e.g. when the memory pressure signal is received). sreejakshetty@chromium.org bfcache-dev@chromium.org Duration between start of navigation restoring a document from back-forward cache and the first paint. This is recorded when a history navigation is served from back-forward cache but in a foreground tab. rakina@chromium.org bfcache-dev@chromium.org When navigating back to a page in the session history that restores a page from the back/forward cache, this records the history navigation direction (back/forward/same entry). This is recorded when committing a navigation where the back/forward cache is enabled for this navigation (back/forward cache feature is enabled and the domain is in the scope of the experiment) and the navigation restores a page from back/forward cache. fergal@google.com bfcache-dev@chromium.org Hash (base::HashMetricName) of a mojo interface name. A sample is recorded for every message the browser receives from a renderer for a page that is in the back-forward cache. Logging can be disabled via the back-forward cache feature parameter "message_handling_when_cached". Renderers should not be sending messages back to the browser for pages that are in the back-forward cache. Eventually we will be killing such renderers (as we could assume that it is misbehaving because it got compromised). But first we must make sure that we are not sending messages by mistake (i.e. bugs in the renderer). gjc@google.com chrome-loading@google.com Records the deferred time caused by the AndroidSpareRendererNavigaionThrottle. The UMA is recorded each time AndroidSpareRendererNavigationThrottle::WillStartRequest resumes the navigation. The UMA will only be sent if the Android spare renderer feature and the navigation throttle for the Android spare renderer are enabled. The UMA only records metrics on machines with high-resolution clocks. gjc@google.com chrome-loading@google.com Records whether the renderer process for the navigation is still alive when resuming the navigation in AndroidSpareRendererNavigaionThrottle. The UMA is recorded each time AndroidSpareRendererNavigationThrottle::WillStartRequest resumes the navigation. The UMA will only be sent if the Android spare renderer feature and the navigation throttle for the Android spare renderer are enabled. gjc@google.com chrome-loading@google.com Records if a navigation is deferred by the AndroidSpareRendererNavigaionThrottle. The UMA is recorded each time AndroidSpareRendererNavigationThrottle::WillStartRequest is called. The UMA will only be sent if the Android spare renderer feature and the navigation throttle for the Android spare renderer are enabled. arthursonzogni@chromium.org chrome-security-owp-team@google.com Record whether iframe with the anonymous attribute contains sandboxed document or not. leimy@chromium.org bfcache-dev@chromium.org The time spent between the back navigation menu model's opening and the activation of a menu item. This is recorded when the back navigation menu model receives signal that indicates the item from the menu is activated. See `BackForwardMenuModel::MenuWillShow()` and `BackForwardMenuModel::ActivatedAt()` for more details. leimy@chromium.org bfcache-dev@chromium.org The time spent between the back navigation menu model's opening and the closing. There might or might not be a menu item activation in between. This is recorded when the back navigation menu model receives signal that indicates it will be closed. See `BackForwardMenuModel::MenuWillShow()` and `BackForwardMenuModel::MenuWillClose()` for details. dljames@chromium.org xiaqu@microsoft.com edgecin@microsoft.com Records when the back-to-opener feature is used. This is recorded when the user clicks the back button to navigate back to the opener tab. dljames@chromium.org xiaqu@microsoft.com edgecin@microsoft.com The time it takes to close the destination tab after the back-to-opener action is triggered. This includes any unload prompts that may delay the tab closure. Recorded when the WebContents is destroyed (in TabCloseObserver::WebContentsDestroyed, which is triggered by BackToOpenerController::GoBackToOpener). The value is measured from when ClosePage() is called until the WebContents is actually destroyed. dljames@chromium.org xiaqu@microsoft.com edgecin@microsoft.com Records when a back-to-opener relationship is established between a newly opened destination tab and its opener tab. This is emitted in SetOpenerWebContents when the opener relationship is first created (i.e. when a user-initiated navigation from one tab opens a new tab). Use this as the denominator with Navigation.BackToOpener.Clicked to compute the trigger rate of the back-to-opener feature. chikamune@chromium.org chrome-loading@google.com Records the execution mode of beforeunload handlers for a navigation. Recorded at the time of navigation commit for cross-document {SameOrCrossOrigin} outermost main frame navigations. Only recorded for HTTP or HTTPS schemes. evanluo@google.com clank-app-team@google.com Records the reason why the navigation blur transition (Android only) was terminated. This helps track the success rate and failure modes of the transition animation. annasato@google.com rakina@google.com chrome-navigation@google.com Records the cookie change status only for potential duplicate navigations where criteria such as URL, initiator, method, and transition match, and specifically for those that occurred within the duplicate navigation time threshold. It distinguishes whether a CookieChangeListener was missing, cookies actually changed since the ongoing navigation started, or cookies remained the same. This is recorded {DuplicateNavTargetScope}. liuwilliam@chromium.org chrome-seamless-core@google.com Counts the different types of browser-initiated session history navigations. The counts are recorded when the respective NavigationRequests are first created, and before the requests are owned by their respective RenderFrameHost. The metric is recorded once per browser-initiated history navigation. xiaochenzh@chromium.org shivanisha@chromium.org For navigation requests with FLEDGE or SharedStorage generated urn:uuid, record whether it is rendered in a fenced frame or iframe. Recorded when navigation requests begin (i.e. during NavigationRequest::BeginNavigation()). cduvall@chromium.org jam@chromium.org Measures how long it takes to fetch from the code cache. Logged every time the code cache is fetched for the navigation body or a resource. chikamune@chromium.org chrome-loading@google.com Time spent processing RenderFrameImpl::CommitNavigationWithParams() in the renderer process. This is recorded on each WebFrameLoadType::kStandard navigation for http or https URLs. This histogram only records metrics on machines with high-resolution clocks. rakina@chromium.org chrome-security-architecture@google.com The time it takes for the RenderFrameImpl::CommitNavigation() to run. Recorded on every RenderFrameImpl::CommitNavigation() call. sisidovski@chromium.org chrome-loading@google.com The time it takes for the RenderFrameImpl::CommitNavigation() to run on the outermost main frame. Recorded on RenderFrameImpl::CommitNavigation() call, when it's a new non-(reload/history/restore) navigation for the URL with HTTP or HTTPS scheme. sisidovski@chromium.org chrome-loading@google.com The time it takes for the RenderFrameImpl::CommitNavigation() to run on {FrameType}. Recorded on every RenderFrameImpl::CommitNavigation() call. rakina@chromium.org bfcache-dev@chromium.org Records the time duration between the creation of CompositorFrameSink for a new RenderWidgetHost to when the navigation that uses that RenderWidgetHost reaches {Stage}. Logged when the navigation that uses a new RenderFrameHost and RenderWidgetHost reaches both the commit and swap RFH stages and the creation of CompositorFrameSink had already been requested at that time. rakina@chromium.org bfcache-dev@chromium.org Records whether the creation of CompositorFrameSink for a new RenderWidgetHost is already requested when the navigation that uses it reaches {Stage}. Logged when the navigation that uses the new RenderFrameHost and RenderWidgetHost has reached both the commit and swap RFH stages. rakina@chromium.org chrome-security-architecture@google.com The time it takes for RenderFrameHostManager::CreateSpeculativeRenderFrameHost() to run. Recorded on every RenderFrameHostManager::CreateSpeculativeRenderFrameHost() call. sisidovski@chromium.org chrome-loading@google.com The time taken to create and clone subresource_proxying_factory_bundle during navigation commit in RenderFrameHostImpl::CommitNavigation. Recorded for each navigation commit where subresource_loader_factories is present. This histogram only records metrics on machines with high-resolution clocks. mkwst@chromium.org chrome-security@google.com The outcome of Content Security Policy Embedded Enforcement (CSPEE) during navigation. Recorded for every navigation that has a required CSP set by its embedder (via the 'csp' attribute). Possible outcomes include allowing the navigation because it's a local scheme, because the 'Allow-CSP-From' header was present and valid, because the frame's own CSP subsumed the required policy, or blocking the navigation entirely. gjc@google.com rakina@chromium.org chrome-navigation@google.com Records whether the speculative RFH is deferred when the navigation starts and whether a spare render process is warmed up. gjc@google.com chrome-loading@google.com Records whether a new spare renderer process is launched when the renderer process for the SiteInstance of the current navigation is not ready. The UMA is recorded each time `RenderFrameHostManager::GetSiteInstanceForNavigation` is called. The UMA records true only if the spare renderer process is initialized before the destination process's renderer process. peilinwang@google.com woa-performance-bugs+jank@google.com Measures the amount of time it takes to call RenderFrameHostImpl::DidCommitSameDocumentNavigation(). Logged once per call to RenderFrameHostImpl::DidCommitSameDocumentNavigation(). annasato@chromium.org chrome-navigation@google.com Records the number of subsequent duplicate navigation requests that were ignored in favor of an ongoing navigation. This is recorded at the time the navigation successfully commits. lazzzis@google.com liuwilliam@chromium.org chrome-seamless-core@google.com Record if there is navigation started during a gesture is in progress. This records for {NavigationMode} when a gesture is finished. Android only. bashi@chromium.org chrome-loading@google.com Time from a navigation request received the first early hints to the response started. Recorded per navigation when both early hints and the final response are received. bashi@chromium.org chrome-loading@google.com Time from a navigation request will start to the first early hints is received. Recorded per navigation when both early hints and the final response are received. alexmos@chromium.org creis@chromium.org If a navigation swaps to the destination RenderFrameHost early, this records whether or not the navigation actually ended up committing a document. This will be true for most navigations, but false for downloads and 204 responses. Recorded once for every navigation that performs an early RenderFrameHost swap. alexmos@chromium.org creis@chromium.org If a navigation swaps to the destination RenderFrameHost early, this records whether the navigation was in an outermost main frame. Recorded once per early RenderFrameHost swap. alexmos@chromium.org creis@chromium.org This records whether a navigation swapped to the destination RenderFrameHost early (prior to commit), as well as the reason for this swap. Recorded once at the end of every navigation, when NavigationRequest is destroyed. estark@chromium.org security-enamel@chromium.org The amount of time that an HTTP page was in the foreground. Recorded on every page close/transition. This metric is exposed publicly on the HTTPS Transparency Report at https://transparencyreport.google.com/https/overview?hl=en. estark@chromium.org security-enamel@chromium.org The amount of time that an HTTPS page was in the foreground. Recorded on every page close/transition. This metric is exposed publicly on the HTTPS Transparency Report at https://transparencyreport.google.com/https/overview?hl=en. estark@chromium.org security-enamel@chromium.org The percentage of time that HTTPS pages were in the foreground, as compared to total foreground time. Recorded whenever user metrics are uploaded. bashi@chromium.org chrome-loading@google.com Measures the synchronous CPU execution time of IsEligibleForFastFetch() during BeginNavigationImpl. Recorded unconditionally on all main frame navigations. Note that some clients may not have a high resolution timer that can send metrics with microsecond precision. bashi@chromium.org chrome-loading@google.com Records the specific eligibility check result (success or first failed exclusion condition) at navigation start. Recorded unconditionally on all main frame navigations. bashi@chromium.org chrome-loading@google.com Records the net error code when an eligible navigation fails. Recorded only when the navigation fails before commit. bashi@chromium.org chrome-loading@google.com Records the final lifecycle disposition of navigations marked eligible during Fast Fetch. Committed indicates successful commit to initial URL. Failed indicates abort or error before commit. bashi@chromium.org chrome-loading@google.com Measures elapsed time from eligibility check in BeginNavigationImpl to the first fetch start time for eligible navigations. bashi@chromium.org chrome-loading@google.com Measures elapsed time from eligibility check in BeginNavigationImpl to URLLoader::Start() for eligible navigations. bashi@chromium.org chrome-loading@google.com Records the skip_throttles value when an eligible navigation fails. Recorded only when the navigation fails before commit. rakina@chromium.org bfcache-dev@chromium.org Records the time between when the first contentful paint frame for a new document is received by Viz to when the surface used for the new document gets embedded by the browser process. Logged after the first contentful frame has been displayed on screen. rakina@chromium.org bfcache-dev@chromium.org Records whether the first contentful paint frame for a new document was received by Viz before the surface used for the document gets embedded by the browser process. Logged after the first contentful frame has been displayed on screen. xiaochenzh@chromium.org shivanisha@chromium.org chrome-fenced-frames-core@google.com Records how many beacons were sent through window.fence.reportEvent() from a document that is same-origin to the mapped URL of the FencedFrameConfig during the lifetime of the FencedFrameConfig object. This is recorded when the FencedFrameConfig object is destroyed and is recorded once per FencedFrameConfig instance. liuwilliam@google.com baranerf@google.com chrome-seamless-core@google.com Counts the occurrence of cache hit or cache miss reasons when the user starts a back/forward navigation gesture. This is recorded once per user gesture. lizeb@chromium.org clank-performance-team@google.com The time it takes to compress the navigation screenshot, on a background thread. Recorded on Android, each time a navigation screenshot is compressed. acondor@google.com clank-performance-team@google.com Records whether a shared image was received from the GPU process when caching a screenshot for navigation transitions. This can happen if the surface is deleted before the CopyOutputRequest is satisfied. Recorded each time a shared image is received for caching. This is recorded on Android only, when the predictive back gesture for web content, using shared images, is enabled. acondor@google.com liuwilliam@google.com baranerf@google.com chrome-seamless-core@google.com The amount of memory usage by the screenshots captured for predictive back. Recorded at Poisson sampled time intervals continuously, regardless of user gesture, with a mean of 5 minutes on Android and 30 minutes on other platforms. lazzzis@google.com clank-app-team@google.com Record the scheme type of the new commit when a new commit happens {Scenario}. rakina@chromium.org chrome-security-architecture@google.com The time it takes for RenderFrameHostManager::GetFrameHostForNavigation() to run. Recorded on every RenderFrameHostManager::GetFrameHostForNavigation() call. chikamune@chromium.org chrome-loading@google.com Time spent processing GetFrameHostForNavigation() in RenderFrameHostManager::DidCreateNavigationRequest() that can prepare a SpeculativeRenderFrameHost. SpeculativeRenderFrameHost might not be created in some cases, but this UMA records such cases as well. This is recorded on each navigation if the navigation requires GetFrameHostForNavigation() to be called for http or https URLs. Calling GetFrameHostForNavigation() is not required for the same document navigations or back/forward cache navigations. This histogram only records metrics on machines with high-resolution clocks. alexmos@chromium.org creis@chromium.org wjmaclean@chromium.org Whether the committing guest navigation targets an HTTP(S) URL. Logged at ready-to-commit time for navigations in a webview tag (also known as "guest" in process model terminology), excluding same-document navigations and errors. alexmos@chromium.org creis@chromium.org wjmaclean@chromium.org Whether the committing guest navigation is in a main frame. Logged at ready-to-commit time for navigations in a webview tag (also known as "guest" in process model terminology), excluding same-document navigations and errors. mpearson@chromium.org amaralp@chromium.org chrome-analysis-team@google.com Emitted every time a user uses a Home button to go to their home page. Records whether the page is chrome-internal (most likely the New Tab Page or about:blank) or not (most likely an actual web site). For the purpose of this histogram, about:, chrome: and chrome-native: are considered chrome-internal; everything else is not. The user action Navigation.Home.NotChromeInternal is also logged in the case that false is logged to this histogram. This histogram is of special interest to the chrome-analysis-team@. Do not change its semantics or retire it without talking to them first. meacer@chromium.org chrome-trusty-transport@google.com Counts the number of typed and pasted main frame navigations to hostnames that contain characters that are treated differently between IDNA 2003 and IDNA 2008, aka deviation characters. Ignores reload navigations. robertlin@chromium.org chrome-prerendering@google.com Records the initiator type of a navigation. Recorded for a standard navigation when it commits. For a prerendered navigation, it is recorded when the page is activated. robertlin@chromium.org chrome-prerendering@google.com Records the initiator type of a SRP navigation. Recorded for a standard SRP navigation when it commits. For a prerendered SRP navigation, it is recorded when the page is activated. alexmos@chromium.org creis@chromium.org wjmaclean@chromium.org Whether the committing navigation is for a webview tag (also known as "guest" in process model terminology). Logged at ready-to-commit time for every navigation, excluding same-document navigations and errors. alexmos@chromium.org lukasza@chromium.org Whether the navigation commits in a process that is locked to an origin. Logged at ready-to-commit time for every navigation excluding same-document navigations and errors. alexmos@chromium.org lukasza@chromium.org Whether the navigation commits in a process that is locked to an origin. Logged at ready-to-commit time for every navigation that commits with a HTTP or HTTPS URL scheme, excluding same-document navigations and errors. chikamune@chromium.org chrome-loading@google.com Records true if the RenderProcess is backgrounded, otherwise records false. This is recorded on {Timing} when the URL is HTTP or HTTPS and only when the navigation happens in OutermostMainFrame. arthursonzogni@chromium.org clamy@chromium.org nasko@chromium.org Whether a main frame navigation led to a change of BrowsingInstance or not. arthursonzogni@chromium.org clamy@chromium.org nasko@chromium.org Whether the navigation led to a change of SiteInstance or not. boliu@chromium.org alexmos@chromium.org src/base/android/OWNERS The type of the source of a load from LoadIfNecessary. Recorded when LoadIfNecessary starts a page load. For example, on Android, kRequestedByClient is recorded when user switch back to a tab with a dead renderer, which causes the tab to reload. michaelpg@chromium.org yilkal@chromium.org cros-families-eng@google.com The number of frames that are present in a WebContents. Recorded once when the main frame finishes loading. yaoxia@chromium.org jkarlin@chromium.org chrome-ads-histograms@google.com Records a True boolean value when clicking on an Ad triggers a main frame navigation. Recorded when the (renderer-initiated) navigation IPC is received by the browser process. michaelpg@chromium.org yilkal@chromium.org cros-families-eng@google.com The maximum number of loaded frames that are present in a WebContents. Recorded once when the main frame is moving away from current page. This can be when the WebContents is being destroyed or when it starts loading new content. chikamune@chromium.org yyanagisawa@chromium.org kouhei@chromium.org Record when (a) the navigation happened in MainFrame, (b) it was a new navigation, (c) it was not a session restore, (d) the URL was http or https, and (e) the navigation was successfully committed. Measures the duration between {DurationFromTo}. This is also included in the trace log. yaoxia@chromium.org cammie@chromium.org Whether the initiator frame is present when a renderer-initiated primary main frame navigation has started. Recorded for each renderer-initiated primary main frame navigation when the navigation has started (i.e. during WebContentsObserver::DidStartNavigation()). meacer@chromium.org security-enamel@chromium.org Site engagement level of the URL of the top frame of a navigation. Only counts HTTP or HTTPS URLs and ignores downloads. dullweber@chromium.org feuunk@chromium.org Records whether third party cookie blocking was enabled for a site. Recorded for each main-frame navigation when that navigation commits. Only counts HTTP or HTTPS URLs and ignores downloads. cthomp@chromium.org trusty-transport@chromium.org Whether the main-frame navigation was to a URL with an RTL domain name. This is only recorded for finished navigations and not attempts. Warning: this histogram was expired from M92 through M95; data may be missing. cthomp@chromium.org trusty-transport@chromium.org Whether the main-frame navigation was to a URL with an RTL domain name, recorded for each main-frame avigation that replaces a document object. This is not reported for reference fragment navigations, pushState/replaceState or same page history navigation. This is only recorded for finished navigations and not attempts. dullweber@chromium.org chrome-privacy-core@google.com The browser profile type for each main-frame navigation, recorded after navigation completion, including NTP and same-document navigations. To only see navigations that replace a document object, take a look at Navigation.MainFrameProfileTypeDifferentPage2. dullweber@chromium.org chrome-privacy-core@google.com The browser profile type for each main-frame navigation that replaces a document object. Recorded after navigation completion, including NTP. To see all navigations, including same-document navigations, take a look at Navigation.MainFrameProfileType2. liuwilliam@chromium.org chrome-seamless-core@google.com Records the time to present the first frame since the same-document navigation has finished in the mainframe's renderer. estark@chromium.org elawrence@chromium.org trusty-transport@chromium.org The scheme of the URL for each main-frame navigation. This is only recorded for finished navigations and not attempts. Warning: this histogram was expired from 2021-06-01 through M95; data may be missing. estark@chromium.org elawrence@chromium.org trusty-transport@chromium.org The scheme of the URL for each main-frame navigation that replaces a document object. This is not reported for reference fragment navigations, pushState/replaceState or same page history navigation. This is only recorded for finished navigations and not attempts. meacer@chromium.org trusty-transport@chromium.org A subset of MainFrameSchemeDifferentPage2 only recorded for non-unique hostnames. The scheme of the URL for each main-frame navigation that replaces a document object. This is not reported for reference fragment navigations, pushState/replaceState or same page history navigation. This is only recorded for finished navigations and not attempts. Warning: this histogram was expired from 2024-09-01 to 2025-02-28; data may be missing. estark@chromium.org elawrence@chromium.org trusty-transport@chromium.org The scheme of the URL for each main-frame navigation that replaces a document object while in incognito. This is not reported for reference fragment navigations, pushState/replaceState or same page history navigation. This is only recorded for finished navigations and not attempts. elawrence@chromium.org estark@chromium.org The scheme of the URL for each main-frame navigation while in incognito. This is only recorded for finished navigations and not attempts. Warning: this histogram was expired from 2021-06-01 through M97; data may be missing. clamy@chromium.org nasko@chromium.org Overhead time spent handling the OnBeforeUnload event from the browser standpoint. More precisely, it is the total time between dispatch and acknowledgment of the BeforeUnload event on the browser side, minus the actual time spent executing the BeforeUnload handlers on the renderer side. chikamune@chromium.org chrome-loading@google.com Overhead time spent handling the OnBeforeUnload event from the browser standpoint. Recorded only when `for_legacy` is false which means there were mojo calls between the browser process and the renderer process. {SyncAsync} hayato@chromium.org chikamune@chromium.org chrome-loading@google.com Measures the time a posted SendBeforeUnload task spends in the queue before execution. It's only recorded when the browser process is already aware that no beforeunload handler is registered. Recorded for each SendBeforeUnload task (but only when `for_legacy` is true). Emitted when the task runs. chikamune@chromium.org chrome-loading@google.com Milliseconds spent to process all the beforeunload events in JavaScript and waiting time for beforeunload dialog is closed if necessary. Recorded only when a non-reload navigation occurs. lazzzis@google.com liuwilliam@chromium.org chrome-seamless-core@google.com Record if a nav is in progress when a gesture has been just started. This records for {NavigationMode} when a gesture has been just started. This records once per navigation gesture. Android only. alexmos@chromium.org creis@chromium.org For every successful cross-document commit, this logs whether or how OriginAgentCluster was involved. It tracks whether it was requested, as well as whether the isolation was granted, which can be affected by other documents in the same browsing context group. If OriginAgentCluster-by- default is not enabled, the first four enum values track this state. If OriginAgentCluster-by-default is enabled, then the second (disjoint) set of six enum values tracks this state, plus the two additional cases where OriginAgentCluster was explicitly not requested, and was or wasn't granted. Warning: this histogram was expired from 2025/05/18 to 2025/06/24; data may be missing. chikamune@chromium.org chrome-loading@google.com Measures the total running time of the previous page's event handlers such as pagehide and visibilitychange when the new page's navigation is committed. dcheng@chromium.org rakina@chromium.org Records how many attempts to assign a final RenderFrameHost for a navigation were blocked due to a pre-existing speculative RenderFrameHost being in the kPendingCommit state. Collected when the navigation commits in DidCommitNavigation(). dcheng@chromium.org rakina@chromium.org Records how many attempts to assign RenderFrameHost (initial or final) for a navigation were blocked due to a pre-existing speculative RenderFrameHost being in the kPendingCommit state. Collected when the navigation commits in DidCommitNavigation(). dcheng@chromium.org rakina@chromium.org Records whether any calls to `GetFrameHostForNavigation()` that failed due to a pre-existing speculative RenderFrameHost being in the kPendingCommit state. Collected when the navigation commits in DidCommitNavigation(). dcheng@chromium.org rakina@chromium.org Measures the amount of time between the browser asking a speculative RenderFrameHost to commit a navigation in the renderer and the commit actually being recorded in the browser process. Collected when the navigation commits in DidCommitNavigation(). alexilin@chromium.org blundell@chromium.org lizeb@chromium.org pasko@chromium.org Measures the amount of time that a requested preresolve job spends queueing before being executed (e.g., due to a max # of preconnects being in flight). Recorded for each presolve job. alexilin@chromium.org blundell@chromium.org lizeb@chromium.org pasko@chromium.org Measures the amount of time that the task corresponding to the completion callback for a host resolution performed as part of navigation preconnect spent being queued before executing. Recorded for each host resolution. alexilin@chromium.org lizeb@chromium.org pasko@chromium.org Measures the duration from initiation to completion for a host resolution performed as part of navigation preconnect. Recorded for each host resolution. Note: Does not capture any delay spent queuing *before* initiating the host resolution (e.g., due to a max # of preconnects being in flight). ricea@chromium.org chikamune@chromium.org Records the size of the response body for prefetch responses that had a non-trivial Content-Encoding. This is logged once per successfully completed compressed response in PrefetchManager::OnPrefetchFinished(). A response is considered compressed when the decoded body length is larger than the encoded body length. Compare to Navigation.Prefetch.UncompressedBodySize. ricea@chromium.org chikamune@chromium.org Records whether or not a prefetch requested a URL with an https scheme. Recorded once for each prefetch performed by PrefetchManager. This is based on what the PrefetchManager requested and doesn't take into account subsequent internal or external redirects to https. robertlin@chromium.org chrome-prerendering@google.com To record whether a prefetching attempt initiated by {PreloadingEmbedderType} trigger is trying to prefetch a SRP url or not. This is recorded when {PreloadingEmbedderType}PreloadPipelineManager::StartPrefetch is called to initiate a SPR url. blundell@chromium.org ryansturm@chromium.org sophiechang@chromium.org Measures the amount of time that a requested prefetch job spends queueing before being executed (e.g., due to a max # of prefetches being in flight). Recorded for each prefetch job. blundell@chromium.org ryansturm@chromium.org sophiechang@chromium.org Measures the length of the queue of prefetch jobs at the beginning of PrefetchManager processing this queue to execute jobs. Recorded each time that PrefetchManager processes the queue of pending jobs. ricea@chromium.org chikamune@chromium.org Records the size of the response body for prefetch responses that did not use HTTP Content-Encoding compression. This is logged once per successfully completed uncompressed response in PrefetchManager::OnPrefetchFinished(). A response is considered compressed when the decoded body length is larger than the encoded body length. Compare to Navigation.Prefetch.CompressedBodySize. nhiroki@chromium.org chrome-prerendering@google.com Measures time a PrerenderCommitDeferringCondition defers activation waiting to commit an ongoing mainframe prerender navigation. Logged every time a PrerenderCommitDeferringCondition defers navigation. After 2023/05, this metric is used with PreloadingTriggerType key and records even when PrerenderCommitDeferringCondition doesn't delay navigation as zero delay. Previously the metric was only used without the key and recorded only when PrerenderCommitDeferringCondition deferred navigation. lingqi@chromium.org chrome-prerendering@google.com Measures time a PrerenderNoVarySearchCommitDeferringCondition defers activation waiting to commit an ongoing mainframe prerender navigation. Logged whenever a PrerenderNoVarySearchCommitDeferringCondition defers navigation. sisidovski@chromium.org chrome-loading@google.com Measures the time taken to process regsitered navigation throttles in the WillStartRequest event for a {FrameType}. Recorded for every navigation, before dispatching the request. taiyo@chromium.org chrome-loading@google.com Records the result of process reuse when swapping Browsing Instances due to COOP mismatches on `RenderFrameHostManager::GetSiteInstanceForNavigation()`. The outcomes of reuse successes/failures are recorded once per each reuse attempt categorized by `ProcessReuseOnCOOPType`. Specifically, 1) `DifferentSiteInstance`: Candidate and target SiteInstances differ (e.g., cross-site navigations with speculative RFH) 2) `SameSiteNavigationInSingleWebContents`: Same-site navigations with single WebContents in the current BrowsingInstance 3) `Prerender`: Prerender's initial navigation with new FrameTree. If none of these strategies match, the type will be `None`, and the result is recorded as always false. For more context, please see crbug.com/40254888, crbug.com/41492112, crrev.com/c/6238439/comment/fb22b7bc_c8962d32/. cduvall@chromium.org yyanagisawa@chromium.org Measures the amount of time the task to run {Method} was queued before running. Logged every time {Method} is run for a {FrameType} in NavigationURLLoaderImpl with a valid queue time. Warning: this histogram was expired after 2023-07-28 and brought back 2024-05-20; data may be missing. clamy@chromium.org nasko@chromium.org The time needed to commit a navigation once it is ready to commit. This is the time between ReadyToCommit and DidFinishNavigation (for a navigation that commits). Warning: this histogram was expired after M85 and brought back 2021-04-13; data may be missing. sisidovski@chromium.org chrome-loading@google.com Measures the time taken to register navigation throttles in NavigationThrottleRunner for a {FrameType}. Recorded for every navigation, before dispatching the request. creis@chromium.org site-isolation-dev@chromium.org Recorded when RenderFrameImpl::IsValidCommitUrl detects a navigation URL that would be blocked by RenderProcessHostImpl::FilterURL and rewrites it to about:blank#blocked. See also BrowserRenderProcessHost.BlockedByFilterURL for cases caught by the browser process, and https://crbug.com/40066983. alexmos@chromium.org creis@chromium.org Identifies how ready the renderer process is for processing a CommitNavigation IPC by recording whether the process was ready for processing IPC when CommitNavigation was sent, and if so, whether all prerequisite view/proxy/frame objects were already created. Recorded in the renderer at the end of committing a navigation. alexmos@chromium.org creis@chromium.org Identifies how ready the renderer process is for processing a main frame CommitNavigation IPC by recording whether the process was ready for processing IPC when CommitNavigation was sent, and if so, whether all prerequisite view/proxy/frame objects were already created. Recorded in the renderer at the end of committing navigation. Similar to Navigation.Renderer.ProcessReadiness, but recorded for main frames only. Note that this is not limited to outermost or primary main frames. alexmos@chromium.org creis@chromium.org Measures the duration {DurationFromTo}. Recorded at the point when a navigation finishes committing in the renderer process, i.e. after processing the CommitNavigation message. A corresponding event is also emitted for tracing. rakina@chromium.org chrome-security-architecture@google.com When RendererCancellationThrottle defers navigation, this records whether the navigation actually gets cancelled or not. Recorded when the RendererCancellationThrottle is destroyed. rakina@chromium.org chrome-security-architecture@google.com When RendererCancellationThrottle defers navigation and the navigation actually gets cancelled, records the time it takes from defer start to the cancellation, which causes the RendererCancellationThrottle to be destructed. Recorded when the RendererCancellationThrottle is destroyed. rakina@chromium.org chrome-security-architecture@google.com When RendererCancellationThrottle defers navigation and the navigation is not cancelled, this records whether the throttle hits the timeout or not (the JS task that initiates the navigation finishes earlier than the timeout). Recorded when either the defer timeout is reached, or when the IPC that indicates that JS task that initiates the navigation finishes is received on the browser side. rakina@chromium.org chrome-security-architecture@google.com The time from when the RendererCancellationThrottle defers a navigation until it finishes the JS task that initiates the navigation to finish. Recorded when the IPC that indicates that JS task that initiates the navigation finishes is received on the browser side. cduvall@chromium.org jam@chromium.org Measures the delay between when the navigation commit was sent by the browser to when it is received by the renderer. Recorded for every cross-document non-page activation navigation commit. Warning: this histogram was expired after 2023-05-05 and brought back 2024-05-09; data may be missing. cduvall@chromium.org jam@chromium.org Measures how long the navigation commit was waiting for the renderer process to start before it was able to receive the commit. Recorded for every cross-document non-page activation navigation commit which waits on a process start. Warning: this histogram was expired after 2023-05-05 and brought back 2024-05-09; data may be missing. cduvall@chromium.org jam@chromium.org Measures queue time for the navigation commit mojo task on the renderer side. Recorded for every cross-document non-page activation navigation commit. Warning: this histogram was expired after 2023-05-05 and brought back 2024-05-09; data may be missing. cduvall@chromium.org jam@chromium.org Measures time it takes to call NavigationControllerImpl::RendererDidNavigate. Recorded for each navigation that is not a same document navigation. chikamune@chromium.org chrome-loading@google.com Measures the duration between a) the start timing of the renderer's RunLoop and b) the first CommitNavigation. Recorded on the first navigation commit in the renderer process. If the first navigation does not commit http or https, this is not recorded. rakina@chromium.org chrome-security-architecture@google.com The time it takes for the RenderFrameImpl::Delete() to run. Recorded on every RenderFrameImpl::Delete() call. rakina@chromium.org chrome-security-architecture@google.com The time it takes for the RenderFrameHost constructor to run. Recorded on every RenderFrameHost construction. rakina@chromium.org chrome-security-architecture@google.com The time it takes for the RenderFrameHost destructor to run. Recorded on every RenderFrameHost destruction. rakina@chromium.org chrome-security-architecture@google.com The time it takes for the RenderViewHost constructor to run. Recorded on every RenderViewHost construction. rakina@chromium.org chrome-security-architecture@google.com The time it takes for the RenderViewHost destructor to run. Recorded on every RenderViewHost destruction. rakina@chromium.org chrome-security-architecture@google.com The time it takes for the RenderWidgetHost constructor to run. Recorded on every RenderWidgetHost construction. rakina@chromium.org chrome-security-architecture@google.com The time it takes for the RenderWidgetHost destructor to run. Recorded on every RenderWidgetHost destruction. alexmos@chromium.org lukasza@chromium.org Whether the navigation commits in a SiteInstance that requires a dedicated process. Logged at ready-to-commit time for every navigation excluding same-document navigations and errors. alexmos@chromium.org lukasza@chromium.org Whether the navigation commits in a SiteInstance that requires a dedicated process. Logged at ready-to-commit time for every navigation that commits with a HTTP or HTTPS URL scheme, excluding same-document navigations and errors. khushalsagar@chromium.org liuwilliam@chromium.org Measures the number of same-document navigations which commit in the renderer. The metric is recorded each time the renderer commits a navigation and tracks whether the navigation is eligible for screenshotting for navigation transitions cduvall@chromium.org jam@chromium.org Measures the time RenderFrameHostImpl::SendCommitNavigation takes to run. Recorded every time the method executes. gjc@google.com chrome-loading@google.com Record if the navigation can be potentially resumed when the render process is gone for the speculative RenderFrameHost. The UMA is recorded each time the render process for the speculative RenderFrameHost is gone and the corresponding navigation is not committed yet. The UMA records true if the navigation has not processed the network response yet. creis@chromium.org alexmos@chromium.org Records whether an adjustment was made to the start time of a cross-document navigation, and what the reason was if so. This metric is recorded each time a cross-document navigation finishes. (Same-document navigations never have adjustments.) This includes both main frame and subframe navigations, the latter of which are less likely to have adjustments. See also Navigation.StartAdjustment.MainFrameOnly. creis@chromium.org alexmos@chromium.org Records how many milliseconds the navigation start time was delayed, in cases where it was adjusted to after a beforeunload dialog was displayed. See also Navigation.StartAdjustment.BeforeUnloadDialog.Percentage. creis@chromium.org alexmos@chromium.org Records how many milliseconds the navigation start time was unexpectedly moved earlier (due to a bug with updating the wrong NavigationRequest), in cases where it was adjusted to after a beforeunload dialog was displayed. No corresponding percentage is reported in these cases. creis@chromium.org alexmos@chromium.org Records the percentage of navigation time that was ignored, in cases where the start time was adjusted to after a beforeunload dialog was displayed. creis@chromium.org alexmos@chromium.org Records how many milliseconds the navigation start time was delayed, in cases where it was adjusted to after beforeunload handlers ran, when no dialog was displayed. See also Navigation.StartAdjustment.BeforeUnloadHandlers.Percentage. creis@chromium.org alexmos@chromium.org Records how many milliseconds the navigation start time was unexpectedly moved earlier (due to a bug with updating the wrong NavigationRequest), in cases where it was adjusted to after beforeunload handlers ran, when no dialog was displayed. No corresponding percentage is reported in these cases. creis@chromium.org alexmos@chromium.org Records the percentage of navigation time that was ignored, in cases where the start time was adjusted to after beforeunload handlers ran, when no dialog was displayed. creis@chromium.org alexmos@chromium.org Records how many milliseconds the navigation start time was delayed, in cases where it was adjusted to after a legacy PostTask was run, when no beforeunload handlers were registered. See also Navigation.StartAdjustment.LegacyPostTask.Percentage. creis@chromium.org alexmos@chromium.org Records how many milliseconds the navigation start time was unexpectedly moved earlier (due to a bug with updating the wrong NavigationRequest), in cases where it was adjusted to after a legacy PostTask was run, when no beforeunload handlers were registered. No corresponding percentage is reported in these cases. creis@chromium.org alexmos@chromium.org Records the percentage of navigation time that was ignored, in cases where the start time was adjusted to after a legacy PostTask was run, when no beforeunload handlers were registered. creis@chromium.org alexmos@chromium.org Records whether an adjustment was made to the navigation start time in a cross-document navigation targeting a primary main frame, and what the reason was if so. This metric is recorded each time a cross-document navigation finishes in a primary main frame. (Same-document navigations never have adjustments.) nasko@chromium.org csharrison@chromium.org The time delta between the start of a navigation and the time it is committed. Warning: this histogram was expired after M85 and brought back 2021-04-13; data may be missing. {NavigationProcessType} fergal@chromium.org rakina@chromium.org Records the combination of mainframe/subframe and what sudden termination disablers were present. This is recorded on every cross-document navigation. Currently only covers Unload. The SameOrigin variant only considers a frame to be same origin as the main frame if it can be reached through a chain of same-origin frames. So e.g. in a->b->a, the second a is not same-origin. rakina@chromium.org bfcache-dev@chromium.org Records the time between when the surface used for a new document gets embedded by the browser process to when the first contentful paint frame for the new document is received by Viz. Logged after the first contentful frame has been displayed on screen. toyoshim@chromium.org chrome-loading@google.com Measures the total count of navigation throttles that are actually registered for a navigation request. Recorded per navigation on destructing NavigationThrottleRunner. Warning: this histogram was expired from 2025-12-01 to 2026-01-06; data may be missing. toyoshim@chromium.org chrome-loading@google.com Records the navigation throttle event type that observes DEFER on running NavigationThrottles. Recorded per receiving DEFER decision on each throttle run to understand the distribution. cduvall@chromium.org toyoshim@chromium.org chrome-loading@google.com Measures time a navigation throttle was deferred when on {Event}. Logged every time a throttle defers a navigation. Warning: this histogram was expired from 2023-02-11 to 2024-06-17; data may be missing. toyoshim@chromium.org chrome-loading@google.com Measures time a navigation throttle runner took to execute all throttles for {Event} including suspended duration by DEFERs. Logged every time a navigation throttle runner completes processing all throttles for {Event} without any objection. toyoshim@chromium.org chrome-loading@google.com Measures accumulated time a navigation throttle runner took to execute all throttles for {Event}. Logged every time a navigation throttle runner completes processing all throttles for {Event} without any objection. cduvall@chromium.org toyoshim@chromium.org chrome-loading@google.com Measures time a navigation throttle took to execute {Event}. Logged every time a throttle runs. Warning: this histogram was expired from 2023-02-11 to 2024-06-17; data may be missing. toyoshim@chromium.org chrome-loading@google.com Measures total count of deferred requests that a throttle runner asked on {Condition} by any throttle per navigation. Recorded per navigation on destructing NavigationThrottleRunner. toyoshim@chromium.org chrome-loading@google.com Measures total duration time that a throttle runner took to wait for deferred requests on {Condition} from all throttles. Recorded per navigation on destructing NavigationThrottleRunner. alexmos@chromium.org creis@chromium.org Reports how much time from beforeunload phases 1 and 2 was correctly excluded from the Navigation.Timeline.TotalExcludingBeforeUnload.Duration metric, so that beforeunload handlers and dialogs would not be counted as part of the navigation. Recorded at the point when a navigation finishes committing, i.e. finishes processing the DidCommitNavigation message. A corresponding event is also emitted for tracing. alexmos@chromium.org creis@chromium.org Reports how much time navigation guardrail metrics like FCP are incorrectly excluding from the navigation duration, due to collecting start times after beforeunload phase 1 finishes and possibly adjusting them to after beforeunload phase 2 finishes. This excluded time represents actual time the user is waiting that is not accounted for in current metrics. Recorded at the point when a navigation finishes committing, i.e. finishes processing the DidCommitNavigation message. A corresponding event is also emitted for tracing. alexmos@chromium.org creis@chromium.org Reports how much time navigation guardrail metrics like FCP are incorrectly excluding from the navigation duration, due to collecting start times after beforeunload phase 1 finishes and possibly adjusting them to after beforeunload phase 2 finishes. This excluded time represents actual time the user is waiting that is not accounted for in current metrics. This metric is recorded each time a cross-document navigation finishes in a primary main frame, i.e. finishes processing the DidCommitNavigation message. See also Navigation.Timeline.IgnoredIncorrectly.Duration for all navigations, including subframes and same-document cases. creis@chromium.org alexmos@chromium.org Records the percentage of navigation time that was incorrectly ignored due to setting the start time later than it should be. See also Navigation.Timeline.IgnoredIncorrectly.MainFrameOnly.Duration. This metric is recorded each time a cross-document navigation finishes in a primary main frame, i.e. finishes processing the DidCommitNavigation message. See also Navigation.Timeline.IgnoredIncorrectly.Percentage for all navigations, including subframes and same-document cases. creis@chromium.org alexmos@chromium.org Records the percentage of navigation time that was incorrectly ignored due to setting the start time later than it should be. See also Navigation.Timeline.IgnoredIncorrectly.Duration. Recorded at the point when a navigation finishes committing, i.e. finishes processing the DidCommitNavigation message. A corresponding event is also emitted for tracing. chikamune@chromium.org chrome-loading@google.com Measures the duration from a) the OS-level timestamp of the user input event that started a navigation to b) when the "actual" navigation starts. Recorded at the point when a navigation finishes committing, i.e. finishes processing the DidCommitNavigation message. This is recorded only for main frame cross-document navigations where the user interaction timestamp is available. chikamune@chromium.org chrome-loading@google.com Measures the duration from a) the OS-level timestamp of the user input event that started a navigation to b) when the navigation finishes committing {ExcludingBeforeUnload}. This is recorded only for main frame cross-document navigations where the user interaction timestamp is available. creis@chromium.org alexmos@chromium.org Measures the duration between when the navigation starts to when the browser process finishes processing the DidCommitNavigation IPC, at which point the navigation is committed{ExcludingBeforeUnload}. This metric is recorded each time a cross-document navigation finishes in a primary main frame, i.e. finishes processing the DidCommitNavigation message. See also Navigation.Timeline.TotalExcludingBeforeUnload.Duration or Navigation.Timeline.TotalExcludingBeforeUnloadDialog.Duration for all navigations, including subframes and same-document cases. alexmos@chromium.org creis@chromium.org Measures the duration between {DurationFromTo}. Recorded at the point when a navigation finishes committing, i.e. finishes processing the DidCommitNavigation message. A corresponding event is also emitted for tracing. nhiroki@chromium.org sreejakshetty@chromium.org chrome-prerendering@google.com The time needed to commit a navigation using prerender activation. This is the time from the beginning of NavigationStart to the end of DidCommitPageActivation. This metric is logged everytime prerender activation navigation commits. clamy@chromium.org nasko@chromium.org The time delta between the start of a navigation and the time it is ready to commit. Warning: this histogram was expired after M85 and brought back 2021-04-13; data may be missing. {NavigationProcessType} rakina@chromium.org chrome-security-architecture@google.com The time it takes for RenderFrameHostImpl::Unload() to run. Recorded on every RenderFrameHostImpl::Unload() call. yyanagisawa@chromium.org chrome-loading@google.com Records whether a ClientHintsControllerDelegate was available when creating a resource request for a navigation. This is part of investigating if the delegate is sometimes missing when it should be present. yyanagisawa@chromium.org chrome-loading@google.com Records NavigationURLLoader is executed as the main path or not. This is recorded on each main resource load on navigation. Multiple events will be recorded for redirect cases. yyanagisawa@chromium.org chrome-loading@google.com When a server sends an Accept-CH frame, the browser may need to restart the navigation to include additional client hints. This can be avoided if the network service can determine that all critical hints are already present. If the network service cannot determine this, it asks the browser process. This histogram is recorded when the browser process checks for missing critical hints, and indicates the result. yyanagisawa@chromium.org chrome-loading@google.com Records whether the enabled client hints at resource request creation time match the enabled client hints at the time OnAcceptCHFrameReceived is called. This is to debug why the Accept-CH offloading optimization is not performing as expected. yyanagisawa@chromium.org chrome-loading@google.com As part of the Accept-CH offloading optimization, the browser calculates the set of enabled client hints at the start of a navigation. This set can be re-evaluated later (e.g., after receiving an `Accept-CH` frame). When the initial set of hints does not match the re-evaluated set (recorded as 'false' in the parent `Navigation.URLLoader.OnAcceptCHFrameReceived.EnabledClientHintsMatch` histogram), this metric is recorded to identify which part of the information differed. Specifically, it records whether the {ClientHintsMismatchType} matches. yyanagisawa@chromium.org chrome-loading@google.com Record the time to execute Accept-CH receiver function in NavigationURLLoader. It is recorded just before returning from the OnAcceptCHFrameReceived() IPC, and is an elapsed time from the function is called to returning. Refer to NavigationURLLoaderImpl::OnAcceptCHFrameReceived() for details. Note: The metrics is reported from all clients. Some of clients may not have high resolution timer that can send metrics with microseconds precision. yyanagisawa@chromium.org chrome-loading@google.com As part of the Accept-CH offloading optimization, the browser compares the set of enabled client hints calculated at the start of a navigation with a re-evaluated set from later in the process. When the list of specific hint types within these sets does not match (recorded as 'false' in the `Navigation.URLLoader.OnAcceptCHFrameReceived.EnabledClientHintsMatch.Hints` histogram), this metric is recorded for each hint that is present in one list but not the other. This helps identify exactly which client hints are causing the mismatch. kouhei@chromium.org chrome-loading@google.com The time elapsed between the original navigation start and the restarted navigation start due to an ACCEPT_CH frame, estimating the additional time incurred by an ACCEPT_CH frame restart. This is recorded every time a navigation is restarted due to an ACCEPT_CH frame{OffTheRecordStatus}. yyanagisawa@chromium.org chrome-loading@google.com Records the code location where the Accept-CH receiver function in NavigationURLLoader returns. This is recorded each time OnAcceptCHFrameReceived is called{OffTheRecordStatus}. Refer to NavigationURLLoaderImpl::OnAcceptCHFrameReceived() for details. yyanagisawa@chromium.org chrome-loading@google.com Records the round trip time to parse headers for {Case}. Note: The metrics is reported from all clients. Some of clients may not have high resolution timer that can send metrics with microseconds precision. miketaylr@chromium.org katabolism-finch@google.com The type of the user agent string value sent in the User-Agent header on a navigation request. The reduced user agent string is sent when User-Agent reduction feature kReduceUserAgentMinorVersion is enabled. This histogram is recorded when a NavigationRequest is constructed, prior to sending the request to the network stack. rakina@chromium.org chrome-security-architecture@google.com For {InitiatorType} navigations that result in wasting a speculative RFH that's previously created for the navigation (i.e. when the WastedSpeculativeRFHCase metric records kWasted_NowUseCurrentRFH or kWasted_NowUseNewSpeculativeRFH), records whether the cross-origin isolation state for the wasted speculative RFH and the new RFH differs. Recorded on RenderFrameHostManager::GetFrameHostNavigation(), for {InitiatorType} navigations that picked a RenderFrameHost that is different from the speculative RFH previously created for the navigation. rakina@chromium.org chrome-security-architecture@google.com For {InitiatorType} navigations that result in wasting a speculative RFH that's previously created for the navigation (i.e. when the WastedSpeculativeRFHCase metric records kWasted_NowUseCurrentRFH or kWasted_NowUseNewSpeculativeRFH), records whether the renderer process for the wasted speculative RFH and the new RFH differ. Recorded on RenderFrameHostManager::GetFrameHostNavigation(), for {InitiatorType} navigations that picked a RenderFrameHost that is different from a speculative RFH previously created for the navigation. rakina@chromium.org chrome-security-architecture@google.com For {InitiatorType} navigations that result in wasting a speculative RFH that's previously created for the navigation (i.e. when the WastedSpeculativeRFHCase metric records kWasted_NowUseCurrentRFH or kWasted_NowUseNewSpeculativeRFH), records whether a new renderer process is created by the RFH that replaces the wasted speculative RFH. These cases add latency while waiting for a new process at commit time. Recorded on RenderFrameHostManager::GetFrameHostNavigation(), for {InitiatorType} navigations that picked a RenderFrameHost that is different from the speculative RFH previously created for the navigation. rakina@chromium.org chrome-security-architecture@google.com For {InitiatorType} navigations that result in wasting a speculative RFH that's previously created for the navigation (i.e. when the WastedSpeculativeRFHCase metric records kWasted_NowUseCurrentRFH or kWasted_NowUseNewSpeculativeRFH), records whether a new renderer process was likely created when creating the wasted speculative RFH. These cases indicate a fair amount of work was wasted. Recorded on RenderFrameHostManager::GetFrameHostNavigation(), for {InitiatorType} navigations that picked a RenderFrameHost that is different from the speculative RFH previously created for the navigation. rakina@chromium.org chrome-security-architecture@google.com Records whether a call to RenderFrameHostManager::GetFrameHostNavigation() for {InitiatorType} navigation resulted in "wasting" a speculative RFH previously created for the navigation. Recorded on {InitiatorType} navigations after picking its RenderFrameHost in RenderFrameHostManager::GetFrameHostNavigation(). Note that this can be called multiple times for each navigation. cduvall@chromium.org sisidovski@chromium.org chrome-loading@google.com Measures the amount of time the {Stage} stage takes in early navigation. Logged for any navigation that reaches the stage. This was not reported between 2023-05-06 and 2024-06-28. rakina@chromium.org bfcache-dev@chromium.org Records the time duration between when the navigation that uses a new RenderWidgetHost reaches {Stage} and when the creation of the CompositorFrameSink for the RenderWidgetHost is requested. Logged when the compositor is requested and the navigation that created the RenderWidgetHost had already reached both the commit and swap RFH stages. rakina@chromium.org chrome-security-architecture@google.com The time it takes to run {TracedMethod}. Recorded everytime {TracedMethod} is triggered. suzukikeita@google.com chrome-loading@google.com The number of preconnect failures that happened before a successful connection. This is recorded when the `SearchEnginePreconnector` detects a connection close of a "long" session (i.e. was not considered as short per comparison with the threshold). suzukikeita@google.com chrome-loading@google.com The duration between successive preconnect attempts made by the `SearchEnginePreconnector`. This is recorded when receiving the preconnect-emitting event. suzukikeita@google.com chrome-loading@google.com The duration `SearchEnginePreconnector` waits until running the next preconnect attempt from the timing when preconnect-emitting event has been issued. This is recorded when receiving the preconnect-emitting event and when the delay has been calculated. suzukikeita@google.com chrome-loading@google.com The protocol utilized to establish this connection session for SearchEnginePreconnector. Recorded when a preconnected network session has been successfully established to the search engine host. suzukikeita@google.com chrome-loading@google.com The setup time (connection latency), including TLS and TCP handshakes, to successfully construct the network connection session. Recorded in milliseconds when the session is successfully established for SearchEnginePreconnector. suzukikeita@google.com chrome-loading@google.com The trigger type of the client (either an active preconnect attempt or a standard web request) which led to the connection establishment. Recorded when the session has been successfully established for SearchEnginePreconnector. suzukikeita@google.com chrome-loading@google.com The event which triggered a preconnect. This is recorded when each event is received by the `SearchEnginePreconnector`. meacer@chromium.org chrome-secure-web-and-net@chromium.org Tracks events when the currently navigated domain name in a non-incognito tab is a lookalike to one of the top 10K domains or a domain that the user interacted with, resulting in a navigation suggestion interstitial. Before M88, NavigationSuggestion.Event recorded a separate entry for each lookalike URL in a redirect chain. E.g. lookalike1.com -> site.com -> lookalike2.com recorded two events. This updated histogram only records an entry for the first or last URL in the redirect if any of those is a lookalike. meacer@chromium.org chrome-secure-web-and-net@chromium.org Tracks events when the currently navigated domain name in an incognito tab is a lookalike to one of the top 10K domains or a domain that the user interacted with, resulting in a navigation suggestion interstitial. meacer@chromium.org blundell@chromium.org security-enamel@chromium.org Records the time duration that PerformChecks() spent in calls to GetDomainInfo() before the navigation was ultimately allowed to proceed. Recorded only for navigations that LookalikeUrlNavigationThrottle::PerfomChecks() directly allows to proceed (i.e., not those that result in showing interstitials and/or digital asset manifest checks). Note this histogram was expired between 2024-11 and 2025-09. meacer@chromium.org blundell@chromium.org security-enamel@chromium.org Records the time duration that PerformChecks() spent in calls to IsLookalikeUrl() before the navigation was ultimately allowed to proceed. Recorded only for navigations that LookalikeUrlNavigationThrottle::PerfomChecks() directly allows to proceed (i.e., not those that result in showing interstitials and/or digital asset manifest checks). Note this histogram was expired between 2024-11 and 2025-09. meacer@chromium.org blundell@chromium.org security-enamel@chromium.org Records the time duration the navigation was deferred while PerformChecks() was executing before the navigation was ultimately allowed to proceed. Recorded only for navigations that LookalikeUrlNavigationThrottle::PerfomChecks() directly allows to proceed (i.e., not those that result in showing interstitials and/or digital asset manifest checks). Note this histogram was expired between 2024-06 and 2025-09. meacer@chromium.org cduvall@chromium.org security-enamel@chromium.org Records the time duration the navigation was deferred while waiting for engaged sites data. Recorded whenever a navigation is deferred waiting for engaged sites. annasato@google.com rakina@google.com chrome-navigation@google.com Records the cookie change status only for potential duplicate navigations where criteria such as URL, initiator, method, and transition match. It distinguishes whether a CookieChangeListener was missing, cookies actually changed since the ongoing navigation started, or cookies remained the same. annasato@google.com chrome-navigation@google.com When a new navigation is a duplicate of a currently ongoing navigation, where the destination and params are the same, records whether the input_start timestamp was available on the new navigation, the old (ongoing) navigation, both, or neither. annasato@google.com chrome-navigation@google.com When a new navigation is a duplicate of a currently ongoing navigation, where the destination and params are the same, records the difference between the new navigation's input start time and the ongoing (old) navigation's input start time {DuplicateNavTargetScope}. rakina@chromium.org chrome-navigation@google.com When a new navigation is a duplicate of a currently ongoing navigation, where the destination and params are the same, records whether the difference between the new navigation's start time and the previous navigation's start time is under the threshold defined by kDuplicateNavThreshold (defaults to 2s). Logged when the new navigation is triggered and about to take the place of the old navigation {DuplicateNavTargetScope}. annasato@google.com rakina@google.com chrome-navigation@google.com Records whether a duplicate navigation's URL matches the origins specified in IgnoreDuplicateNavsOrigins parameter. This is recorded for both browser-initiated and renderer-initiated navigations when the feature kIgnoreDuplicateNavs is enabled and an origin list is provided. rakina@chromium.org bfcache-dev@chromium.org When a new navigation is a duplicate of a currently ongoing navigation, where the destination and params are the same, records the difference between the new navigation's start time and the previous navigation's start time. Logged when the new navigation is triggered and about to take the place of the old navigation {DuplicateNavTargetScope}. rakina@chromium.org chrome-navigation@google.com Whether a new navigation is a duplicate of a currently ongoing navigation, where the destination and params are the same. This does not do a navigation start threshold check, so this will be true even if the new navigation started a long time after the previous navigation. Logged when the new navigation is triggered and about to take the place of the old navigation {DuplicateNavTargetScope}. chikamune@chromium.org chrome-loading@google.com Records whether a {Initiator} navigation required to use the beforeunload logic or not. If using the beforeunload logic in the browser process to post a task is necessary for legacy reasons, as described in the code comment of RenderFrameHostImpl::SendBeforeUnload(), true will be recorded. This is recorded on each {Initiator} navigation. lingqi@chromium.org chrome-prerendering@google.com Warning: this histogram was expired from 2024-03-01 to 2025-02-20, and 2025-08-01 to 2025-09-16; data may be missing. Tracks the prerender cancellations caused by inactive RenderFrameHosts' restrictions, recording the reason passed to RenderFrameHost::IsInactiveAndDisallowActivation calls. This metric is recored when a RenderFrameHost is going to perform some actions that are not allowed for a prerendering RenderFrameHost, such as showing context menu. At that time, the detailed reason will be passed to RenderFrameHost::IsInactiveAndDisallowActivation, which will cancel prerendering and record this metric. Note: This histogram does not track prerender activation behavior, but to analyze PrerenderHostFinalStatus::kInactivePageRestriction. Warning: this histogram was expired from 2023-03-01 to 2023-03-29; data may be missing. lingqi@chromium.org chrome-prerendering@google.com Breakdown metric for PrerenderActivationNavigationParamsMatch::kHttpRequestHeader. We are considering whether we should loosen this restriction, so this metric is added to figure out the usage of headers during prerender navigation and activation navigation. See https://crbug.com/1378921 for more information. When we are attempting to activate a prerendered page, we compare the prerendered page's NavigationRequest's headers with the incoming NavigationRequest's (called activation navigation). If they mismatch, PrerenderHost will post a task. The task scans the two headers, and will report a mismatching record if it detects any differences between them. It records the hashed number of a mismatching header, together with the mismatching reason: Missing in prerendering navigation, missing in activation navigation, or the values mismatch. Warning: this histogram was expired from 2023-01-31 to 2023-03-29; data may be missing. lingqi@chromium.org chrome-prerendering@google.com Recorded by WebViewImpl::ActivatePrerenderedPage when renderer process starts to ask the receiver end of the prerender activation IPC to process this signal, i.e., when this method is invoked. This metric is used to measure the delay of when renderer process receives the signal and when it can process this signal. Recorded on the main document only. nhiroki@chromium.org chrome-prerendering@google.com Records the mismatched parameters between the prerender initial navigation parameters and the prerender activation navigation parameters. Recorded by PrerenderHost in the browser process when comparing these two parameters. nhiroki@chromium.org chrome-prerendering@google.com Breakdown metric for PrerenderActivationNavigationParamsMatch::kTransition. When we are attempting to activate a prerendered page, we compare the prerendered page's NavigationRequest's ui::PageTransition with the incoming NavigationRequest's (called activation navigation). If they mismatch, this metric records the transition of the activation navigation in RecordPrerenderActivationTransition(). lingqi@chromium.org nhiroki@chromium.org src/content/browser/preloading/prerender/OWNERS Warning: this histogram was expired from 2025-08-01 to 2025-09-16; data may be missing. A breakdown metric for analyzing cross-origin redirection cases during embedder-triggered prerendering, Recorded when redirections were caused due to HTTP protocol upgrades. Note that for now it is not used for prerendering that are triggered by speculation rules. gjc@google.com chrome-prerendering@google.com chrome-loading@google.com Records whether there is a PrerenderHost can be reused when creating a new PrerenderHost. The UMA is recorded each time a new PrerenderHost is constructed. nhiroki@chromium.org chrome-prerendering@google.com Records the number of PrerenderHosts that match the potential activation navigation. This is recorded when the navigation chooses one of the hosts in PrerenderHostRegistry::FindPotentialHostToActivate(). nhiroki@chromium.org chrome-prerendering@google.com Records the prediction status started by omnibox. In particular, this records whether they were used or not. It's recorded when omnibox-initiated navigation finishes. Consider it as a success when the prediction is correct and note that the activation of prerendering may fail. nhiroki@chromium.org chrome-prerendering@google.com Records the prediction status started by omnibox. In particular, this records whether they were used or not. It's recorded when omnibox-initiated navigation finishes. Consider it as a success when the prediction is correct and note that the activation of prerendering may fail. kenoss@chromium.org chrome-prerendering@google.com Status of prefetch ahead of prerender. Recorded by PrerenderHost or PrerenderHostRegistry in the browser process when the attempt finishes. Recorded only if prerender failed due to prefetch. Warning: this histogram was expired from 2025-03-10 to 2026-07-02; data may be missing. nhiroki@chromium.org toyoshim@chromium.org lingqi@chromium.org Mojo interfaces that cause the cancellation of prerendering. Recorded by MojoBinderPolicyApplier in the browser process once it receives the binding request of a kCancel Mojo interface. nhiroki@chromium.org toyoshim@chromium.org lingqi@chromium.org This histogram tracks the interfaces that Prerender.Experimental.PrerenderCancelledInterface fails to track. It is needed because: * Embedders can set their own policies, so Prerender2 cannot map all of them to enums. * Channel-associated interfaces' policies are set to kCancel implicitly. It's hard to track all of them, especially the newly added channel-associated interfaces. This sparse histogram allows Prerender2 to record all of these interfaces separately. It is recored by MojoBinderPolicyApplier in the browser process once it receives the binding request of a kCancel Mojo interface and cannot find an accurate enum type for this interface. lingqi@chromium.org nhiroki@chromium.org src/content/browser/preloading/prerender/OWNERS Warning: this histogram was expired from 2024-06-01 to 2024-08-06; data may be missing. A breakdown metric for analyzing cross-origin redirection cases during embedder-triggered prerendering. Recorded when the embedder-triggered prerendering was redirected to another origin that differs from the initial one. The cases are encoded into 3 bits(scheme mismatch, host mismatch, port mismatch). Note that for now it is not used for prerendering that are triggered by speculation rules. nhiroki@chromium.org toyoshim@chromium.org lingqi@chromium.org chrome-prerendering@google.com Final status for a prerendering attempt. Recorded by PrerenderHost or PrerenderHostRegistry in the browser process when the attempt finishes. lingqi@chromium.org chrome-prerendering@google.com Net error code is recorded by PrerenderCancellationReason when a prerender host is canceled due to kDidFailLoad. This metric is used to monitor whether preload cache intercepting logic causes extra page loading errors. Similar to PageLoad.Internal.Prerender2.ActivatedPageLoaderStatus{PreloadingTriggerType}, but used to track the loading status of not activated prerendered pages. gjc@google.com chrome-prerendering@google.com chrome-loading@google.com Records whether there is a PrerenderHost matching the navigation or under the same origin or same host as the navigation so that its renderer process can be reused. The UMA is recorded when the navigation chooses one of the hosts in PrerenderHostRegistry::FindPotentialHostToActivate(). toyoshim@chromium.org chrome-loading@google.com Records the decision whether PrerenderManager can start prewarming in the current context and settings. This decision is made and recorded per each prewarm request. taiyo@chromium.org chrome-prerendering@google.com Records the number of received speculation rules prerender triggers with eagerness per primary page changed, classified with their eagerness. This is coutend per PrerendererImpl::MaybePrerender and recorded when primary page is changed and PrerendererImpl::CancelStartedPrerenders is called. Note that this metric only records where PreloadingTriggerType is SpeculationRule and SpeculationRuleFromIsolatedWorld. See https://crbug.com/40287486 for the history of the histogram changes. suzukikeita@google.com gjc@google.com chrome-prerendering@google.com chrome-loading@google.com Records the number of PrerenderHosts when we failed to find a reuseable PrerenderHost. The UMA is recorded each time a new PrerenderHost is constructed and we failed to find a reuseable PrerenderHost. lingqi@chromium.org chrome-prerendering@google.com Warning: this histogram was expired from 2023-11-20 to 2024-02-27; data may be missing. Recorded by StreamingSearchPrefetchURLLoader in its destructor. This instance is created per (non-duplicated) prefetch attempt. The destructor runs upon: - Case 1: A prefetched response is deleted upon expiration or network error. - Case 2: A prefetched response deletes itself after finishing serving to navigations. This will be executed asynchronously. See comments in StreamingSearchPrefetchURLLoader for more information. Indicates the number of prerendering DSE navigation that one prefetched response served to. In most cases, it should record 0 (which means the loader does not serve to any prerendering navigations) or 1 (served to one prerender). And we will track the count that is greater than 2 to determine whether the loader should be designed to target multiple serving destinations. This number should be quite small (0 or 1 in most cases), so the count is capped at 9 and put into 10 buckets, from 0 to 9. nhiroki@chromium.org chrome-prerendering@google.com Finished reason of waiting for the No-Vary-Search header. Recorded by PrerenderHost in the browser process when the header is received, the timeout timer runs, or cancellation happens. robertlin@chromium.org chrome-prerendering@google.com To record whether a prerendering attempt initiated by prerender {PreloadingEmbedderType} trigger is trying to prerender a SRP url or not. This is recorded when {PreloadingEmbedderType}PreloadPipelineManager::StartPrerender is called to initiate a SPR url, which is the list of affected prerender triggers in https://crbug.com/40066983. gambard@chromium.org justincohen@chromium.org Whether the load was completed when the pre-render was used. If the prerender is cancelled, this is not logged. Only on iOS. gambard@chromium.org justincohen@chromium.org This is the time from when a prerendered page begins to load to when it is swapped in as the main page load or to when the pre-loaded page is fully loaded, whichever came first. Recorded when the swap occurs, only on iOS. ryansturm@chromium.org tbansal@chromium.org Final status for prerender pages - either success, or why it was canceled. {PrerenderSource}