Google Git
Sign in
chromium / chromium / src / main / . / content / browser / preloading / prerender
tree: 0a7d3414f1090bc8805b9a3d32ba3c53cc1e0ca3 [path history] [tgz]
  1. COMMON_METADATA
  2. devtools_prerender_attempt.cc
  3. devtools_prerender_attempt.h
  4. DIR_METADATA
  5. OWNERS
  6. prerender_attributes.cc
  7. prerender_attributes.h
  8. prerender_browsertest.cc
  9. prerender_commit_deferring_condition.cc
  10. prerender_commit_deferring_condition.h
  11. prerender_features.cc
  12. prerender_features.h
  13. prerender_final_status.cc
  14. prerender_final_status.h
  15. prerender_handle_impl.cc
  16. prerender_handle_impl.h
  17. prerender_host.cc
  18. prerender_host.h
  19. prerender_host_registry.cc
  20. prerender_host_registry.h
  21. prerender_host_registry_unittest.cc
  22. prerender_host_unittest.cc
  23. prerender_metrics.cc
  24. prerender_metrics.h
  25. prerender_metrics_unittest.cc
  26. prerender_navigation_throttle.cc
  27. prerender_navigation_throttle.h
  28. prerender_navigation_utils.cc
  29. prerender_navigation_utils.h
  30. prerender_new_tab_handle.cc
  31. prerender_new_tab_handle.h
  32. prerender_no_vary_search_commit_deferring_condition.cc
  33. prerender_no_vary_search_commit_deferring_condition.h
  34. prerender_no_vary_search_hint_commit_deferring_condition.cc
  35. prerender_no_vary_search_hint_commit_deferring_condition.h
  36. prerender_subframe_navigation_throttle.cc
  37. prerender_subframe_navigation_throttle.h
  38. prerender_url_loader_throttle.cc
  39. prerender_url_loader_throttle.h
  40. README.md
content/browser/preloading/prerender/README.md

This directory contains the Prerender2 implementation (https://crbug.com/1126305).

If you're interested in relevant code changes, join the [email protected] group.

Summary

Prerendering is “pre”-rendering, it's about pre-loading and rendering a page before the user actually navigates to it. The main goal of prerendering is to make the next page navigation faster, or ideally nearly instant.

The Prerender2 is the new implementation of prerendering.

Terminology

  • Trigger: “Trigger” is an entry point to start prerendering. Currently, <script type="speculationrules"> is the only trigger in content/. Embedders may define their triggers by calling WebContents::StartPrerendering.
  • Activate: The Prerender2 runs navigation code twice: navigation for prerendering a page, and navigation for displaying the prerendered page. “Activate” indicates the latter navigation.
  • Legacy Prerender: “Legacy Prerender” is the previous implementation of prerendering that does not use NoStatePrefetch. This is already deprecated (https://crbug.com/755921).
  • NoStatePrefetch: An internal mechanism for speculative prefetching of pages and their subresources that are on a critical path of page loading without executing any JavaScript or creating a complex state of the web platform (https://www.chromestatus.com/feature/5928321099497472). This mechanism is not purely “no state” because the HTTP cache allows to create cookies and other state related to validating cache entries. The current prerendering uses this mechanism, that is, it does not actually render pages, while the Prerender2 renders pages.
  • Activation-gated APIs: Web platform APIs that are dependent on user activation. Prerendered pages never have user activation, so the activation-gated APIs automatically fail or no-op in the prerendered pages. The known activation-gated APIs are listed here.

UKM Source Ids

As previously mentioned, there are two navigations involved in Prerender2: the prerendering navigation and the activation navigation. As a result, there are two UKM Source IDs that are currently used for a prerendered page; one derived from each navigation's ID.

The SourceId for the prerendering navigation is currently returned by RenderFrameHost::GetPageUkmSourceId(), and by NavigationHandle::GetNextPageUkmSourceId() when called on the NavigationHandle for the prerendering navigation. This source ID is not associated with a URL by SourceUrlRecorder (the data collection policy disallows recording it before prerender activation), so any metrics recorded using it will not be associated with a URL.

The SourceId for the activation navigation is associated with a URL by SourceUrlRecorder. The value is currently returned by NavigationHandle::GetNextPageUkmSourceId() when called on the NavigationHandle for the activation navigation, and by PageLoadMetricsObserverDelegate::GetPageUkmSourceId (and is used by all PLMOs that record UKMs for prerendered pages).

There are 2 patterns recording metrics for prerendering pages used currently in content/:

  1. Use the source ID of the most recently navigated primary page (obtained from NavigationHandle::GetNextPageUkmSourceId(), which uses the activation navigation ID for prerender activations). This UKM source ID is always associated with a URL. This approach is currently used by Precog (the UKM infrastructure in content/browser/preloading) to record the Preloading_Prediction and Preloading_Attempt UKMs.

  2. Use the triggering page‘s UKM source ID to record metrics for a prerendering page. PrerenderHost uses this approach currently to record the PrerenderPageLoad UKM, which it reports even if the prerendered page isn’t activated. Precog also uses this approach to record the Preloading_Attempt_PreviousPrimaryPage UKM. They both currently use RenderFrameHost::GetPageUkmSourceId to retrieve the source ID, which will be associated with a URL in most cases, except when the triggering page itself was prerendered.

Another possible approach is to collect/remember metrics while prerendering and only record them using the activation navigation's source ID after the prerender is activated (a similar pattern is used by PageLoadMetricsObservers outside content/). In the future, we may want to support recording UKMs after activation with both source IDs. This will require registering the prerender navigation source ID with a URL after activation.

Tips for Chromium Developers

Note that this section is targeting Chromium developers, to help diagnose issues where prerendering needs to be enabled or disabled. For web development, see Prerender pages in Chrome for instant page navigations and Debugging speculation rules.

Debugging tips

Force-enable prerendering

Prerendering a link on a page

  1. Download the extension of Prerender Tweak.
  2. Install it in chrome://extensions.
  3. Click the icon of the extension to see how to trigger prerendering in this case.

Prerendering a URL

For now the best strategy is to prerender the url with the bookmark bar's help.

  1. Enable prerendering bookmark bar with command line --enable-features=BookmarkTriggerForPrerender2
  2. Save the URL as a bookmark. Ensure the icon is displayed on the bookmark bar.
  3. Trigger prerendering by clicking the button OR hovering more than 300ms.

Note it is expected that prerender2 would only prerender HTTPS sites with this approach.

An alternative is to trigger prerender with Direct URL Input in omnibox. Refer to Demonstration of URL-bar-triggered Omnibox prerendering, which demonstrates how to trigger it.

Force-disable all prerender triggers

Force-disable specific prerender triggers

Use feature param PreloadingConfig:preloading_config.

Example:

  1. Make preloading config JSON. Default value is here. You can disable starting preloadings by putting holdback: true for each entry.
  2. Minify and URL-encode it. E.g. cat - | jq -c . | jq -sRr @uri | sed 's/%0A//g'.
  3. Use an option --enable-features="PreloadingConfig:preloading_config/<url_encoded_preloading_config>.

Note that FeatureParam doesn't decode %20 and + [cs]. Minification is recommended.

Tell whether prerender has started

  • For speculationrules-triggered ones, refer to Debugging speculation rules.
  • For embedder-triggered ones:

    • Determine whether prerender is running with chrome://process-internals

      1. Open chrome://process-internals/#web-contents
      2. Find the corresponding WebContents to the tab where you will trigger prerendering.
      3. Attempt to trigger prerendering.
      4. Click Refresh button in the process-internals page (just below the section title of “Frame Tree”). If prerender has started, you will see another FrameTree in the WebContents.

    • Determine whether prerender is running with Task Manager

      1. Open Task Manager, which can be found under three-dots menu > More Tools.
      2. Find the corresponding task to the tab where you will trigger prerendering.
      3. Attempt to trigger prerendering.
      4. If prerender has started, a new task starting with "Prerender: " will be displayed under that task.

    • Determine whether prerendered pages were activated: chrome://histograms/Prerender.Experimental.PrerenderHostFinalStatus covers the final status of all triggers, and the meaning of each enum item can be found in PrerenderFinalStatus.

Demo sites:

References

The date is the publication date, not the last updated date.

  • Prerender2 (Oct, 2020): Introduces how Prerender2 works and more detailed designs such as Mojo Capability Control.