Add feature for target prediction

This also only creates the prediction manager if the feature is enabled
and overrides any target decision if feature is enabled

Bug: 1001194
Change-Id: Iea7db02a4e7b851967228df44c8ce7458118d1d3
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1853863Reviewed-by: Tarun Bansal <tbansal@chromium.org>
Reviewed-by: Michael Crouse <mcrouse@chromium.org>
Commit-Queue: Sophie Chang <sophiechang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#704835}

chrome/browser/optimization_guide/optimization_guide_keyed_service.cc

@@ -144,8 +144,10 @@ void OptimizationGuideKeyedService::Initialize(
       database_provider, top_host_provider_.get(),
       content::BrowserContext::GetDefaultStoragePartition(profile)
           ->GetURLLoaderFactoryForBrowserProcess());
-  prediction_manager_ =
-      std::make_unique<optimization_guide::PredictionManager>();
+  if (optimization_guide::features::IsOptimizationTargetPredictionEnabled()) {
+    prediction_manager_ =
+        std::make_unique<optimization_guide::PredictionManager>();
+  }
 }
 
 void OptimizationGuideKeyedService::MaybeLoadHintForNavigation(
@@ -164,9 +166,10 @@ void OptimizationGuideKeyedService::RegisterOptimizationTypesAndTargets(
     const std::vector<optimization_guide::proto::OptimizationTarget>&
         optimization_targets) {
   DCHECK(hints_manager_);
-  DCHECK(prediction_manager_);
   hints_manager_->RegisterOptimizationTypes(optimization_types);
-  prediction_manager_->RegisterOptimizationTargets(optimization_targets);
+
+  if (prediction_manager_)
+    prediction_manager_->RegisterOptimizationTargets(optimization_targets);
 }
 
 optimization_guide::OptimizationGuideDecision
@@ -184,6 +187,13 @@ OptimizationGuideKeyedService::CanApplyOptimization(
       &optimization_target_decision, &optimization_type_decision,
       optimization_metadata);
 
+  if (prediction_manager_) {
+    optimization_target_decision = prediction_manager_->ShouldTargetNavigation(
+        navigation_handle, optimization_target);
+    // TODO(crbug/1001194): Add feature param for propagating decision that
+    // allows for us to collect metrics without tainting the data.
+  }
+
   LogDecisions(navigation_handle, optimization_target,
                optimization_target_decision, optimization_type,
                optimization_type_decision);

chrome/browser/optimization_guide/optimization_guide_keyed_service_browsertest.cc

@@ -248,6 +248,13 @@ class OptimizationGuideKeyedServiceBrowserTest
   DISALLOW_COPY_AND_ASSIGN(OptimizationGuideKeyedServiceBrowserTest);
 };
 
+IN_PROC_BROWSER_TEST_F(OptimizationGuideKeyedServiceBrowserTest,
+                       PredictionManagerNotCreatedIfFeatureDisabled) {
+  ASSERT_FALSE(
+      OptimizationGuideKeyedServiceFactory::GetForProfile(browser()->profile())
+          ->GetPredictionManager());
+}
+
 IN_PROC_BROWSER_TEST_F(OptimizationGuideKeyedServiceBrowserTest,
                        TopHostProviderNotSetIfNotAllowed) {
   ASSERT_FALSE(
@@ -664,3 +671,61 @@ IN_PROC_BROWSER_TEST_F(OptimizationGuideKeyedServiceCommandLineOverridesTest,
   EXPECT_EQ("whatever.com", top_hosts[0]);
   EXPECT_EQ("somehost.com", top_hosts[1]);
 }
+
+class OptimizationGuideKeyedServiceTargetPredictionEnabledBrowserTest
+    : public OptimizationGuideKeyedServiceBrowserTest {
+ public:
+  OptimizationGuideKeyedServiceTargetPredictionEnabledBrowserTest() = default;
+  ~OptimizationGuideKeyedServiceTargetPredictionEnabledBrowserTest() override =
+      default;
+
+  void SetUp() override {
+    scoped_feature_list_.InitAndEnableFeature(
+        optimization_guide::features::kOptimizationTargetPrediction);
+
+    OptimizationGuideKeyedServiceBrowserTest::SetUp();
+  }
+
+  void TearDown() override {
+    OptimizationGuideKeyedServiceBrowserTest::TearDown();
+
+    scoped_feature_list_.Reset();
+  }
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
+IN_PROC_BROWSER_TEST_F(
+    OptimizationGuideKeyedServiceTargetPredictionEnabledBrowserTest,
+    PredictionManagerIsCreated) {
+  ASSERT_TRUE(
+      OptimizationGuideKeyedServiceFactory::GetForProfile(browser()->profile())
+          ->GetPredictionManager());
+}
+
+IN_PROC_BROWSER_TEST_F(
+    OptimizationGuideKeyedServiceTargetPredictionEnabledBrowserTest,
+    PredictionManagerDecisionOverridesHintsManager) {
+  PushHintsComponentAndWaitForCompletion();
+  RegisterWithKeyedService();
+
+  ukm::TestAutoSetUkmRecorder ukm_recorder;
+  base::HistogramTester histogram_tester;
+
+  ui_test_utils::NavigateToURL(browser(), url_with_hints());
+
+  EXPECT_EQ(RetryForHistogramUntilCountReached(
+                histogram_tester, "OptimizationGuide.LoadedHint.Result", 1),
+            1);
+  // There should be a hint that matches this URL.
+  histogram_tester.ExpectUniqueSample("OptimizationGuide.LoadedHint.Result",
+                                      true, 1);
+  EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse,
+            last_consumer_decision());
+  histogram_tester.ExpectUniqueSample(
+      "OptimizationGuide.TargetDecision.PainfulPageLoad",
+      static_cast<int>(optimization_guide::OptimizationTargetDecision::
+                           kModelNotAvailableOnClient),
+      1);
+}

chrome/browser/optimization_guide/prediction/prediction_manager_browsertest.cc

@@ -30,7 +30,8 @@ class PredictionManagerBrowserTest : public InProcessBrowserTest {
   void SetUp() override {
     scoped_feature_list_.InitWithFeatures(
         {optimization_guide::features::kOptimizationHints,
-         optimization_guide::features::kOptimizationGuideKeyedService},
+         optimization_guide::features::kOptimizationGuideKeyedService,
+         optimization_guide::features::kOptimizationTargetPrediction},
         {});
     InProcessBrowserTest::SetUp();
   }

components/optimization_guide/optimization_guide_features.cc

@@ -49,13 +49,17 @@ const base::Feature kOptimizationHintsFetching{
 const base::Feature kOptimizationGuideKeyedService{
     "OptimizationGuideKeyedService", base::FEATURE_DISABLED_BY_DEFAULT};
 
+// Enables the prediction of optimization targets.
+const base::Feature kOptimizationTargetPrediction{
+    "OptimizationTargetPrediction", base::FEATURE_DISABLED_BY_DEFAULT};
+
 size_t MaxHintsFetcherTopHostBlacklistSize() {
   // The blacklist will be limited to the most engaged hosts and will hold twice
   // (2*N) as many hosts that the HintsFetcher request hints for. The extra N
   // hosts on the blacklist are meant to cover the case that the engagement
   // scores on some of the top N host engagement scores decay and they fall out
   // of the top N.
-  return GetFieldTrialParamByFeatureAsInt(features::kOptimizationHintsFetching,
+  return GetFieldTrialParamByFeatureAsInt(kOptimizationHintsFetching,
                                           "top_host_blacklist_size_multiplier",
                                           2) *
          MaxHostsForOptimizationGuideServiceHintsFetch();
@@ -63,13 +67,13 @@ size_t MaxHintsFetcherTopHostBlacklistSize() {
 
 size_t MaxHostsForOptimizationGuideServiceHintsFetch() {
   return GetFieldTrialParamByFeatureAsInt(
-      features::kOptimizationHintsFetching,
+      kOptimizationHintsFetching,
       "max_hosts_for_optimization_guide_service_hints_fetch", 30);
 }
 
 size_t MaxHostsForRecordingSuccessfullyCovered() {
   return GetFieldTrialParamByFeatureAsInt(
-      features::kOptimizationHintsFetching,
+      kOptimizationHintsFetching,
       "max_hosts_for_recording_successfully_covered", 200);
 }
 
@@ -78,19 +82,19 @@ double MinTopHostEngagementScoreThreshold() {
   // points for a navigation from the omnibox and 1.5 points for the first
   // navigation of the day.
   return GetFieldTrialParamByFeatureAsDouble(
-      features::kOptimizationHintsFetching,
-      "min_top_host_engagement_score_threshold", 3.0);
+      kOptimizationHintsFetching, "min_top_host_engagement_score_threshold",
+      3.0);
 }
 
 base::TimeDelta StoredFetchedHintsFreshnessDuration() {
   return base::TimeDelta::FromDays(GetFieldTrialParamByFeatureAsInt(
-      features::kOptimizationHintsFetching,
+      kOptimizationHintsFetching,
       "max_store_duration_for_featured_hints_in_days", 7));
 }
 
 base::TimeDelta DurationApplyLowEngagementScoreThreshold() {
   return base::TimeDelta::FromDays(GetFieldTrialParamByFeatureAsInt(
-      features::kOptimizationHintsFetching,
+      kOptimizationHintsFetching,
       "duration_apply_low_engagement_score_threshold_in_days", 30));
 }
 
@@ -115,7 +119,7 @@ GURL GetOptimizationGuideServiceURL() {
   }
 
   std::string url = base::GetFieldTrialParamValueByFeature(
-      features::kOptimizationHintsFetching, "optimization_guide_service_url");
+      kOptimizationHintsFetching, "optimization_guide_service_url");
   if (url.empty() || !GURL(url).SchemeIs(url::kHttpsScheme)) {
     if (!url.empty())
       LOG(WARNING)
@@ -128,27 +132,26 @@ GURL GetOptimizationGuideServiceURL() {
 }
 
 bool IsOptimizationHintsEnabled() {
-  return base::FeatureList::IsEnabled(features::kOptimizationHints);
+  return base::FeatureList::IsEnabled(kOptimizationHints);
 }
 
 bool IsHintsFetchingEnabled() {
-  return base::FeatureList::IsEnabled(features::kOptimizationHintsFetching);
+  return base::FeatureList::IsEnabled(kOptimizationHintsFetching);
 }
 
 bool IsOptimizationGuideKeyedServiceEnabled() {
-  return base::FeatureList::IsEnabled(features::kOptimizationGuideKeyedService);
+  return base::FeatureList::IsEnabled(kOptimizationGuideKeyedService);
 }
 
 int MaxServerBloomFilterByteSize() {
-  return base::GetFieldTrialParamByFeatureAsInt(features::kOptimizationHints,
-                                                "max_bloom_filter_byte_size",
-                                                250 * 1024 /* 250KB */);
+  return base::GetFieldTrialParamByFeatureAsInt(
+      kOptimizationHints, "max_bloom_filter_byte_size", 250 * 1024 /* 250KB */);
 }
 
 base::Optional<net::EffectiveConnectionType>
 GetMaxEffectiveConnectionTypeForNavigationHintsFetch() {
   std::string param_value = base::GetFieldTrialParamValueByFeature(
-      features::kOptimizationHintsFetching,
+      kOptimizationHintsFetching,
       "max_effective_connection_type_for_navigation_hints_fetch");
 
   // Use a default value.
@@ -162,5 +165,9 @@ base::TimeDelta GetHintsFetchRefreshDuration() {
   return base::TimeDelta::FromHours(72);
 }
 
+bool IsOptimizationTargetPredictionEnabled() {
+  return base::FeatureList::IsEnabled(kOptimizationTargetPrediction);
+}
+
 }  // namespace features
 }  // namespace optimization_guide

components/optimization_guide/optimization_guide_features.h

@@ -22,6 +22,7 @@ extern const base::Feature kOptimizationHintsExperiments;
 constexpr char kOptimizationHintsExperimentNameParam[] = "experiment_name";
 extern const base::Feature kOptimizationHintsFetching;
 extern const base::Feature kOptimizationGuideKeyedService;
+extern const base::Feature kOptimizationTargetPrediction;
 
 // The maximum number of hosts that can be stored in the
 // |kHintsFetcherTopHostBlacklist| dictionary pref when initialized. The top
@@ -86,6 +87,9 @@ GetMaxEffectiveConnectionTypeForNavigationHintsFetch();
 // GetHintsFetchRefreshDuration().
 base::TimeDelta GetHintsFetchRefreshDuration();
 
+// Returns true if optimization target prediction is enabled.
+bool IsOptimizationTargetPredictionEnabled();
+
 }  // namespace features
 }  // namespace optimization_guide