Reland "Reland "Record split UMA histograms when rendering has been delayed for font preloading""

This reverts commit 033f06d6.

Reason for reland: there are new changes:

1. Fix how the loading behavior is observed. Now it's observed whenever
a font is preloaded.

2. The loading behavior flag is renamed.

Original change's description:
> Revert "Reland "Record split UMA histograms when rendering has been delayed for font preloading""
>
> This reverts commit 0e19fa7c.
>
> Reason for revert: should go through the normal review process
>
> Original change's description:
> > Reland "Record split UMA histograms when rendering has been delayed for font preloading"
> >
> > This reverts commit 950810de.
> >
> > Reason for revert: Loading behavior fixed
> >
> > Original change's description:
> > > Revert "Record split UMA histograms when rendering has been delayed for font preloading"
> > >
> > > This reverts commit 4a7fe529.
> > >
> > > Reason for revert: The loading behavior is designed wrong.
> > >
> > > The objective of these split histograms is to study, when there's font preloading, how effective delaying rendering is.
> > >
> > > Currently: the behavior is observed when rendering is delayed by font preloading.
> > >
> > > What's actually needed: the behavior is observed when font preloading occurs
> > >
> > > Original change's description:
> > > > Record split UMA histograms when rendering has been delayed for font preloading
> > > >
> > > > This patch adds split histograms of the following metrics when
> > > > rendering delay for web font preloading has been triggered:
> > > > - PaintTiming.NavigationToFirstPaint
> > > > - PaintTiming.NavigationToFirstContentfulPaint
> > > > - PaintTiming.NavigationToLargestContentfulPaint
> > > > - LayoutInstability.CumulativeShiftScore
> > > >
> > > > This will help us understand the effectiveness of this optimization, and
> > > > adjust the length of the delay to the best value.
> > > >
> > > > Bug: 1040632
> > > > Change-Id: I6f8aa151c576c9d8d583647a3a7ef6fcb8fb833d
> > > > Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2109251
> > > > Reviewed-by: Kunihiko Sakamoto <ksakamoto@chromium.org>
> > > > Reviewed-by: Charlie Harrison <csharrison@chromium.org>
> > > > Reviewed-by: Chris Harrelson <chrishtr@chromium.org>
> > > > Reviewed-by: Bryan McQuade <bmcquade@chromium.org>
> > > > Commit-Queue: Xiaocheng Hu <xiaochengh@chromium.org>
> > > > Cr-Commit-Position: refs/heads/master@{#754771}
> > >
> > > TBR=chrishtr@chromium.org,ksakamoto@chromium.org,skobes@chromium.org,bmcquade@chromium.org,csharrison@chromium.org,xiaochengh@chromium.org
> > >
> > > Change-Id: I7829822fea47183df9d4ed27c0eec2a1f888aa0b
> > > No-Presubmit: true
> > > No-Tree-Checks: true
> > > No-Try: true
> > > Bug: 1040632
> > > Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2131010
> > > Reviewed-by: Xiaocheng Hu <xiaochengh@chromium.org>
> > > Commit-Queue: Xiaocheng Hu <xiaochengh@chromium.org>
> > > Cr-Commit-Position: refs/heads/master@{#755081}
> >
> > TBR=chrishtr@chromium.org,ksakamoto@chromium.org,skobes@chromium.org,bmcquade@chromium.org,csharrison@chromium.org,xiaochengh@chromium.org
> >
> > Change-Id: Ibae7230089fe9e56e91cf1480d19c7bc70778567
> > No-Presubmit: true
> > No-Tree-Checks: true
> > No-Try: true
> > Bug: 1040632
> > Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2131011
> > Reviewed-by: Xiaocheng Hu <xiaochengh@chromium.org>
> > Cr-Commit-Position: refs/heads/master@{#755108}
>
> TBR=chrishtr@chromium.org,ksakamoto@chromium.org,skobes@chromium.org,bmcquade@chromium.org,csharrison@chromium.org,xiaochengh@chromium.org
>
> # Not skipping CQ checks because original CL landed > 1 day ago.
>
> Bug: 1040632
> Change-Id: I80ae98e1f0ec97a11f35bb2c55ad9d591f1b07b1
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2135047
> Commit-Queue: Xiaocheng Hu <xiaochengh@chromium.org>
> Reviewed-by: Xiaocheng Hu <xiaochengh@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#756098}

Bug: 1040632
Change-Id: I44b9ff37bf7cf75b0d4c9967cc183aa0609e4532
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2134887
Commit-Queue: Xiaocheng Hu <xiaochengh@chromium.org>
Reviewed-by: Chris Harrelson <chrishtr@chromium.org>
Reviewed-by: Steve Kobes <skobes@chromium.org>
Reviewed-by: Charlie Harrison <csharrison@chromium.org>
Cr-Commit-Position: refs/heads/master@{#756866}

chrome/browser/page_load_metrics/observers/ukm_page_load_metrics_observer.cc

@@ -583,6 +583,8 @@ void UkmPageLoadMetricsObserver::ReportLayoutStability() {
                                   .layout_shift_score_before_input_or_scroll))
       .Record(ukm::UkmRecorder::Get());
 
+  // TODO(crbug.com/1064483): We should move UMA recording to components/
+
   UMA_HISTOGRAM_COUNTS_100(
       "PageLoad.LayoutInstability.CumulativeShiftScore",
       LayoutShiftUmaValue(
@@ -592,6 +594,15 @@ void UkmPageLoadMetricsObserver::ReportLayoutStability() {
       "PageLoad.LayoutInstability.CumulativeShiftScore.MainFrame",
       LayoutShiftUmaValue(
           GetDelegate().GetMainFrameRenderData().layout_shift_score));
+
+  // Note: This depends on PageLoadMetrics internally processing loading
+  // behavior before timing metrics if they come in the same IPC update.
+  if (font_preload_started_before_rendering_observed_) {
+    UMA_HISTOGRAM_COUNTS_100(
+        "PageLoad.Clients.FontPreload.LayoutInstability.CumulativeShiftScore",
+        LayoutShiftUmaValue(
+            GetDelegate().GetPageRenderData().layout_shift_score));
+  }
 }
 
 void UkmPageLoadMetricsObserver::RecordInputTimingMetrics() {
@@ -756,3 +767,12 @@ void UkmPageLoadMetricsObserver::RecordGeneratedNavigationUKM(
   builder.SetFirstURLIsDefaultSearchEngine(start_url_is_default_search_);
   builder.Record(ukm::UkmRecorder::Get());
 }
+
+void UkmPageLoadMetricsObserver::OnLoadingBehaviorObserved(
+    content::RenderFrameHost* rfh,
+    int behavior_flag) {
+  if (behavior_flag & blink::LoadingBehaviorFlag::
+                          kLoadingBehaviorFontPreloadStartedBeforeRendering) {
+    font_preload_started_before_rendering_observed_ = true;
+  }
+}

chrome/browser/page_load_metrics/observers/ukm_page_load_metrics_observer.h

@@ -88,6 +88,9 @@ class UkmPageLoadMetricsObserver
       content::RenderFrameHost* subframe_rfh,
       const page_load_metrics::mojom::CpuTiming& timing) override;
 
+  void OnLoadingBehaviorObserved(content::RenderFrameHost* rfh,
+                                 int behavior_flags) override;
+
   // Whether the current page load is an Offline Preview. Must be called from
   // OnCommit. Virtual for testing.
   virtual bool IsOfflinePreview(content::WebContents* web_contents) const;
@@ -208,6 +211,8 @@ class UkmPageLoadMetricsObserver
   // Unique across the lifetime of the browser process.
   int main_document_sequence_number_ = -1;
 
+  bool font_preload_started_before_rendering_observed_ = false;
+
   // The connection info for the committed URL.
   base::Optional<net::HttpResponseInfo::ConnectionInfo> connection_info_;
 

chrome/browser/page_load_metrics/observers/ukm_page_load_metrics_observer_unittest.cc

@@ -1366,6 +1366,39 @@ TEST_F(UkmPageLoadMetricsObserverTest, LayoutInstability) {
   EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
                   "PageLoad.LayoutInstability.CumulativeShiftScore"),
               testing::ElementsAre(base::Bucket(25, 1)));
+
+  tester()->histogram_tester().ExpectTotalCount(
+      "PageLoad.Clients.FontPreload.LayoutInstability."
+      "CumulativeShiftScore",
+      0);
+}
+
+TEST_F(UkmPageLoadMetricsObserverTest,
+       UpdateAfterHide_RecordsLayoutInstabilityWithFontPreload) {
+  NavigateAndCommit(GURL(kTestUrl1));
+
+  page_load_metrics::mojom::FrameMetadata metadata;
+  metadata.behavior_flags |= blink::LoadingBehaviorFlag::
+      kLoadingBehaviorFontPreloadStartedBeforeRendering;
+  tester()->SimulateMetadataUpdate(metadata, web_contents()->GetMainFrame());
+
+  page_load_metrics::mojom::FrameRenderDataUpdate render_data(1.0, 1.0);
+  tester()->SimulateRenderDataUpdate(render_data);
+
+  // Simulate hiding the tab (the report should include shifts after hide).
+  web_contents()->WasHidden();
+
+  render_data.layout_shift_delta = 1.5;
+  render_data.layout_shift_delta_before_input_or_scroll = 0.0;
+  tester()->SimulateRenderDataUpdate(render_data);
+
+  // Simulate closing the tab.
+  DeleteContents();
+
+  EXPECT_THAT(tester()->histogram_tester().GetAllSamples(
+                  "PageLoad.Clients.FontPreload.LayoutInstability."
+                  "CumulativeShiftScore"),
+              testing::ElementsAre(base::Bucket(25, 1)));
 }
 
 TEST_F(UkmPageLoadMetricsObserverTest, MHTMLNotTracked) {

components/page_load_metrics/browser/observers/core_page_load_metrics_observer.cc

@@ -271,6 +271,14 @@ const char kBackgroundHistogramInputToFirstContentfulPaint[] =
 const char kHistogramBackForwardCacheEvent[] =
     "PageLoad.BackForwardCache.Event";
 
+const char kHistogramFontPreloadFirstPaint[] =
+    "PageLoad.Clients.FontPreload.PaintTiming.NavigationToFirstPaint";
+const char kHistogramFontPreloadFirstContentfulPaint[] =
+    "PageLoad.Clients.FontPreload.PaintTiming.NavigationToFirstContentfulPaint";
+const char kHistogramFontPreloadLargestContentfulPaint[] =
+    "PageLoad.Clients.FontPreload.PaintTiming."
+    "NavigationToLargestContentfulPaint";
+
 }  // namespace internal
 
 CorePageLoadMetricsObserver::CorePageLoadMetricsObserver()
@@ -344,6 +352,13 @@ void CorePageLoadMetricsObserver::OnFirstPaintInPage(
           timing.paint_timing->first_paint, GetDelegate())) {
     PAGE_LOAD_HISTOGRAM(internal::kHistogramFirstPaint,
                         timing.paint_timing->first_paint.value());
+
+    // Note: This depends on PageLoadMetrics internally processing loading
+    // behavior before timing metrics if they come in the same IPC update.
+    if (font_preload_started_before_rendering_observed_) {
+      PAGE_LOAD_HISTOGRAM(internal::kHistogramFontPreloadFirstPaint,
+                          timing.paint_timing->first_paint.value());
+    }
     if (timing.input_to_navigation_start) {
       PAGE_LOAD_HISTOGRAM(internal::kHistogramInputToFirstPaint,
                           timing.input_to_navigation_start.value() +
@@ -389,6 +404,13 @@ void CorePageLoadMetricsObserver::OnFirstContentfulPaintInPage(
                         timing.paint_timing->first_contentful_paint.value() -
                             timing.parse_timing->parse_start.value());
 
+    // Note: This depends on PageLoadMetrics internally processing loading
+    // behavior before timing metrics if they come in the same IPC update.
+    if (font_preload_started_before_rendering_observed_) {
+      PAGE_LOAD_HISTOGRAM(internal::kHistogramFontPreloadFirstContentfulPaint,
+                          timing.paint_timing->first_contentful_paint.value());
+    }
+
     // Emit a trace event to highlight a long navigation to first contentful
     // paint.
     if (timing.paint_timing->first_contentful_paint >
@@ -755,6 +777,13 @@ void CorePageLoadMetricsObserver::RecordTimingHistograms(
     UMA_HISTOGRAM_ENUMERATION(
         internal::kHistogramLargestContentfulPaintContentType,
         all_frames_largest_contentful_paint.Type());
+
+    // Note: This depends on PageLoadMetrics internally processing loading
+    // behavior before timing metrics if they come in the same IPC update.
+    if (font_preload_started_before_rendering_observed_) {
+      PAGE_LOAD_HISTOGRAM(internal::kHistogramFontPreloadLargestContentfulPaint,
+                          all_frames_largest_contentful_paint.Time().value());
+    }
   }
 
   if (main_frame_timing.paint_timing->first_paint &&
@@ -920,3 +949,12 @@ CorePageLoadMetricsObserver::OnEnterBackForwardCache(
       internal::PageLoadBackForwardCacheEvent::kEnterBackForwardCache);
   return PageLoadMetricsObserver::OnEnterBackForwardCache(timing);
 }
+
+void CorePageLoadMetricsObserver::OnLoadingBehaviorObserved(
+    content::RenderFrameHost* rfh,
+    int behavior_flag) {
+  if (behavior_flag & blink::LoadingBehaviorFlag::
+                          kLoadingBehaviorFontPreloadStartedBeforeRendering) {
+    font_preload_started_before_rendering_observed_ = true;
+  }
+}

components/page_load_metrics/browser/observers/core_page_load_metrics_observer.h

@@ -99,6 +99,13 @@ extern const char kHistogramInputToFirstContentfulPaint[];
 extern const char kBackgroundHistogramInputToFirstContentfulPaint[];
 extern const char kHistogramBackForwardCacheEvent[];
 
+// Split histograms recorded only when the first rendering cycle has been
+// delayed for web font preloading.
+// See design doc https://bit.ly/36E8UKB for details.
+extern const char kHistogramFontPreloadFirstPaint[];
+extern const char kHistogramFontPreloadFirstContentfulPaint[];
+extern const char kHistogramFontPreloadLargestContentfulPaint[];
+
 enum FirstMeaningfulPaintStatus {
   FIRST_MEANINGFUL_PAINT_RECORDED,
   FIRST_MEANINGFUL_PAINT_BACKGROUNDED,
@@ -174,6 +181,8 @@ class CorePageLoadMetricsObserver
       content::NavigationHandle* navigation_handle) override;
   ObservePolicy OnEnterBackForwardCache(
       const page_load_metrics::mojom::PageLoadTiming& timing) override;
+  void OnLoadingBehaviorObserved(content::RenderFrameHost* rfh,
+                                 int behavior_flags) override;
 
  private:
   void RecordTimingHistograms(
@@ -215,6 +224,10 @@ class CorePageLoadMetricsObserver
   // True if we've received a scroll input after first paint has happened.
   bool received_scroll_input_after_first_paint_ = false;
 
+  // True if the first rendering cycle has been delayed due to web font
+  // preloading.
+  bool font_preload_started_before_rendering_observed_ = false;
+
   base::TimeTicks first_paint_;
 
   page_load_metrics::LargestContentfulPaintHandler

components/page_load_metrics/browser/observers/core_page_load_metrics_observer_unittest.cc

@@ -1392,3 +1392,119 @@ TEST_F(CorePageLoadMetricsObserverTest, UnfinishedBytesRecorded) {
   tester()->histogram_tester().ExpectUniqueSample(
       internal::kHistogramPageLoadUnfinishedBytes, 10, 1);
 }
+
+// PageLoad.Clients.FontPreload.* shouldn't be recorded when the behavior is not
+// observed.
+TEST_F(CorePageLoadMetricsObserverTest, FontPreloadHistogramsNotObserved) {
+  page_load_metrics::mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  timing.parse_timing->parse_start = base::TimeDelta::FromMilliseconds(1);
+  timing.parse_timing->parse_stop = base::TimeDelta::FromMilliseconds(100);
+  timing.paint_timing->first_paint = base::TimeDelta::FromMilliseconds(150);
+  timing.paint_timing->first_contentful_paint =
+      base::TimeDelta::FromMilliseconds(200);
+  timing.paint_timing->largest_text_paint =
+      base::TimeDelta::FromMilliseconds(250);
+  timing.paint_timing->largest_text_paint_size = 100u;
+  timing.paint_timing->largest_image_paint =
+      base::TimeDelta::FromMilliseconds(250);
+  timing.paint_timing->largest_image_paint_size = 100u;
+  PopulateRequiredTimingFields(&timing);
+
+  NavigateAndCommit(GURL("https://www.google.com/"));
+  tester()->SimulateTimingUpdate(timing);
+
+  // Simulate closing the tab.
+  DeleteContents();
+
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadFirstPaint, 0);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadFirstContentfulPaint, 0);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadLargestContentfulPaint, 0);
+}
+
+// PageLoad.Clients.FontPreload.* should be recorded when the behavior is
+// observed.
+TEST_F(CorePageLoadMetricsObserverTest, FontPreloadHistogramsObserved) {
+  page_load_metrics::mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  timing.parse_timing->parse_start = base::TimeDelta::FromMilliseconds(1);
+  timing.parse_timing->parse_stop = base::TimeDelta::FromMilliseconds(100);
+  timing.paint_timing->first_paint = base::TimeDelta::FromMilliseconds(150);
+  timing.paint_timing->first_contentful_paint =
+      base::TimeDelta::FromMilliseconds(200);
+  timing.paint_timing->largest_text_paint =
+      base::TimeDelta::FromMilliseconds(250);
+  timing.paint_timing->largest_text_paint_size = 100u;
+  timing.paint_timing->largest_image_paint =
+      base::TimeDelta::FromMilliseconds(250);
+  timing.paint_timing->largest_image_paint_size = 100u;
+  PopulateRequiredTimingFields(&timing);
+
+  // Note: PageLoadMetrics internally processes loading behavior before timing
+  // metrics if they come in the same IPC update.
+  page_load_metrics::mojom::FrameMetadata metadata;
+  metadata.behavior_flags |= blink::LoadingBehaviorFlag::
+      kLoadingBehaviorFontPreloadStartedBeforeRendering;
+  NavigateAndCommit(GURL("https://www.google.com/"));
+  tester()->SimulateTimingAndMetadataUpdate(timing, metadata);
+
+  // Similate closing the tab.
+  DeleteContents();
+
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadFirstPaint, 1);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadFirstContentfulPaint, 1);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadLargestContentfulPaint, 1);
+}
+
+// PageLoad.Clients.FontPreload.* depends on the order that, we need to first
+// observe the load behavior and then observe the paint timings. This should
+// have been guaranteed by the renderer. However, If the ordering is wrong, we
+// can't observe the histograms correctly.
+TEST_F(CorePageLoadMetricsObserverTest,
+       FontPreloadHistogramsNotObservedOnWrongDispatchOrder) {
+  page_load_metrics::mojom::PageLoadTiming timing;
+  page_load_metrics::InitPageLoadTimingForTest(&timing);
+  timing.navigation_start = base::Time::FromDoubleT(1);
+  timing.parse_timing->parse_start = base::TimeDelta::FromMilliseconds(1);
+  timing.parse_timing->parse_stop = base::TimeDelta::FromMilliseconds(100);
+  timing.paint_timing->first_paint = base::TimeDelta::FromMilliseconds(150);
+  timing.paint_timing->first_contentful_paint =
+      base::TimeDelta::FromMilliseconds(200);
+  timing.paint_timing->largest_text_paint =
+      base::TimeDelta::FromMilliseconds(250);
+  timing.paint_timing->largest_text_paint_size = 100u;
+  timing.paint_timing->largest_image_paint =
+      base::TimeDelta::FromMilliseconds(250);
+  timing.paint_timing->largest_image_paint_size = 100u;
+  PopulateRequiredTimingFields(&timing);
+
+  // Note: PageLoadMetrics internally processes loading behavior before timing
+  // metrics if they come in the same IPC update.
+  page_load_metrics::mojom::FrameMetadata metadata;
+  metadata.behavior_flags |= blink::LoadingBehaviorFlag::
+      kLoadingBehaviorFontPreloadStartedBeforeRendering;
+
+  NavigateAndCommit(GURL("https://www.google.com/"));
+  tester()->SimulateTimingUpdate(timing);
+  tester()->SimulateMetadataUpdate(metadata, main_rfh());
+
+  // Similate closing the tab.
+  DeleteContents();
+
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadFirstPaint, 0);
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadFirstContentfulPaint, 0);
+
+  // LCP is recorded on page complete/closing, so it can still be observed.
+  tester()->histogram_tester().ExpectTotalCount(
+      internal::kHistogramFontPreloadLargestContentfulPaint, 1);
+}

third_party/blink/public/common/loader/loading_behavior_flag.h

@@ -37,6 +37,10 @@ enum LoadingBehaviorFlag {
   kLoadingBehaviorSubresourceFilterMatch = 1 << 6,
   // Indicates that the page is an AMP document, with <html amp> tag.
   kLoadingBehaviorAmpDocumentLoaded = 1 << 7,
+  // Indicates that font preloading (via <link rel=preload> or Font JS API) has
+  // occurred before the first rendering cycle begins. Used to study the
+  // effects of delaying the first rendering cycle for web font loading.
+  kLoadingBehaviorFontPreloadStartedBeforeRendering = 1 << 8,
 };
 
 }  // namespace blink

third_party/blink/renderer/core/loader/font_preload_manager.cc

@@ -6,8 +6,10 @@
 
 #include "build/build_config.h"
 #include "third_party/blink/public/common/features.h"
+#include "third_party/blink/public/common/loader/loading_behavior_flag.h"
 #include "third_party/blink/renderer/core/css/font_face.h"
 #include "third_party/blink/renderer/core/dom/document.h"
+#include "third_party/blink/renderer/core/loader/document_loader.h"
 #include "third_party/blink/renderer/core/loader/resource/font_resource.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_finish_observer.h"
 
@@ -83,9 +85,6 @@ bool FontPreloadManager::HasPendingRenderBlockingFonts() const {
 }
 
 void FontPreloadManager::FontPreloadingStarted(FontResource* font_resource) {
-  if (!base::FeatureList::IsEnabled(features::kFontPreloadingDelaysRendering))
-    return;
-
   // The font is either already in the memory cache, or has errored out. In
   // either case, we don't any further processing.
   if (font_resource->IsLoaded())
@@ -94,6 +93,12 @@ void FontPreloadManager::FontPreloadingStarted(FontResource* font_resource) {
   if (state_ == State::kUnblocked)
     return;
 
+  document_->Loader()->DidObserveLoadingBehavior(
+      kLoadingBehaviorFontPreloadStartedBeforeRendering);
+
+  if (!base::FeatureList::IsEnabled(features::kFontPreloadingDelaysRendering))
+    return;
+
   FontPreloadFinishObserver* observer =
       MakeGarbageCollected<FontPreloadFinishObserver>(*font_resource,
                                                       *document_);
@@ -105,15 +110,18 @@ void FontPreloadManager::FontPreloadingStarted(FontResource* font_resource) {
 }
 
 void FontPreloadManager::ImperativeFontLoadingStarted(FontFace* font_face) {
-  if (!base::FeatureList::IsEnabled(features::kFontPreloadingDelaysRendering))
-    return;
-
   if (font_face->LoadStatus() != FontFace::kLoading)
     return;
 
   if (state_ == State::kUnblocked)
     return;
 
+  document_->Loader()->DidObserveLoadingBehavior(
+      kLoadingBehaviorFontPreloadStartedBeforeRendering);
+
+  if (!base::FeatureList::IsEnabled(features::kFontPreloadingDelaysRendering))
+    return;
+
   ImperativeFontLoadFinishedCallback* callback =
       MakeGarbageCollected<ImperativeFontLoadFinishedCallback>(*document_);
   font_face->AddCallback(callback);
@@ -170,8 +178,6 @@ void FontPreloadManager::RenderBlockingFontLoadingFinished() {
 }
 
 void FontPreloadManager::WillBeginRendering() {
-  if (!base::FeatureList::IsEnabled(features::kFontPreloadingDelaysRendering))
-    return;
   if (state_ == State::kUnblocked)
     return;
 

third_party/blink/renderer/core/loader/font_preload_manager_test.cc

@@ -483,4 +483,103 @@ TEST_F(FontPreloadManagerTest, OptionalFontFastImperativeLoad) {
   EXPECT_FALSE(GetTargetFont().ShouldSkipDrawing());
 }
 
+class FontPreloadBehaviorObservationTest
+    : public testing::WithParamInterface<bool>,
+      public SimTest {
+ public:
+  class LoadingBehaviorObserver
+      : public frame_test_helpers::TestWebFrameClient {
+   public:
+    void DidObserveLoadingBehavior(LoadingBehaviorFlag flag) override {
+      observed_behaviors_ =
+          static_cast<LoadingBehaviorFlag>(observed_behaviors_ | flag);
+    }
+
+    LoadingBehaviorFlag ObservedBehaviors() const {
+      return observed_behaviors_;
+    }
+
+   private:
+    LoadingBehaviorFlag observed_behaviors_ = kLoadingBehaviorNone;
+  };
+
+  void SetUp() override {
+    SimTest::SetUp();
+    original_web_local_frame_client_ = MainFrame().Client();
+    MainFrame().SetClient(&loading_behavior_observer_);
+  }
+
+  void TearDown() override {
+    MainFrame().SetClient(original_web_local_frame_client_);
+    SimTest::TearDown();
+  }
+
+  LoadingBehaviorFlag ObservedBehaviors() const {
+    return loading_behavior_observer_.ObservedBehaviors();
+  }
+
+ private:
+  WebLocalFrameClient* original_web_local_frame_client_;
+  LoadingBehaviorObserver loading_behavior_observer_;
+};
+
+INSTANTIATE_TEST_SUITE_P(All,
+                         FontPreloadBehaviorObservationTest,
+                         testing::Bool());
+
+TEST_P(FontPreloadBehaviorObservationTest, ObserveBehaviorWithLinkPreload) {
+  // kLoadingBehaviorFontPreloadStartedBeforeRendering should be observed as
+  // long as there's font preloading, regardless of the enabled status of the
+  // feature FontPreloadingDelaysRendering.
+  base::test::ScopedFeatureList scoped_feature_list;
+  if (GetParam()) {
+    scoped_feature_list.InitAndEnableFeature(
+        features::kFontPreloadingDelaysRendering);
+  }
+
+  SimRequest main_resource("https://example.com", "text/html");
+  SimRequest font_resource("https://example.com/font.woff", "font/woff2");
+
+  LoadURL("https://example.com");
+  main_resource.Complete(R"HTML(
+    <!doctype html>
+    <link rel="preload" as="font" type="font/woff2"
+          href="https://example.com/font.woff" crossorigin>
+  )HTML");
+
+  EXPECT_TRUE(ObservedBehaviors() |
+              kLoadingBehaviorFontPreloadStartedBeforeRendering);
+
+  font_resource.Finish();
+  test::RunPendingTasks();
+}
+
+TEST_P(FontPreloadBehaviorObservationTest, ObserveBehaviorWithImperativeLoad) {
+  // kLoadingBehaviorFontPreloadStartedBeforeRendering should be observed as
+  // long as there's an imperative font load, regardless of the enabled status
+  // of the feature FontPreloadingDelaysRendering.
+  base::test::ScopedFeatureList scoped_feature_list;
+  if (GetParam()) {
+    scoped_feature_list.InitAndEnableFeature(
+        features::kFontPreloadingDelaysRendering);
+  }
+
+  SimRequest main_resource("https://example.com", "text/html");
+  SimRequest font_resource("https://example.com/font.woff", "font/woff2");
+
+  LoadURL("https://example.com");
+  main_resource.Complete(R"HTML(
+    <!doctype html>
+    <script>
+    new FontFace('custom-font', 'url(https://example.com/font.woff)').load();
+    </script>
+  )HTML");
+
+  EXPECT_TRUE(ObservedBehaviors() |
+              kLoadingBehaviorFontPreloadStartedBeforeRendering);
+
+  font_resource.Finish();
+  test::RunPendingTasks();
+}
+
 }  // namespace blink