BackForwardCache: Enable use counters for back-forward cache

This CL enables UseCounterPageLoadMetricsObserver for back-forward
cache. The page load's UKM ID is used to record the use counters even
after the page is restored from the cache. It is because the metrics are
per-page-load metrics and not belong to history navigations.

Bug: 1112282
Change-Id: I791713e1c2b5bcf610c49d8866527f9be20c9376
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2334787Reviewed-by: Nicolás Peña Moreno <npm@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: Hajime Hoshi <hajimehoshi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#795328}

chrome/browser/page_load_metrics/observers/use_counter_page_load_metrics_observer_browsertest.cc

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/page_load_metrics/browser/observers/use_counter_page_load_metrics_observer.h"
+
+#include "chrome/browser/page_load_metrics/integration_tests/metric_integration_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "components/page_load_metrics/browser/page_load_metrics_test_waiter.h"
+#include "components/page_load_metrics/common/test/page_load_metrics_test_util.h"
+#include "content/public/common/content_features.h"
+#include "content/public/test/browser_test.h"
+
+namespace {
+
+using WebFeature = blink::mojom::WebFeature;
+
+class UseCounterPageLoadMetricsObserverBrowserTest
+    : public MetricIntegrationTest {
+ public:
+  ~UseCounterPageLoadMetricsObserverBrowserTest() override = default;
+
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    feature_list_.InitWithFeaturesAndParameters(
+        {{features::kBackForwardCache,
+          {{"TimeToLiveInBackForwardCacheInSeconds", "3600"}}}},
+        {});
+
+    MetricIntegrationTest::SetUpCommandLine(command_line);
+  }
+
+ protected:
+  content::RenderFrameHost* top_frame_host() {
+    return web_contents()->GetMainFrame();
+  }
+
+  std::unique_ptr<page_load_metrics::PageLoadMetricsTestWaiter>
+  CreatePageLoadMetricsTestWaiter() {
+    return std::make_unique<page_load_metrics::PageLoadMetricsTestWaiter>(
+        web_contents());
+  }
+
+  base::test::ScopedFeatureList feature_list_;
+};
+
+}  // namespace
+
+IN_PROC_BROWSER_TEST_F(UseCounterPageLoadMetricsObserverBrowserTest,
+                       RecordFeatures) {
+  std::vector<WebFeature> features_0(
+      {WebFeature::kFetch, WebFeature::kFetchBodyStream});
+  std::vector<WebFeature> features_1({WebFeature::kWindowFind});
+  page_load_metrics::mojom::PageLoadFeatures page_load_features_0;
+  page_load_metrics::mojom::PageLoadFeatures page_load_features_1;
+  page_load_features_0.features = features_0;
+  page_load_features_1.features = features_1;
+
+  Start();
+  GURL url_a(embedded_test_server()->GetURL("a.com", "/title1.html"));
+  GURL url_b(embedded_test_server()->GetURL("b.com", "/title1.html"));
+
+  // Navigate to A.
+  EXPECT_TRUE(ui_test_utils::NavigateToURL(browser(), url_a));
+  content::RenderFrameHost* rfh_a = top_frame_host();
+  page_load_metrics::MetricsWebContentsObserver::RecordFeatureUsage(
+      rfh_a, page_load_features_0);
+
+  // Navigate to B.
+  EXPECT_TRUE(ui_test_utils::NavigateToURL(browser(), url_b));
+  EXPECT_TRUE(rfh_a->IsInBackForwardCache());
+
+  // Go back to A.
+  web_contents()->GetController().GoBack();
+  EXPECT_TRUE(WaitForLoadStop(web_contents()));
+  EXPECT_EQ(rfh_a, top_frame_host());
+  EXPECT_FALSE(rfh_a->IsInBackForwardCache());
+  page_load_metrics::MetricsWebContentsObserver::RecordFeatureUsage(
+      rfh_a, page_load_features_1);
+
+  // The RenderFrameHost for the page B was likely in the back-forward cache
+  // just after the history navigation, but now this might be evicted due to
+  // outstanding-network request.
+
+  // Navigate to B again.
+  EXPECT_TRUE(ui_test_utils::NavigateToURL(browser(), url_b));
+  EXPECT_TRUE(rfh_a->IsInBackForwardCache());
+
+  // Go back to A again.
+  web_contents()->GetController().GoBack();
+  EXPECT_TRUE(WaitForLoadStop(web_contents()));
+  EXPECT_EQ(rfh_a, top_frame_host());
+  EXPECT_FALSE(rfh_a->IsInBackForwardCache());
+
+  for (auto feature : page_load_features_0.features) {
+    histogram_tester().ExpectBucketCount(
+        internal::kFeaturesHistogramName,
+        static_cast<base::Histogram::Sample>(feature), 1);
+    histogram_tester().ExpectBucketCount(
+        internal::kFeaturesHistogramMainFrameName,
+        static_cast<base::Histogram::Sample>(feature), 1);
+  }
+  for (auto feature : page_load_features_1.features) {
+    histogram_tester().ExpectBucketCount(
+        internal::kFeaturesHistogramName,
+        static_cast<base::Histogram::Sample>(feature), 1);
+    histogram_tester().ExpectBucketCount(
+        internal::kFeaturesHistogramMainFrameName,
+        static_cast<base::Histogram::Sample>(feature), 1);
+  }
+}

chrome/test/BUILD.gn

@@ -1066,6 +1066,7 @@ if (!is_android) {
       "../browser/page_load_metrics/observers/security_state_page_load_metrics_observer_browsertest.cc",
       "../browser/page_load_metrics/observers/signed_exchange_page_load_metrics_browsertest.cc",
       "../browser/page_load_metrics/observers/third_party_metrics_observer_browsertest.cc",
+      "../browser/page_load_metrics/observers/use_counter_page_load_metrics_observer_browsertest.cc",
       "../browser/page_load_metrics/page_load_metrics_browsertest.cc",
       "../browser/password_manager/credential_manager_browsertest.cc",
       "../browser/password_manager/password_manager_browsertest.cc",

components/page_load_metrics/browser/observers/use_counter_page_load_metrics_observer.cc

@@ -28,8 +28,9 @@ void RecordUkmFeatures(const UkmFeatureList& features,
     if (!features_recorded.test(static_cast<size_t>(feature)))
       continue;
     if (ukm_features_recorded->find(static_cast<size_t>(feature)) !=
-        ukm_features_recorded->end())
+        ukm_features_recorded->end()) {
       continue;
+    }
     ukm::builders::Blink_UseCounter(source_id)
         .SetFeature(static_cast<size_t>(feature))
         .SetIsMainFrameFeature(
@@ -237,3 +238,9 @@ UseCounterPageLoadMetricsObserver::ShouldObserveMimeType(
              ? CONTINUE_OBSERVING
              : STOP_OBSERVING;
 }
+
+page_load_metrics::PageLoadMetricsObserver::ObservePolicy
+UseCounterPageLoadMetricsObserver::OnEnterBackForwardCache(
+    const page_load_metrics::mojom::PageLoadTiming& timing) {
+  return CONTINUE_OBSERVING;
+}

components/page_load_metrics/browser/observers/use_counter_page_load_metrics_observer.h

@@ -40,6 +40,8 @@ class UseCounterPageLoadMetricsObserver
   void OnFailedProvisionalLoad(
       const page_load_metrics::FailedProvisionalLoadInfo&
           failed_provisional_load_info) override;
+  ObservePolicy OnEnterBackForwardCache(
+      const page_load_metrics::mojom::PageLoadTiming& timing) override;
   ObservePolicy FlushMetricsOnAppEnterBackground(
       const page_load_metrics::mojom::PageLoadTiming& timing) override;
   ObservePolicy ShouldObserveMimeType(