Add UKM metric tracking for various page load metric observers.

Bug: 739389, 739384
Change-Id: I8637ce1ad693f566f738058e7fef07d025109d72
Reviewed-on: https://chromium-review.googlesource.com/563884
Commit-Queue: Bryan McQuade <bmcquade@chromium.org>
Reviewed-by: Robert Kaplow <rkaplow@chromium.org>
Reviewed-by: Charlie Harrison <csharrison@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#486616}

chrome/browser/page_load_metrics/observers/document_write_page_load_metrics_observer.cc

@@ -3,7 +3,9 @@
 // found in the LICENSE file.
 
 #include "chrome/browser/page_load_metrics/observers/document_write_page_load_metrics_observer.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
+#include "services/metrics/public/cpp/ukm_recorder.h"
 #include "third_party/WebKit/public/platform/WebLoadingBehaviorFlag.h"
 
 namespace internal {
@@ -74,6 +76,13 @@ const char kHistogramDocWriteBlockReloadCount[] =
 const char kHistogramDocWriteBlockLoadingBehavior[] =
     "PageLoad.Clients.DocWrite.Block.DocumentWriteLoadingBehavior";
 
+const char kUkmDocWriteBlockName[] = "Intervention.DocumentWrite.ScriptBlock";
+const char kUkmDocWriteBlockReload[] = "Disabled.Reload";
+const char kUkmParseBlockedOnScriptLoadDocumentWrite[] =
+    "ParseTiming.ParseBlockedOnScriptLoadFromDocumentWrite";
+const char kUkmParseBlockedOnScriptExecutionDocumentWrite[] =
+    "ParseTiming.ParseBlockedOnScriptExecutionFromDocumentWrite";
+
 }  // namespace internal
 
 void DocumentWritePageLoadMetricsObserver::OnFirstContentfulPaintInPage(
@@ -119,11 +128,28 @@ void DocumentWritePageLoadMetricsObserver::OnParseStop(
   }
 }
 
-void LogLoadingBehaviorMetrics(
- DocumentWritePageLoadMetricsObserver::DocumentWriteLoadingBehavior behavior) {
-  UMA_HISTOGRAM_ENUMERATION(internal::kHistogramDocWriteBlockLoadingBehavior,
-                            behavior,
-                  DocumentWritePageLoadMetricsObserver::LOADING_BEHAVIOR_MAX);
+// static
+void DocumentWritePageLoadMetricsObserver::LogLoadingBehaviorMetrics(
+    DocumentWritePageLoadMetricsObserver::DocumentWriteLoadingBehavior behavior,
+    ukm::SourceId source_id) {
+  UMA_HISTOGRAM_ENUMERATION(
+      internal::kHistogramDocWriteBlockLoadingBehavior, behavior,
+      DocumentWritePageLoadMetricsObserver::LOADING_BEHAVIOR_MAX);
+
+  // We only log the block and reload behaviors in UKM.
+  if (behavior != LOADING_BEHAVIOR_BLOCK &&
+      behavior != LOADING_BEHAVIOR_RELOAD) {
+    return;
+  }
+  ukm::UkmRecorder* ukm_recorder = g_browser_process->ukm_recorder();
+  if (ukm_recorder) {
+    std::unique_ptr<ukm::UkmEntryBuilder> builder =
+        ukm_recorder->GetEntryBuilder(source_id,
+                                      internal::kUkmDocWriteBlockName);
+    if (behavior == LOADING_BEHAVIOR_RELOAD) {
+      builder->AddMetric(internal::kUkmDocWriteBlockReload, true);
+    }
+  }
 }
 
 void DocumentWritePageLoadMetricsObserver::OnLoadingBehaviorObserved(
@@ -136,21 +162,22 @@ void DocumentWritePageLoadMetricsObserver::OnLoadingBehaviorObserved(
         info.main_frame_metadata.behavior_flags &
         blink::WebLoadingBehaviorFlag::kWebLoadingBehaviorDocumentWriteBlock));
     UMA_HISTOGRAM_COUNTS(internal::kHistogramDocWriteBlockReloadCount, 1);
-    LogLoadingBehaviorMetrics(LOADING_BEHAVIOR_RELOAD);
+    LogLoadingBehaviorMetrics(LOADING_BEHAVIOR_RELOAD, info.source_id);
     doc_write_block_reload_observed_ = true;
   }
   if ((info.main_frame_metadata.behavior_flags &
        blink::WebLoadingBehaviorFlag::kWebLoadingBehaviorDocumentWriteBlock) &&
       !doc_write_block_observed_) {
     UMA_HISTOGRAM_BOOLEAN(internal::kHistogramDocWriteBlockCount, true);
-    LogLoadingBehaviorMetrics(LOADING_BEHAVIOR_BLOCK);
+    LogLoadingBehaviorMetrics(LOADING_BEHAVIOR_BLOCK, info.source_id);
     doc_write_block_observed_ = true;
   }
   if ((info.main_frame_metadata.behavior_flags &
        blink::WebLoadingBehaviorFlag::
            kWebLoadingBehaviorDocumentWriteBlockDifferentScheme) &&
       !doc_write_same_site_diff_scheme_) {
-    LogLoadingBehaviorMetrics(LOADING_BEHAVIOR_SAME_SITE_DIFF_SCHEME);
+    LogLoadingBehaviorMetrics(LOADING_BEHAVIOR_SAME_SITE_DIFF_SCHEME,
+                              info.source_id);
     doc_write_same_site_diff_scheme_ = true;
   }
 }
@@ -291,6 +318,24 @@ void DocumentWritePageLoadMetricsObserver::LogDocumentWriteBlockParseStop(
         timing.parse_timing
             ->parse_blocked_on_script_execution_from_document_write_duration
             .value());
+
+    ukm::UkmRecorder* ukm_recorder = g_browser_process->ukm_recorder();
+    if (ukm_recorder) {
+      std::unique_ptr<ukm::UkmEntryBuilder> builder =
+          ukm_recorder->GetEntryBuilder(info.source_id,
+                                        internal::kUkmDocWriteBlockName);
+      builder->AddMetric(
+          internal::kUkmParseBlockedOnScriptLoadDocumentWrite,
+          timing.parse_timing
+              ->parse_blocked_on_script_load_from_document_write_duration
+              ->InMilliseconds());
+      builder->AddMetric(
+          internal::kUkmParseBlockedOnScriptExecutionDocumentWrite,
+          timing.parse_timing
+              ->parse_blocked_on_script_execution_from_document_write_duration
+              ->InMilliseconds());
+    }
+
   } else {
     PAGE_LOAD_HISTOGRAM(
         internal::kBackgroundHistogramDocWriteBlockParseDuration,

chrome/browser/page_load_metrics/observers/document_write_page_load_metrics_observer.h

@@ -16,6 +16,11 @@ extern const char kHistogramDocWriteBlockParseStartToFirstContentfulPaint[];
 extern const char kHistogramDocWriteBlockCount[];
 extern const char kHistogramDocWriteBlockReloadCount[];
 
+extern const char kUkmDocWriteBlockName[];
+extern const char kUkmDocWriteBlockReload[];
+extern const char kUkmParseBlockedOnScriptLoadDocumentWrite[];
+extern const char kUkmParseBlockedOnScriptExecutionDocumentWrite[];
+
 }  // namespace internal
 
 class DocumentWritePageLoadMetricsObserver
@@ -47,6 +52,9 @@ class DocumentWritePageLoadMetricsObserver
   };
 
  private:
+  static void LogLoadingBehaviorMetrics(DocumentWriteLoadingBehavior behavior,
+                                        ukm::SourceId source_id);
+
   void LogDocumentWriteEvaluatorFirstContentfulPaint(
       const page_load_metrics::mojom::PageLoadTiming& timing,
       const page_load_metrics::PageLoadExtraInfo& info);

chrome/browser/page_load_metrics/observers/document_write_page_load_metrics_observer_unittest.cc

@@ -30,6 +30,7 @@ class DocumentWritePageLoadMetricsObserverTest
 TEST_F(DocumentWritePageLoadMetricsObserverTest, NoMetrics) {
   AssertNoPreloadHistogramsLogged();
   AssertNoBlockHistogramsLogged();
+  EXPECT_EQ(0ul, test_ukm_recorder().entries_count());
 }
 
 TEST_F(DocumentWritePageLoadMetricsObserverTest, PossiblePreload) {
@@ -44,7 +45,7 @@ TEST_F(DocumentWritePageLoadMetricsObserverTest, PossiblePreload) {
   page_load_metrics::mojom::PageLoadMetadata metadata;
   metadata.behavior_flags |=
       blink::WebLoadingBehaviorFlag::kWebLoadingBehaviorDocumentWriteEvaluator;
-  NavigateAndCommit(GURL("https://www.google.com"));
+  NavigateAndCommit(GURL("https://www.google.com/"));
   SimulateTimingAndMetadataUpdate(timing, metadata);
 
   histogram_tester().ExpectTotalCount(
@@ -53,7 +54,7 @@ TEST_F(DocumentWritePageLoadMetricsObserverTest, PossiblePreload) {
       internal::kHistogramDocWriteParseStartToFirstContentfulPaint,
       contentful_paint.InMilliseconds(), 1);
 
-  NavigateAndCommit(GURL("https://www.example.com"));
+  NavigateAndCommit(GURL("https://www.example.com/"));
 
   histogram_tester().ExpectTotalCount(
       internal::kHistogramDocWriteParseStartToFirstContentfulPaint, 1);
@@ -71,9 +72,9 @@ TEST_F(DocumentWritePageLoadMetricsObserverTest, NoPossiblePreload) {
   PopulateRequiredTimingFields(&timing);
 
   page_load_metrics::mojom::PageLoadMetadata metadata;
-  NavigateAndCommit(GURL("https://www.google.com"));
+  NavigateAndCommit(GURL("https://www.google.com/"));
   SimulateTimingAndMetadataUpdate(timing, metadata);
-  NavigateAndCommit(GURL("https://www.example.com"));
+  NavigateAndCommit(GURL("https://www.example.com/"));
   AssertNoPreloadHistogramsLogged();
 }
 
@@ -84,12 +85,23 @@ TEST_F(DocumentWritePageLoadMetricsObserverTest, PossibleBlock) {
   timing.navigation_start = base::Time::FromDoubleT(1);
   timing.paint_timing->first_contentful_paint = contentful_paint;
   timing.parse_timing->parse_start = base::TimeDelta::FromMilliseconds(1);
+  timing.parse_timing->parse_stop = base::TimeDelta::FromMilliseconds(100);
+  timing.parse_timing->parse_blocked_on_script_load_duration =
+      base::TimeDelta::FromMilliseconds(5);
+  timing.parse_timing
+      ->parse_blocked_on_script_load_from_document_write_duration =
+      base::TimeDelta::FromMilliseconds(5);
+  timing.parse_timing->parse_blocked_on_script_execution_duration =
+      base::TimeDelta::FromMilliseconds(3);
+  timing.parse_timing
+      ->parse_blocked_on_script_execution_from_document_write_duration =
+      base::TimeDelta::FromMilliseconds(3);
   PopulateRequiredTimingFields(&timing);
 
   page_load_metrics::mojom::PageLoadMetadata metadata;
   metadata.behavior_flags |=
       blink::WebLoadingBehaviorFlag::kWebLoadingBehaviorDocumentWriteBlock;
-  NavigateAndCommit(GURL("https://www.google.com"));
+  NavigateAndCommit(GURL("https://www.google.com/"));
   SimulateTimingAndMetadataUpdate(timing, metadata);
 
   histogram_tester().ExpectTotalCount(internal::kHistogramDocWriteBlockCount,
@@ -100,7 +112,18 @@ TEST_F(DocumentWritePageLoadMetricsObserverTest, PossibleBlock) {
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint,
       contentful_paint.InMilliseconds(), 1);
 
-  NavigateAndCommit(GURL("https://www.example.com"));
+  const ukm::UkmSource* source =
+      test_ukm_recorder().GetSourceForUrl("https://www.google.com/");
+  EXPECT_TRUE(
+      test_ukm_recorder().HasEntry(*source, internal::kUkmDocWriteBlockName));
+  test_ukm_recorder().ExpectMetric(
+      *source, internal::kUkmDocWriteBlockName,
+      internal::kUkmParseBlockedOnScriptLoadDocumentWrite, 5);
+  test_ukm_recorder().ExpectMetric(
+      *source, internal::kUkmDocWriteBlockName,
+      internal::kUkmParseBlockedOnScriptExecutionDocumentWrite, 3);
+
+  NavigateAndCommit(GURL("https://www.example.com/"));
 
   histogram_tester().ExpectTotalCount(
       internal::kHistogramDocWriteBlockParseStartToFirstContentfulPaint, 1);
@@ -121,19 +144,27 @@ TEST_F(DocumentWritePageLoadMetricsObserverTest, PossibleBlockReload) {
   page_load_metrics::mojom::PageLoadMetadata metadata;
   metadata.behavior_flags |= blink::WebLoadingBehaviorFlag::
       kWebLoadingBehaviorDocumentWriteBlockReload;
-  NavigateAndCommit(GURL("https://www.google.com"));
+  NavigateAndCommit(GURL("https://www.google.com/"));
   SimulateTimingAndMetadataUpdate(timing, metadata);
 
   histogram_tester().ExpectTotalCount(
       internal::kHistogramDocWriteBlockReloadCount, 1);
 
+  test_ukm_recorder().ExpectMetric(
+      *test_ukm_recorder().GetSourceForUrl("https://www.google.com/"),
+      internal::kUkmDocWriteBlockName, internal::kUkmDocWriteBlockReload, true);
+
   // Another reload.
-  NavigateAndCommit(GURL("https://www.example.com"));
+  NavigateAndCommit(GURL("https://www.example.com/"));
   SimulateTimingAndMetadataUpdate(timing, metadata);
 
   histogram_tester().ExpectTotalCount(
       internal::kHistogramDocWriteBlockReloadCount, 2);
 
+  test_ukm_recorder().ExpectMetric(
+      *test_ukm_recorder().GetSourceForUrl("https://www.example.com/"),
+      internal::kUkmDocWriteBlockName, internal::kUkmDocWriteBlockReload, true);
+
   // Another metadata update should not increase reload count.
   metadata.behavior_flags |=
       blink::WebLoadingBehaviorFlag::kWebLoadingBehaviorServiceWorkerControlled;
@@ -143,6 +174,8 @@ TEST_F(DocumentWritePageLoadMetricsObserverTest, PossibleBlockReload) {
 
   histogram_tester().ExpectTotalCount(internal::kHistogramDocWriteBlockCount,
                                       0);
+
+  EXPECT_EQ(2ul, test_ukm_recorder().entries_count());
 }
 
 TEST_F(DocumentWritePageLoadMetricsObserverTest, NoPossibleBlock) {
@@ -154,9 +187,9 @@ TEST_F(DocumentWritePageLoadMetricsObserverTest, NoPossibleBlock) {
   PopulateRequiredTimingFields(&timing);
 
   page_load_metrics::mojom::PageLoadMetadata metadata;
-  NavigateAndCommit(GURL("https://www.google.com"));
+  NavigateAndCommit(GURL("https://www.google.com/"));
   SimulateTimingAndMetadataUpdate(timing, metadata);
 
-  NavigateAndCommit(GURL("https://www.example.com"));
+  NavigateAndCommit(GURL("https://www.example.com/"));
   AssertNoBlockHistogramsLogged();
 }

chrome/browser/page_load_metrics/observers/from_gws_page_load_metrics_observer.cc

@@ -7,8 +7,10 @@
 
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
 #include "chrome/common/page_load_metrics/page_load_timing.h"
+#include "services/metrics/public/cpp/ukm_recorder.h"
 
 using page_load_metrics::PageAbortReason;
 
@@ -109,6 +111,8 @@ const char kHistogramFromGWSForegroundDurationWithoutPaint[] =
 const char kHistogramFromGWSForegroundDurationNoCommit[] =
     "PageLoad.Clients.FromGoogleSearch.PageTiming.ForegroundDuration.NoCommit";
 
+const char kUkmFromGoogleSearchName[] = "PageLoad.FromGoogleSearch";
+
 }  // namespace internal
 
 namespace {
@@ -359,6 +363,7 @@ FromGWSPageLoadMetricsObserver::OnCommit(
           navigation_handle->GetPageTransition()));
 
   logger_.SetNavigationStart(navigation_handle->NavigationStart());
+  logger_.OnCommit(navigation_handle, source_id);
   return CONTINUE_OBSERVING;
 }
 
@@ -435,6 +440,18 @@ void FromGWSPageLoadMetricsObserver::OnUserInput(
   logger_.OnUserInput(event);
 }
 
+void FromGWSPageLoadMetricsLogger::OnCommit(
+    content::NavigationHandle* navigation_handle,
+    ukm::SourceId source_id) {
+  if (!ShouldLogPostCommitMetrics(navigation_handle->GetURL()))
+    return;
+  ukm::UkmRecorder* ukm_recorder = g_browser_process->ukm_recorder();
+  if (ukm_recorder) {
+    ukm_recorder->GetEntryBuilder(source_id,
+                                  internal::kUkmFromGoogleSearchName);
+  }
+}
+
 void FromGWSPageLoadMetricsLogger::OnComplete(
     const page_load_metrics::mojom::PageLoadTiming& timing,
     const page_load_metrics::PageLoadExtraInfo& extra_info) {

chrome/browser/page_load_metrics/observers/from_gws_page_load_metrics_observer.h

@@ -36,6 +36,8 @@ extern const char kHistogramFromGWSForegroundDuration[];
 extern const char kHistogramFromGWSForegroundDurationAfterPaint[];
 extern const char kHistogramFromGWSForegroundDurationNoCommit[];
 
+extern const char kUkmFromGoogleSearchName[];
+
 }  // namespace internal
 
 // FromGWSPageLoadMetricsLogger is a peer class to
@@ -63,6 +65,8 @@ class FromGWSPageLoadMetricsLogger {
   }
 
   // Invoked when metrics for the given page are complete.
+  void OnCommit(content::NavigationHandle* navigation_handle,
+                ukm::SourceId source_id);
   void OnComplete(const page_load_metrics::mojom::PageLoadTiming& timing,
                   const page_load_metrics::PageLoadExtraInfo& extra_info);
   void OnFailedProvisionalLoad(

chrome/browser/page_load_metrics/observers/service_worker_page_load_metrics_observer.cc

@@ -4,9 +4,11 @@
 
 #include "chrome/browser/page_load_metrics/observers/service_worker_page_load_metrics_observer.h"
 
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/page_load_metrics/observers/from_gws_page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
 #include "net/http/http_response_headers.h"
+#include "services/metrics/public/cpp/ukm_recorder.h"
 #include "third_party/WebKit/public/platform/WebLoadingBehaviorFlag.h"
 
 namespace internal {
@@ -110,6 +112,10 @@ const char kHistogramNoServiceWorkerLoadSearch[] =
     "PageLoad.Clients.NoServiceWorker.DocumentTiming."
     "NavigationToLoadEventFired.search";
 
+// UKM (URL-keyed metrics) entry identifier, recorded for pages (main frame
+// loads) controlled by a service worker.
+const char kUkmServiceWorkerName[] = "PageLoad.ServiceWorkerControlled";
+
 }  // namespace internal
 
 namespace {
@@ -343,3 +349,15 @@ void ServiceWorkerPageLoadMetricsObserver::OnParseStart(
                         timing.parse_timing->parse_start.value());
   }
 }
+
+void ServiceWorkerPageLoadMetricsObserver::OnLoadingBehaviorObserved(
+    const page_load_metrics::PageLoadExtraInfo& info) {
+  if (!IsServiceWorkerControlled(info) || logged_ukm_event_)
+    return;
+  ukm::UkmRecorder* ukm_recorder = g_browser_process->ukm_recorder();
+  if (ukm_recorder) {
+    ukm_recorder->GetEntryBuilder(info.source_id,
+                                  internal::kUkmServiceWorkerName);
+    logged_ukm_event_ = true;
+  }
+}

chrome/browser/page_load_metrics/observers/service_worker_page_load_metrics_observer.h

@@ -46,6 +46,7 @@ extern const char
     kHistogramServiceWorkerParseStartToFirstContentfulPaintSearch[];
 extern const char kHistogramServiceWorkerDomContentLoadedSearch[];
 extern const char kHistogramServiceWorkerLoadSearch[];
+extern const char kUkmServiceWorkerName[];
 
 extern const char kHistogramNoServiceWorkerFirstContentfulPaintSearch[];
 extern const char kHistogramNoServiceWorkerFirstMeaningfulPaintSearch[];
@@ -80,10 +81,13 @@ class ServiceWorkerPageLoadMetricsObserver
   void OnLoadEventStart(
       const page_load_metrics::mojom::PageLoadTiming& timing,
       const page_load_metrics::PageLoadExtraInfo& extra_info) override;
+  void OnLoadingBehaviorObserved(
+      const page_load_metrics::PageLoadExtraInfo& extra_info) override;
 
  private:
   ui::PageTransition transition_ = ui::PAGE_TRANSITION_LINK;
   bool was_no_store_main_resource_ = false;
+  bool logged_ukm_event_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerPageLoadMetricsObserver);
 };

chrome/browser/page_load_metrics/observers/service_worker_page_load_metrics_observer_unittest.cc

@@ -9,7 +9,7 @@
 
 namespace {
 
-const char kDefaultTestUrl[] = "https://google.com";
+const char kDefaultTestUrl[] = "https://google.com/";
 const char kInboxTestUrl[] = "https://inbox.google.com/test";
 const char kSearchTestUrl[] = "https://www.google.com/search?q=test";
 
@@ -135,6 +135,7 @@ TEST_F(ServiceWorkerPageLoadMetricsObserverTest, NoMetrics) {
   AssertNoInboxHistogramsLogged();
   AssertNoSearchHistogramsLogged();
   AssertNoSearchNoSWHistogramsLogged();
+  EXPECT_EQ(0ul, test_ukm_recorder().entries_count());
 }
 
 TEST_F(ServiceWorkerPageLoadMetricsObserverTest, NoServiceWorker) {
@@ -148,6 +149,7 @@ TEST_F(ServiceWorkerPageLoadMetricsObserverTest, NoServiceWorker) {
   AssertNoInboxHistogramsLogged();
   AssertNoSearchHistogramsLogged();
   AssertNoSearchNoSWHistogramsLogged();
+  EXPECT_EQ(0ul, test_ukm_recorder().entries_count());
 }
 
 TEST_F(ServiceWorkerPageLoadMetricsObserverTest, WithServiceWorker) {
@@ -201,6 +203,12 @@ TEST_F(ServiceWorkerPageLoadMetricsObserverTest, WithServiceWorker) {
   histogram_tester().ExpectTotalCount(
       internal::kHistogramServiceWorkerParseStartForwardBackNoStore, 0);
 
+  EXPECT_EQ(1ul, test_ukm_recorder().entries_count());
+  const ukm::UkmSource* source =
+      test_ukm_recorder().GetSourceForUrl(kDefaultTestUrl);
+  EXPECT_TRUE(
+      test_ukm_recorder().HasEntry(*source, internal::kUkmServiceWorkerName));
+
   AssertNoInboxHistogramsLogged();
   AssertNoSearchHistogramsLogged();
   AssertNoSearchNoSWHistogramsLogged();
@@ -246,6 +254,12 @@ TEST_F(ServiceWorkerPageLoadMetricsObserverTest, WithServiceWorkerBackground) {
   // histogram_tester().ExpectTotalCount(
   //     internal::kBackgroundHistogramServiceWorkerParseStart, 1);
 
+  EXPECT_EQ(1ul, test_ukm_recorder().entries_count());
+  const ukm::UkmSource* source =
+      test_ukm_recorder().GetSourceForUrl(kDefaultTestUrl);
+  EXPECT_TRUE(
+      test_ukm_recorder().HasEntry(*source, internal::kUkmServiceWorkerName));
+
   AssertNoInboxHistogramsLogged();
   AssertNoSearchHistogramsLogged();
   AssertNoSearchNoSWHistogramsLogged();

chrome/browser/page_load_metrics/observers/subresource_filter_metrics_observer.cc

@@ -4,10 +4,13 @@
 
 #include "chrome/browser/page_load_metrics/observers/subresource_filter_metrics_observer.h"
 
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/page_load_metrics/page_load_metrics_util.h"
 #include "components/subresource_filter/content/browser/content_subresource_filter_driver_factory.h"
 #include "components/subresource_filter/content/browser/subresource_filter_safe_browsing_activation_throttle.h"
 #include "components/subresource_filter/core/common/activation_decision.h"
+#include "services/metrics/public/cpp/ukm_entry_builder.h"
+#include "services/metrics/public/cpp/ukm_recorder.h"
 #include "third_party/WebKit/public/platform/WebLoadingBehaviorFlag.h"
 
 using subresource_filter::ContentSubresourceFilterDriverFactory;
@@ -113,6 +116,10 @@ const char kHistogramSubresourceFilterActivationDecision[] =
 const char kHistogramSubresourceFilterActivationDecisionReload[] =
     "PageLoad.Clients.SubresourceFilter.ActivationDecision.LoadType.Reload";
 
+const char kUkmSubresourceFilterName[] = "SubresourceFilter";
+const char kUkmSubresourceFilterActivationDecision[] = "ActivationDecision";
+const char kUkmSubresourceFilterDryRun[] = "DryRun";
+
 }  // namespace internal
 
 namespace {
@@ -185,6 +192,21 @@ SubresourceFilterMetricsObserver::OnCommit(
   DCHECK(scoped_observer_.IsObservingSources());
   LogActivationDecisionMetrics(navigation_handle, *activation_decision_);
   scoped_observer_.RemoveAll();
+
+  ukm::UkmRecorder* ukm_recorder = g_browser_process->ukm_recorder();
+  if (ukm_recorder) {
+    std::unique_ptr<ukm::UkmEntryBuilder> builder =
+        ukm_recorder->GetEntryBuilder(source_id,
+                                      internal::kUkmSubresourceFilterName);
+    builder->AddMetric(internal::kUkmSubresourceFilterActivationDecision,
+                       static_cast<int64_t>(*activation_decision_));
+    if (*activation_level_ == subresource_filter::ActivationLevel::DRYRUN) {
+      DCHECK_EQ(subresource_filter::ActivationDecision::ACTIVATED,
+                *activation_decision_);
+      builder->AddMetric(internal::kUkmSubresourceFilterDryRun, true);
+    }
+  }
+
   return CONTINUE_OBSERVING;
 }
 
@@ -339,6 +361,9 @@ void SubresourceFilterMetricsObserver::OnPageActivationComputed(
   DCHECK(!did_commit_);
   DCHECK(!activation_decision_);
   activation_decision_ = activation_decision;
+
+  DCHECK(!activation_level_);
+  activation_level_ = activation_state.activation_level;
 }
 
 void SubresourceFilterMetricsObserver::OnGoingAway(

chrome/browser/page_load_metrics/observers/subresource_filter_metrics_observer.h

@@ -11,6 +11,8 @@
 #include "chrome/browser/page_load_metrics/page_load_metrics_observer.h"
 #include "components/subresource_filter/content/browser/subresource_filter_observer.h"
 #include "components/subresource_filter/content/browser/subresource_filter_observer_manager.h"
+#include "components/subresource_filter/core/common/activation_decision.h"
+#include "components/subresource_filter/core/common/activation_level.h"
 #include "components/ukm/ukm_source.h"
 
 namespace internal {
@@ -60,6 +62,10 @@ extern const char kHistogramSubresourceFilterCount[];
 extern const char kHistogramSubresourceFilterActivationDecision[];
 extern const char kHistogramSubresourceFilterActivationDecisionReload[];
 
+extern const char kUkmSubresourceFilterName[];
+extern const char kUkmSubresourceFilterActivationDecision[];
+extern const char kUkmSubresourceFilterDryRun[];
+
 }  // namespace internal
 
 class SubresourceFilterMetricsObserver
@@ -115,6 +121,7 @@ class SubresourceFilterMetricsObserver
                    base::TimeTicks app_background_time);
 
   base::Optional<subresource_filter::ActivationDecision> activation_decision_;
+  base::Optional<subresource_filter::ActivationLevel> activation_level_;
 
   ScopedObserver<subresource_filter::SubresourceFilterObserverManager,
                  subresource_filter::SubresourceFilterObserver>

chrome/browser/page_load_metrics/observers/subresource_filter_metrics_observer_unittest.cc

@@ -19,6 +19,8 @@
 namespace {
 const char kDefaultTestUrl[] = "https://example.com/";
 const char kDefaultTestUrlWithActivation[] = "https://example-activation.com/";
+const char kDefaultTestUrlWithActivationDryRun[] =
+    "https://dryrun.example-activation.com/";
 }  // namespace
 
 class SubresourceFilterMetricsObserverTest
@@ -78,6 +80,11 @@ class SubresourceFilterMetricsObserverTest
           handle, subresource_filter::ActivationDecision::ACTIVATED,
           subresource_filter::ActivationState(
               subresource_filter::ActivationLevel::ENABLED));
+    } else if (handle->GetURL() == kDefaultTestUrlWithActivationDryRun) {
+      observer_manager_->NotifyPageActivationComputed(
+          handle, subresource_filter::ActivationDecision::ACTIVATED,
+          subresource_filter::ActivationState(
+              subresource_filter::ActivationLevel::DRYRUN));
     } else {
       observer_manager_->NotifyPageActivationComputed(
           handle,
@@ -88,6 +95,28 @@ class SubresourceFilterMetricsObserverTest
     simulator->Commit();
   }
 
+  void ExpectActivationDecision(const char* url,
+                                subresource_filter::ActivationDecision decision,
+                                subresource_filter::ActivationLevel level) {
+    histogram_tester().ExpectBucketCount(
+        internal::kHistogramSubresourceFilterActivationDecision,
+        static_cast<int>(decision), 1);
+
+    ASSERT_EQ(1ul, test_ukm_recorder().entries_count());
+    const ukm::UkmSource* source = test_ukm_recorder().GetSourceForUrl(url);
+    EXPECT_TRUE(test_ukm_recorder().HasEntry(
+        *source, internal::kUkmSubresourceFilterName));
+    test_ukm_recorder().ExpectMetric(
+        *source, internal::kUkmSubresourceFilterName,
+        internal::kUkmSubresourceFilterActivationDecision,
+        static_cast<int64_t>(decision));
+    if (level == subresource_filter::ActivationLevel::DRYRUN) {
+      test_ukm_recorder().ExpectMetric(
+          *source, internal::kUkmSubresourceFilterName,
+          internal::kUkmSubresourceFilterDryRun, true);
+    }
+  }
+
  private:
   // Owned by the WebContents.
   subresource_filter::SubresourceFilterObserverManager* observer_manager_ =
@@ -109,11 +138,10 @@ TEST_F(SubresourceFilterMetricsObserverTest,
   NavigateToUntrackedUrl();
 
   EXPECT_EQ(1u, TotalMetricsRecorded());
-  histogram_tester().ExpectBucketCount(
-      internal::kHistogramSubresourceFilterActivationDecision,
-      static_cast<int>(subresource_filter::ActivationDecision::
-                           ACTIVATION_CONDITIONS_NOT_MET),
-      1);
+  ExpectActivationDecision(
+      kDefaultTestUrl,
+      subresource_filter::ActivationDecision::ACTIVATION_CONDITIONS_NOT_MET,
+      subresource_filter::ActivationLevel::DISABLED);
 }
 
 TEST_F(SubresourceFilterMetricsObserverTest, Basic) {
@@ -130,6 +158,9 @@ TEST_F(SubresourceFilterMetricsObserverTest, Basic) {
   NavigateToUntrackedUrl();
 
   EXPECT_GT(TotalMetricsRecorded(), 0u);
+  ExpectActivationDecision(kDefaultTestUrlWithActivation,
+                           subresource_filter::ActivationDecision::ACTIVATED,
+                           subresource_filter::ActivationLevel::ENABLED);
 
   histogram_tester().ExpectTotalCount(
       internal::kHistogramSubresourceFilterCount, 1);
@@ -207,6 +238,25 @@ TEST_F(SubresourceFilterMetricsObserverTest, Basic) {
       internal::kHistogramSubresourceFilterForegroundDuration, 1);
 }
 
+TEST_F(SubresourceFilterMetricsObserverTest, DryRun) {
+  SimulateNavigateAndCommit(GURL(kDefaultTestUrlWithActivationDryRun));
+
+  page_load_metrics::mojom::PageLoadTiming timing;
+  InitializePageLoadTiming(&timing);
+  page_load_metrics::mojom::PageLoadMetadata metadata;
+  metadata.behavior_flags |=
+      blink::WebLoadingBehaviorFlag::kWebLoadingBehaviorSubresourceFilterMatch;
+  SimulateTimingAndMetadataUpdate(timing, metadata);
+
+  // Navigate away from the current page to force logging of metrics.
+  NavigateToUntrackedUrl();
+
+  EXPECT_GT(TotalMetricsRecorded(), 0u);
+  ExpectActivationDecision(kDefaultTestUrlWithActivationDryRun,
+                           subresource_filter::ActivationDecision::ACTIVATED,
+                           subresource_filter::ActivationLevel::DRYRUN);
+}
+
 TEST_F(SubresourceFilterMetricsObserverTest, Subresources) {
   SimulateNavigateAndCommit(GURL(kDefaultTestUrlWithActivation));
 
@@ -239,6 +289,9 @@ TEST_F(SubresourceFilterMetricsObserverTest, Subresources) {
                           nullptr /* data_reduction_proxy_data */,
                           content::ResourceType::RESOURCE_TYPE_SCRIPT, 0});
 
+  ExpectActivationDecision(kDefaultTestUrlWithActivation,
+                           subresource_filter::ActivationDecision::ACTIVATED,
+                           subresource_filter::ActivationLevel::ENABLED);
   histogram_tester().ExpectTotalCount(
       internal::kHistogramSubresourceFilterCount, 1);
 
@@ -342,6 +395,9 @@ TEST_F(SubresourceFilterMetricsObserverTest, SubresourcesWithMedia) {
                           nullptr /* data_reduction_proxy_data */,
                           content::ResourceType::RESOURCE_TYPE_SCRIPT, 0});
 
+  ExpectActivationDecision(kDefaultTestUrlWithActivation,
+                           subresource_filter::ActivationDecision::ACTIVATED,
+                           subresource_filter::ActivationLevel::ENABLED);
   histogram_tester().ExpectTotalCount(
       internal::kHistogramSubresourceFilterCount, 1);
 

services/metrics/public/cpp/ukm_recorder.h

@@ -19,8 +19,12 @@
 #include "url/gurl.h"
 
 class ContextualSearchRankerLoggerImpl;
+class DocumentWritePageLoadMetricsObserver;
+class FromGWSPageLoadMetricsLogger;
 class PluginInfoMessageFilter;
 class ProcessMemoryMetricsEmitter;
+class ServiceWorkerPageLoadMetricsObserver;
+class SubresourceFilterMetricsObserver;
 class UkmPageLoadMetricsObserver;
 class LocalNetworkRequestsPageLoadMetricsObserver;
 
@@ -94,6 +98,10 @@ class METRICS_EXPORT UkmRecorder {
   friend PluginInfoMessageFilter;
   friend UkmPageLoadMetricsObserver;
   friend LocalNetworkRequestsPageLoadMetricsObserver;
+  friend DocumentWritePageLoadMetricsObserver;
+  friend FromGWSPageLoadMetricsLogger;
+  friend ServiceWorkerPageLoadMetricsObserver;
+  friend SubresourceFilterMetricsObserver;
   friend translate::TranslateRankerImpl;
   friend TestRecordingHelper;
   friend UkmInterface;

tools/metrics/ukm/ukm.xml

@@ -395,6 +395,34 @@ be describing additional metrics about the same event.
   </metric>
 </event>
 
+<event name="Intervention.DocumentWrite.ScriptBlock" singular="True">
+  <owner>bmcquade@chromium.org</owner>
+  <summary>
+    Recorded for page loads where the document.write script block intervention
+    could apply.
+  </summary>
+  <metric name="Disabled.Reload">
+    <summary>
+      Records '1' if the document.write script block intervention could have
+      applied, but was disabled due to the page being reloaded.
+    </summary>
+  </metric>
+  <metric name="ParseTiming.ParseBlockedOnScriptExecutionFromDocumentWrite">
+    <summary>
+      Measures the time in milliseconds that the HTML parser spent blocked on
+      the execution of scripts inserted from document.write, for main frame
+      documents that finished parsing.
+    </summary>
+  </metric>
+  <metric name="ParseTiming.ParseBlockedOnScriptLoadFromDocumentWrite">
+    <summary>
+      Measures the time in milliseconds that the HTML parser spent blocked on
+      the load of scripts inserted from document.write, for main frame documents
+      that finished parsing.
+    </summary>
+  </metric>
+</event>
+
 <event name="LocalNetworkRequests">
   <owner>uthakore@chromium.org</owner>
   <summary>
@@ -650,6 +678,22 @@ be describing additional metrics about the same event.
   </metric>
 </event>
 
+<event name="PageLoad.FromGoogleSearch" singular="True">
+  <owner>bmcquade@chromium.org</owner>
+  <owner>mushan@chromium.org</owner>
+  <summary>
+    Recorded for page loads that were navigated to via Google Search.
+  </summary>
+</event>
+
+<event name="PageLoad.ServiceWorkerControlled" singular="True">
+  <owner>bmcquade@chromium.org</owner>
+  <owner>falken@chromium.org</owner>
+  <summary>
+    Recorded for page loads controlled by a service worker.
+  </summary>
+</event>
+
 <event name="PasswordForm">
   <owner>battre@chromium.org</owner>
   <summary>
@@ -806,6 +850,30 @@ be describing additional metrics about the same event.
   </summary>
 </event>
 
+<event name="SubresourceFilter" singular="True">
+  <owner>bmcquade@chromium.org</owner>
+  <owner>csharrison@chromium.org</owner>
+  <summary>
+    Recorded for page loads where subresource filtering policy was evaluated.
+  </summary>
+  <metric name="ActivationDecision">
+    <summary>
+      Enum that records the policy decision to activate subresource filtering
+      for a page load. 0 = Unknown, 1 = Activated, 2 = Disabled, 3 = Unsupported
+      scheme, 4 = URL whitelisted, 5 = Activation conditions not met.
+      'Activated' indicates that subresource filtering was activated. All other
+      reasons indicate that subresource filtering was not activated.
+    </summary>
+  </metric>
+  <metric name="DryRun">
+    <summary>
+      Records '1' if subresource filtering was activated in dry run mode. In dry
+      run mode, subresource filtering policy is evaluated against resources
+      loaded on the page, but subresource filtering is not actually applied.
+    </summary>
+  </metric>
+</event>
+
 <event name="Translate">
   <owner>hamelphi@chromium.org</owner>
   <summary>