Add UKM event for PreviewsResourceLoadingHints

A new UKM event, PreviewsResourceLoadingHints, is being added. This
tracks the usage of the patterns associated with a resource loading
hints based preview and the total number of resource requests blocked
at each resource load priority.

The UKM is recorded after the URL's document finished loading and uses
the NavigationID from the browser's NavigationHandle as the source id.

Bug: 891453, 884815
Change-Id: I429a6ef5e6222d7f569c8d2eb5539d815af6ff02
Reviewed-on: https://chromium-review.googlesource.com/c/1307057
Commit-Queue: Jered Gray <jegray@chromium.org>
Reviewed-by: Steven Holte <holte@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Tarun Bansal <tbansal@chromium.org>
Cr-Commit-Position: refs/heads/master@{#605034}

chrome/browser/previews/resource_loading_hints/resource_loading_hints_web_contents_observer.cc

@@ -20,6 +20,7 @@
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
+#include "services/metrics/public/cpp/ukm_source_id.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/blink/public/mojom/loader/previews_resource_loading_hints.mojom.h"
 #include "url/gurl.h"
@@ -84,6 +85,9 @@ void ResourceLoadingHintsWebContentsObserver::SendResourceLoadingHints(
 
   if (hints.empty())
     return;
+
+  hints_ptr->ukm_source_id = ukm::ConvertToSourceId(
+      navigation_handle->GetNavigationId(), ukm::SourceIdType::NAVIGATION_ID);
   for (const std::string& hint : hints)
     hints_ptr->subresources_to_block.push_back(hint);
 

third_party/blink/public/mojom/loader/previews_resource_loading_hints.mojom

@@ -9,6 +9,9 @@ module blink.mojom;
 // hints are provided to the renderer and aid in optimizing the loading of
 // resources.
 struct PreviewsResourceLoadingHints {
+    // SourceId to use when recording UKM for the resource loading hints. This
+    // is based on the browser NavigationHandle's navigation id.
+    int64 ukm_source_id;
     // List of subresources to block. The list contains the URL patterns of
     // subresources to block.
     // TODO(tbansal): https://crbug.com/856243. Update the mojom message below

third_party/blink/renderer/core/DEPS

@@ -71,6 +71,7 @@ specific_include_rules = {
         "+base/message_loop/message_loop.h",
         # Test harness may use cc directly instead of going through WebViewImpl etc.
         "+cc",
+        "+components/ukm/test_ukm_recorder.h",
 	# TODO(crbug.com/838693): Test harnesses use LayerTreeView
 	# from content instead of a fake WebLayerTreeView implementation, so
 	# that the Web abstraction can go away.
@@ -88,7 +89,4 @@ specific_include_rules = {
     "find_task_controller.cc" : [
         "+third_party/blink/renderer/core/frame/web_local_frame_impl.h",
     ],
-    "local_frame_ukm_aggregator_test.cc" : [
-        "+components/ukm/test_ukm_recorder.h"
-    ],
 }

third_party/blink/renderer/core/dom/document.cc

@@ -3583,6 +3583,15 @@ bool Document::CheckCompletedInternal() {
     }
 
     AnchorElementMetrics::MaybeReportViewportMetricsOnLoad(*this);
+
+    // If this is a document associated with a resource loading hints based
+    // preview, then record the resource loading hints UKM now that the load is
+    // finished.
+    PreviewsResourceLoadingHints* hints =
+        Loader()->GetPreviewsResourceLoadingHints();
+    if (hints) {
+      hints->RecordUKM(UkmRecorder());
+    }
   }
 
   return true;

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

@@ -5,6 +5,8 @@
 #include "third_party/blink/renderer/core/loader/previews_resource_loading_hints.h"
 
 #include "base/metrics/histogram_macros.h"
+#include "services/metrics/public/cpp/ukm_builders.h"
+#include "services/metrics/public/cpp/ukm_recorder.h"
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
@@ -28,16 +30,25 @@ String GetConsoleLogStringForBlockedLoad(const KURL& url) {
 // static
 PreviewsResourceLoadingHints* PreviewsResourceLoadingHints::Create(
     ExecutionContext& execution_context,
+    int64_t ukm_source_id,
     const std::vector<WTF::String>& subresource_patterns_to_block) {
-  return new PreviewsResourceLoadingHints(&execution_context,
+  return new PreviewsResourceLoadingHints(&execution_context, ukm_source_id,
                                           subresource_patterns_to_block);
 }
 
 PreviewsResourceLoadingHints::PreviewsResourceLoadingHints(
     ExecutionContext* execution_context,
+    int64_t ukm_source_id,
     const std::vector<WTF::String>& subresource_patterns_to_block)
     : execution_context_(execution_context),
-      subresource_patterns_to_block_(subresource_patterns_to_block) {}
+      ukm_source_id_(ukm_source_id),
+      subresource_patterns_to_block_(subresource_patterns_to_block) {
+  DCHECK_NE(ukm::kInvalidSourceId, ukm_source_id_);
+
+  subresource_patterns_to_block_usage_.assign(
+      subresource_patterns_to_block.size(), false);
+  blocked_resource_load_priority_counts_.fill(0);
+}
 
 PreviewsResourceLoadingHints::~PreviewsResourceLoadingHints() = default;
 
@@ -51,14 +62,19 @@ bool PreviewsResourceLoadingHints::AllowLoad(
   resource_url_string = resource_url_string.Left(resource_url.PathEnd());
   bool allow_load = true;
 
+  int pattern_index = 0;
   for (const WTF::String& subresource_pattern :
        subresource_patterns_to_block_) {
     // TODO(tbansal): https://crbug.com/856247. Add support for wildcard
     // matching.
     if (resource_url_string.Find(subresource_pattern) != kNotFound) {
       allow_load = false;
+      subresource_patterns_to_block_usage_[pattern_index] = true;
+      blocked_resource_load_priority_counts_[static_cast<int>(
+          resource_load_priority)]++;
       break;
     }
+    pattern_index++;
   }
 
   UMA_HISTOGRAM_BOOLEAN("ResourceLoadingHints.ResourceLoadingBlocked",
@@ -91,4 +107,36 @@ void PreviewsResourceLoadingHints::Trace(blink::Visitor* visitor) {
   visitor->Trace(execution_context_);
 }
 
+void PreviewsResourceLoadingHints::RecordUKM(
+    ukm::UkmRecorder* ukm_recorder) const {
+  DCHECK(ukm_recorder);
+
+  size_t patterns_to_block_used_count = 0;
+  for (bool pattern_used : subresource_patterns_to_block_usage_) {
+    if (pattern_used) {
+      patterns_to_block_used_count++;
+    }
+  }
+
+  ukm::builders::PreviewsResourceLoadingHints(ukm_source_id_)
+      .Setpatterns_to_block_total(subresource_patterns_to_block_.size())
+      .Setpatterns_to_block_used(patterns_to_block_used_count)
+      .Setblocked_very_low_priority(
+          blocked_resource_load_priority_counts_[static_cast<int>(
+              ResourceLoadPriority::kVeryLow)])
+      .Setblocked_low_priority(
+          blocked_resource_load_priority_counts_[static_cast<int>(
+              ResourceLoadPriority::kLow)])
+      .Setblocked_medium_priority(
+          blocked_resource_load_priority_counts_[static_cast<int>(
+              ResourceLoadPriority::kMedium)])
+      .Setblocked_high_priority(
+          blocked_resource_load_priority_counts_[static_cast<int>(
+              ResourceLoadPriority::kHigh)])
+      .Setblocked_very_high_priority(
+          blocked_resource_load_priority_counts_[static_cast<int>(
+              ResourceLoadPriority::kVeryHigh)])
+      .Record(ukm_recorder);
+}
+
 }  // namespace blink

third_party/blink/renderer/core/loader/previews_resource_loading_hints.h

@@ -13,6 +13,10 @@
 #include "third_party/blink/renderer/platform/loader/fetch/resource_load_priority.h"
 #include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"
 
+namespace ukm {
+class UkmRecorder;
+}
+
 namespace blink {
 
 class ExecutionContext;
@@ -25,6 +29,7 @@ class CORE_EXPORT PreviewsResourceLoadingHints final
  public:
   static PreviewsResourceLoadingHints* Create(
       ExecutionContext& execution_context,
+      int64_t ukm_source_id,
       const std::vector<WTF::String>& subresource_patterns_to_block);
 
   ~PreviewsResourceLoadingHints();
@@ -36,15 +41,22 @@ class CORE_EXPORT PreviewsResourceLoadingHints final
 
   virtual void Trace(blink::Visitor*);
 
+  // Records UKM on the utilization of patterns to block during the document
+  // load. This is expected to be called once after the document finishes
+  // loading.
+  void RecordUKM(ukm::UkmRecorder* ukm_recorder) const;
+
  private:
   PreviewsResourceLoadingHints(
       ExecutionContext* execution_context,
+      int64_t ukm_source_id,
       const std::vector<WTF::String>& subresource_patterns_to_block);
 
   // Reports to console when loading of |resource_url| is blocked.
   void ReportBlockedLoading(const KURL& resource_url) const;
 
   Member<ExecutionContext> execution_context_;
+  const int64_t ukm_source_id_;
 
   // |subresource_patterns_to_block_| is a collection of subresource patterns
   // for resources whose loading should be blocked. Each pattern is a
@@ -52,6 +64,15 @@ class CORE_EXPORT PreviewsResourceLoadingHints final
   // |subresource_patterns_to_block_|, then that subresource's loading could
   // be blocked.
   const std::vector<WTF::String> subresource_patterns_to_block_;
+
+  // |subresource_patterns_to_block_usage_| records whether the pattern located
+  // at the same index in |subresource_patterns_to_block_| was ever blocked.
+  mutable std::vector<bool> subresource_patterns_to_block_usage_;
+
+  // |blocked_resource_load_priority_counts_| records the total number of
+  // resources blocked at each ResourceLoadPriority.
+  mutable std::array<int, static_cast<int>(ResourceLoadPriority::kHighest) + 1>
+      blocked_resource_load_priority_counts_;
 };
 
 }  // namespace blink

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

@@ -37,8 +37,9 @@ void PreviewsResourceLoadingHintsReceiverImpl::SetResourceLoadingHints(
   }
 
   document_->Loader()->SetPreviewsResourceLoadingHints(
-      PreviewsResourceLoadingHints::Create(*(document_.Get()),
-                                           subresource_patterns_to_block));
+      PreviewsResourceLoadingHints::Create(
+          *(document_.Get()), resource_loading_hints->ukm_source_id,
+          subresource_patterns_to_block));
 }
 
 }  // namespace blink

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

@@ -8,10 +8,12 @@
 #include <vector>
 
 #include "base/test/metrics/histogram_tester.h"
+#include "components/ukm/test_ukm_recorder.h"
+#include "services/metrics/public/cpp/ukm_builders.h"
+#include "services/metrics/public/cpp/ukm_recorder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/loader/frame_loader.h"
-#include "third_party/blink/renderer/core/loader/previews_resource_loading_hints.h"
 #include "third_party/blink/renderer/core/testing/dummy_page_holder.h"
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
 #include "third_party/blink/renderer/platform/geometry/int_size.h"
@@ -38,7 +40,8 @@ TEST_F(PreviewsResourceLoadingHintsTest, NoPatterns) {
   std::vector<WTF::String> subresources_to_block;
 
   PreviewsResourceLoadingHints* hints = PreviewsResourceLoadingHints::Create(
-      dummy_page_holder_->GetDocument(), subresources_to_block);
+      dummy_page_holder_->GetDocument(), ukm::UkmRecorder::GetNewSourceID(),
+      subresources_to_block);
   EXPECT_TRUE(hints->AllowLoad(KURL("https://www.example.com/"),
                                ResourceLoadPriority::kHighest));
 }
@@ -48,7 +51,8 @@ TEST_F(PreviewsResourceLoadingHintsTest, OnePattern) {
   subresources_to_block.push_back("foo.jpg");
 
   PreviewsResourceLoadingHints* hints = PreviewsResourceLoadingHints::Create(
-      dummy_page_holder_->GetDocument(), subresources_to_block);
+      dummy_page_holder_->GetDocument(), ukm::UkmRecorder::GetNewSourceID(),
+      subresources_to_block);
 
   const struct {
     KURL url;
@@ -102,7 +106,8 @@ TEST_F(PreviewsResourceLoadingHintsTest, MultiplePatterns) {
   subresources_to_block.push_back(".example2.com/baz.jpg");
 
   PreviewsResourceLoadingHints* hints = PreviewsResourceLoadingHints::Create(
-      dummy_page_holder_->GetDocument(), subresources_to_block);
+      dummy_page_holder_->GetDocument(), ukm::UkmRecorder::GetNewSourceID(),
+      subresources_to_block);
 
   const struct {
     KURL url;
@@ -132,7 +137,8 @@ TEST_F(PreviewsResourceLoadingHintsTest, OnePatternHistogramChecker) {
   subresources_to_block.push_back("foo.jpg");
 
   PreviewsResourceLoadingHints* hints = PreviewsResourceLoadingHints::Create(
-      dummy_page_holder_->GetDocument(), subresources_to_block);
+      dummy_page_holder_->GetDocument(), ukm::UkmRecorder::GetNewSourceID(),
+      subresources_to_block);
 
   const struct {
     KURL url;
@@ -178,6 +184,84 @@ TEST_F(PreviewsResourceLoadingHintsTest, OnePatternHistogramChecker) {
   }
 }
 
+TEST_F(PreviewsResourceLoadingHintsTest, MultiplePatternUKMChecker) {
+  std::vector<WTF::String> subresources_to_block;
+  subresources_to_block.push_back(".example1.com/low_1.jpg");
+  subresources_to_block.push_back(".example1.com/very_low_1.jpg");
+  subresources_to_block.push_back(".example1.com/very_high_1.jpg");
+  subresources_to_block.push_back(".example1.com/medium_1_and_medium_4.jpg");
+  subresources_to_block.push_back(".example1.com/unused_1.jpg");
+  subresources_to_block.push_back(".example2.com/medium_2.jpg");
+  subresources_to_block.push_back(".example2.com/unused_2.jpg");
+  subresources_to_block.push_back(".example3.com/unused_3.jpg");
+  subresources_to_block.push_back(".example3.com/very_low_2_and_medium_3.jpg");
+
+  PreviewsResourceLoadingHints* hints = PreviewsResourceLoadingHints::Create(
+      dummy_page_holder_->GetDocument(), ukm::UkmRecorder::GetNewSourceID(),
+      subresources_to_block);
+
+  const struct {
+    KURL url;
+    ResourceLoadPriority resource_load_priority;
+  } resources_to_load[] = {
+      {KURL("https://www.example1.com/"), ResourceLoadPriority::kHigh},
+      {KURL("https://www.example1.com/foo.js"), ResourceLoadPriority::kLow},
+      {KURL("https://www.example1.com/very_low_1.jpg"),
+       ResourceLoadPriority::kVeryLow},
+      {KURL("https://www.example1.com/low_1.jpg"), ResourceLoadPriority::kLow},
+      {KURL("https://www.example1.com/very_high_1.jpg"),
+       ResourceLoadPriority::kVeryHigh},
+      {KURL("https://www.example1.com/pages/foo.jpg"),
+       ResourceLoadPriority::kVeryLow},
+      {KURL("https://www.example1.com/foobar.jpg"),
+       ResourceLoadPriority::kVeryHigh},
+      {KURL("https://www.example1.com/barfoo.jpg"),
+       ResourceLoadPriority::kVeryHigh},
+      {KURL("http://www.example1.com/foo.jpg"), ResourceLoadPriority::kLow},
+      {KURL("http://www.example1.com/medium_1_and_medium_4.jpg"),
+       ResourceLoadPriority::kMedium},
+      {KURL("http://www.example2.com/medium_2.jpg"),
+       ResourceLoadPriority::kMedium},
+      {KURL("http://www.example2.com/pages/baz.jpg"),
+       ResourceLoadPriority::kLow},
+      {KURL("http://www.example2.com/baz.html"),
+       ResourceLoadPriority::kVeryHigh},
+      {KURL("http://www.example3.com/very_low_2_and_medium_3.jpg"),
+       ResourceLoadPriority::kVeryLow},
+      {KURL("http://www.example3.com/very_low_2_and_medium_3.jpg"),
+       ResourceLoadPriority::kMedium},
+      {KURL("http://www.example1.com/medium_1_and_medium_4.jpg"),
+       ResourceLoadPriority::kMedium},
+  };
+
+  for (const auto& resource_to_load : resources_to_load) {
+    hints->AllowLoad(resource_to_load.url,
+                     resource_to_load.resource_load_priority);
+  }
+
+  ukm::TestAutoSetUkmRecorder test_ukm_recorder;
+  hints->RecordUKM(&test_ukm_recorder);
+
+  using UkmEntry = ukm::builders::PreviewsResourceLoadingHints;
+  auto entries = test_ukm_recorder.GetEntriesByName(UkmEntry::kEntryName);
+  ASSERT_EQ(1u, entries.size());
+  const auto* entry = entries[0];
+  test_ukm_recorder.ExpectEntryMetric(
+      entry, UkmEntry::kpatterns_to_block_totalName, 9);
+  test_ukm_recorder.ExpectEntryMetric(entry,
+                                      UkmEntry::kpatterns_to_block_usedName, 6);
+  test_ukm_recorder.ExpectEntryMetric(
+      entry, UkmEntry::kblocked_very_low_priorityName, 2);
+  test_ukm_recorder.ExpectEntryMetric(entry,
+                                      UkmEntry::kblocked_low_priorityName, 1);
+  test_ukm_recorder.ExpectEntryMetric(
+      entry, UkmEntry::kblocked_medium_priorityName, 4);
+  test_ukm_recorder.ExpectEntryMetric(entry,
+                                      UkmEntry::kblocked_high_priorityName, 0);
+  test_ukm_recorder.ExpectEntryMetric(
+      entry, UkmEntry::kblocked_very_high_priorityName, 1);
+}
+
 }  // namespace
 
 }  // namespace blink

tools/metrics/ukm/ukm.xml

@@ -3780,7 +3780,7 @@ be describing additional metrics about the same event.
   <owner>ryansturm@chromium.org</owner>
   <summary>
     Previews related metrics associated with a page load. See
-    //componenets/previews/.
+    //components/previews/.
   </summary>
   <metric name="client_lofi">
     <summary>
@@ -3832,6 +3832,58 @@ be describing additional metrics about the same event.
   </metric>
 </event>
 
+<event name="PreviewsResourceLoadingHints" singular="True">
+  <owner>jegray@chromium.org</owner>
+  <summary>
+    Metrics associated with loading a resource loading hints based preview. This
+    is recorded when the URL's document finishes loading. See
+    //components/previews/.
+  </summary>
+  <metric name="blocked_high_priority">
+    <summary>
+      The number of high priority resource requests that were blocked by the
+      resource loading hints based preview while the URL's document was loading.
+    </summary>
+  </metric>
+  <metric name="blocked_low_priority">
+    <summary>
+      The number of low priority resource requests that were blocked by the
+      resource loading hints based preview while the URL's document was loading.
+    </summary>
+  </metric>
+  <metric name="blocked_medium_priority">
+    <summary>
+      The number of medium priority resource requests that were blocked by the
+      resource loading hints based preview while the URL's document was loading.
+    </summary>
+  </metric>
+  <metric name="blocked_very_high_priority">
+    <summary>
+      The number of very high priority resource requests that were blocked by
+      the resource loading hints based preview while the URL's document was
+      loading.
+    </summary>
+  </metric>
+  <metric name="blocked_very_low_priority">
+    <summary>
+      The number of very low priority resource requests that were blocked by the
+      resource loading hints based preview while the URL's document was loading.
+    </summary>
+  </metric>
+  <metric name="patterns_to_block_total">
+    <summary>
+      The total number of patterns to block included in the resource loading
+      hints based preview.
+    </summary>
+  </metric>
+  <metric name="patterns_to_block_used">
+    <summary>
+      The number of patterns that blocked at least one resource request in the
+      resource loading hints based preview while the URL's document was loading.
+    </summary>
+  </metric>
+</event>
+
 <event name="ResponsivenessMeasurement">
   <owner>npm@chromium.org</owner>
   <owner>tdresser@chromium.org</owner>