Separate out max ECT trigger from hint in hints manager CanApply logic

This makes it easier to refactor CanApply for the URL-keyed hints.
The new ShouldTargetNavigation in hints manager is temporary and will
be removed once prediction manager is fully live.

Bug: 1036490
Change-Id: I5855abc507ff1f12f9c392d234b9bfb71d9acb8c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1986250
Commit-Queue: Sophie Chang <sophiechang@chromium.org>
Reviewed-by: Michael Crouse <mcrouse@chromium.org>
Cr-Commit-Position: refs/heads/master@{#728276}

chrome/browser/optimization_guide/optimization_guide_hints_manager.cc

@@ -728,55 +728,64 @@ bool OptimizationGuideHintsManager::HasLoadedOptimizationFilter(
          blacklist_optimization_filters_.end();
 }
 
-void OptimizationGuideHintsManager::CanApplyOptimization(
+optimization_guide::OptimizationTargetDecision
+OptimizationGuideHintsManager::ShouldTargetNavigation(
+    content::NavigationHandle* navigation_handle,
+    optimization_guide::proto::OptimizationTarget optimization_target) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  if (optimization_target !=
+      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD) {
+    return optimization_guide::OptimizationTargetDecision::
+        kModelNotAvailableOnClient;
+  }
+
+  net::EffectiveConnectionType max_ect_trigger =
+      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_2G;
+
+  const auto& url = navigation_handle->GetURL();
+  if (url.has_host()) {
+    const auto& host = url.host();
+    // Check if we have a hint already loaded for this navigation.
+    const optimization_guide::proto::Hint* loaded_hint =
+        hint_cache_->GetHintIfLoaded(host);
+    const optimization_guide::proto::PageHint* matched_page_hint =
+        loaded_hint ? GetPageHintForNavigation(navigation_handle, loaded_hint)
+                    : nullptr;
+
+    if (matched_page_hint && matched_page_hint->has_max_ect_trigger()) {
+      max_ect_trigger = optimization_guide::ConvertProtoEffectiveConnectionType(
+          matched_page_hint->max_ect_trigger());
+    }
+  }
+
+  if (current_effective_connection_type_ !=
+          net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_UNKNOWN &&
+      current_effective_connection_type_ <= max_ect_trigger) {
+    return optimization_guide::OptimizationTargetDecision::kPageLoadMatches;
+  }
+
+  return optimization_guide::OptimizationTargetDecision::kPageLoadDoesNotMatch;
+}
+
+optimization_guide::OptimizationTypeDecision
+OptimizationGuideHintsManager::CanApplyOptimization(
     content::NavigationHandle* navigation_handle,
-    optimization_guide::proto::OptimizationTarget optimization_target,
     optimization_guide::proto::OptimizationType optimization_type,
-    optimization_guide::OptimizationTargetDecision*
-        optimization_target_decision,
-    optimization_guide::OptimizationTypeDecision* optimization_type_decision,
     optimization_guide::OptimizationMetadata* optimization_metadata) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DCHECK(optimization_target_decision);
-  DCHECK(optimization_type_decision);
 
   // Clear out optimization metadata if provided.
   if (optimization_metadata)
     (*optimization_metadata).previews_metadata.Clear();
 
-  *optimization_target_decision =
-      optimization_guide::OptimizationTargetDecision::kUnknown;
-  *optimization_type_decision =
-      optimization_guide::OptimizationTypeDecision::kUnknown;
-
-  bool should_update_optimization_target_decision = true;
-  if (optimization_target !=
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD) {
-    *optimization_target_decision = optimization_guide::
-        OptimizationTargetDecision::kModelNotAvailableOnClient;
-    should_update_optimization_target_decision = false;
-  }
-
   const auto& url = navigation_handle->GetURL();
   // If the URL doesn't have a host, we cannot query the hint for it, so just
   // return early.
-  if (!url.has_host()) {
-    if (should_update_optimization_target_decision) {
-      *optimization_target_decision =
-          optimization_guide::OptimizationTargetDecision::kPageLoadDoesNotMatch;
-    }
-    *optimization_type_decision =
-        optimization_guide::OptimizationTypeDecision::kNoHintAvailable;
-    return;
-  }
+  if (!url.has_host())
+    return optimization_guide::OptimizationTypeDecision::kNoHintAvailable;
   const auto& host = url.host();
 
-  net::EffectiveConnectionType max_ect_trigger =
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_2G;
-
-  // TODO(sophiechang): Maybe cache the page hint for a navigation ID so we
-  // don't have to iterate through all page hints every time this is called.
-
   // Check if we have a hint already loaded for this navigation.
   const optimization_guide::proto::Hint* loaded_hint =
       hint_cache_->GetHintIfLoaded(host);
@@ -792,28 +801,10 @@ void OptimizationGuideHintsManager::CanApplyOptimization(
   if (navigation_data) {
     navigation_data->set_has_hint_after_commit(has_hint_in_cache);
 
-    if (loaded_hint)
+    if (loaded_hint) {
       navigation_data->set_serialized_hint_version_string(
           loaded_hint->version());
     }
-
-  if (matched_page_hint && matched_page_hint->has_max_ect_trigger()) {
-    max_ect_trigger = optimization_guide::ConvertProtoEffectiveConnectionType(
-        matched_page_hint->max_ect_trigger());
-  }
-
-  if (should_update_optimization_target_decision) {
-    if (current_effective_connection_type_ ==
-            net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_UNKNOWN ||
-        current_effective_connection_type_ > max_ect_trigger) {
-      // The current network is not slow enough, so this navigation is likely
-      // not going to be painful.
-      *optimization_target_decision =
-          optimization_guide::OptimizationTargetDecision::kPageLoadDoesNotMatch;
-    } else {
-      *optimization_target_decision =
-          optimization_guide::OptimizationTargetDecision::kPageLoadMatches;
-    }
   }
 
   // Check if the URL should be filtered out if we have an optimization filter
@@ -825,22 +816,19 @@ void OptimizationGuideHintsManager::CanApplyOptimization(
     // if the URL matches anything in the filter.
     if (blacklist_optimization_filters_.find(optimization_type) !=
         blacklist_optimization_filters_.end()) {
-      *optimization_type_decision =
-          blacklist_optimization_filters_[optimization_type]->Matches(url)
+      return blacklist_optimization_filters_[optimization_type]->Matches(url)
                  ? optimization_guide::OptimizationTypeDecision::
                        kNotAllowedByOptimizationFilter
                  : optimization_guide::OptimizationTypeDecision::
                        kAllowedByOptimizationFilter;
-      return;
     }
 
     // Check if we had an optimization filter for it, but it was not loaded into
     // memory.
     if (optimization_types_with_filter_.find(optimization_type) !=
         optimization_types_with_filter_.end()) {
-      *optimization_type_decision = optimization_guide::
-          OptimizationTypeDecision::kHadOptimizationFilterButNotLoadedInTime;
-      return;
+      return optimization_guide::OptimizationTypeDecision::
+          kHadOptimizationFilterButNotLoadedInTime;
     }
   }
 
@@ -849,21 +837,18 @@ void OptimizationGuideHintsManager::CanApplyOptimization(
     // cache, we do not know what to do with the URL so just return.
     // Otherwise, we do have information, but we just do not know it yet.
     if (has_hint_in_cache) {
-      *optimization_type_decision = optimization_guide::
-          OptimizationTypeDecision::kHadHintButNotLoadedInTime;
-    } else if (IsHintBeingFetched(url.host())) {
-      *optimization_type_decision = optimization_guide::
-          OptimizationTypeDecision::kHintFetchStartedButNotAvailableInTime;
-    } else {
-      *optimization_type_decision =
-          optimization_guide::OptimizationTypeDecision::kNoHintAvailable;
+      return optimization_guide::OptimizationTypeDecision::
+          kHadHintButNotLoadedInTime;
     }
-    return;
+    if (IsHintBeingFetched(url.host())) {
+      return optimization_guide::OptimizationTypeDecision::
+          kHintFetchStartedButNotAvailableInTime;
+    }
+    return optimization_guide::OptimizationTypeDecision::kNoHintAvailable;
   }
+
   if (!matched_page_hint) {
-    *optimization_type_decision =
-        optimization_guide::OptimizationTypeDecision::kNoMatchingPageHint;
-    return;
+    return optimization_guide::OptimizationTypeDecision::kNoMatchingPageHint;
   }
 
   // Now check if we have any optimizations for it.
@@ -883,14 +868,11 @@ void OptimizationGuideHintsManager::CanApplyOptimization(
       (*optimization_metadata).previews_metadata =
           optimization.previews_metadata();
     }
-    *optimization_type_decision =
-        optimization_guide::OptimizationTypeDecision::kAllowedByHint;
-    return;
+    return optimization_guide::OptimizationTypeDecision::kAllowedByHint;
   }
 
   // We didn't find anything, so it's not allowed by the hint.
-  *optimization_type_decision =
-      optimization_guide::OptimizationTypeDecision::kNotAllowedByHint;
+  return optimization_guide::OptimizationTypeDecision::kNotAllowedByHint;
 }
 
 void OptimizationGuideHintsManager::OnEffectiveConnectionTypeChanged(

chrome/browser/optimization_guide/optimization_guide_hints_manager.h

@@ -104,15 +104,18 @@ class OptimizationGuideHintsManager
   bool HasLoadedOptimizationFilter(
       optimization_guide::proto::OptimizationType optimization_type);
 
-  // Populates |optimization_target_decision| and |optimization_type_decision|
-  // for whether the page load matches the given parameters.
-  void CanApplyOptimization(
+  // Returns the OptimizationTargetDecision based on the given parameters.
+  // TODO(crbug/1021364): Remove this method once the hints have nothing to do
+  // with predicting navigations.
+  optimization_guide::OptimizationTargetDecision ShouldTargetNavigation(
+      content::NavigationHandle* navigation_handle,
+      optimization_guide::proto::OptimizationTarget optimization_target);
+
+  // Returns the OptimizationTypeDecision based on the given parameters.
+  // |optimization_metadata| will be populated, if applicable.
+  optimization_guide::OptimizationTypeDecision CanApplyOptimization(
       content::NavigationHandle* navigation_handle,
-      optimization_guide::proto::OptimizationTarget optimization_target,
       optimization_guide::proto::OptimizationType optimization_type,
-      optimization_guide::OptimizationTargetDecision*
-          optimization_target_decision,
-      optimization_guide::OptimizationTypeDecision* optimization_type_decision,
       optimization_guide::OptimizationMetadata* optimization_metadata);
 
   // Clears fetched hints from |hint_cache_|.

chrome/browser/optimization_guide/optimization_guide_hints_manager_unittest.cc

@@ -1021,26 +1021,17 @@ TEST_F(OptimizationGuideHintsManagerTest, CanApplyOptimizationUrlWithNoHost) {
                                   kBlackBlacklistBloomFilterNumBits, &config);
   ProcessHints(config, "1.0.0.0");
 
-  // Set ECT estimate to be "painful".
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           GURL("urlwithnohost"));
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
           navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
           optimization_guide::proto::LITE_PAGE_REDIRECT,
-      &optimization_target_decision, &optimization_type_decision,
           /*optimization_metadata=*/nullptr);
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(
-      optimization_guide::OptimizationTargetDecision::kPageLoadDoesNotMatch,
-      optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNoHintAvailable,
             optimization_type_decision);
   // Make sure navigation data is populated correctly.
@@ -1054,7 +1045,10 @@ TEST_F(OptimizationGuideHintsManagerTest, CanApplyOptimizationUrlWithNoHost) {
 }
 
 TEST_F(OptimizationGuideHintsManagerTest,
-       CanApplyOptimizationHasFilterForTypeButNotLoadedYet) {
+       ShouldTargetNavigationUrlWithNoHostECTSlowerThanDefault) {
+  hints_manager()->RegisterOptimizationTypes(
+      {optimization_guide::proto::LITE_PAGE_REDIRECT});
+
   optimization_guide::proto::Configuration config;
   optimization_guide::BloomFilter blacklist_bloom_filter(
       kBlackBlacklistBloomFilterNumHashFunctions,
@@ -1068,23 +1062,79 @@ TEST_F(OptimizationGuideHintsManagerTest,
 
   // Set ECT estimate to be "painful".
   hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
+      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_2G);
+  std::unique_ptr<content::MockNavigationHandle> navigation_handle =
+      CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
+          GURL("urlwithnohost"));
+
+  optimization_guide::OptimizationTargetDecision optimization_target_decision =
+      hints_manager()->ShouldTargetNavigation(
+          navigation_handle.get(),
+          optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD);
+
+  // Make sure decisions are logged correctly.
+  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
+            optimization_target_decision);
+}
+
+TEST_F(OptimizationGuideHintsManagerTest,
+       ShouldTargetNavigationUrlWithNoHostECTFasterThanDefault) {
+  hints_manager()->RegisterOptimizationTypes(
+      {optimization_guide::proto::LITE_PAGE_REDIRECT});
+
+  optimization_guide::proto::Configuration config;
+  optimization_guide::BloomFilter blacklist_bloom_filter(
+      kBlackBlacklistBloomFilterNumHashFunctions,
+      kBlackBlacklistBloomFilterNumBits);
+  PopulateBlackBlacklistBloomFilter(&blacklist_bloom_filter);
+  AddBlacklistBloomFilterToConfig(optimization_guide::proto::LITE_PAGE_REDIRECT,
+                                  blacklist_bloom_filter,
+                                  kBlackBlacklistBloomFilterNumHashFunctions,
+                                  kBlackBlacklistBloomFilterNumBits, &config);
+  ProcessHints(config, "1.0.0.0");
+
+  // Set ECT estimate to be "fast".
+  hints_manager()->OnEffectiveConnectionTypeChanged(
+      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_3G);
+  std::unique_ptr<content::MockNavigationHandle> navigation_handle =
+      CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
+          GURL("urlwithnohost"));
+
+  optimization_guide::OptimizationTargetDecision optimization_target_decision =
+      hints_manager()->ShouldTargetNavigation(
+          navigation_handle.get(),
+          optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD);
+
+  // Make sure decisions are logged correctly.
+  EXPECT_EQ(
+      optimization_guide::OptimizationTargetDecision::kPageLoadDoesNotMatch,
+      optimization_target_decision);
+}
+
+TEST_F(OptimizationGuideHintsManagerTest,
+       CanApplyOptimizationHasFilterForTypeButNotLoadedYet) {
+  optimization_guide::proto::Configuration config;
+  optimization_guide::BloomFilter blacklist_bloom_filter(
+      kBlackBlacklistBloomFilterNumHashFunctions,
+      kBlackBlacklistBloomFilterNumBits);
+  PopulateBlackBlacklistBloomFilter(&blacklist_bloom_filter);
+  AddBlacklistBloomFilterToConfig(optimization_guide::proto::LITE_PAGE_REDIRECT,
+                                  blacklist_bloom_filter,
+                                  kBlackBlacklistBloomFilterNumHashFunctions,
+                                  kBlackBlacklistBloomFilterNumBits, &config);
+  ProcessHints(config, "1.0.0.0");
+
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           GURL("https://whatever.com/123"));
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
           navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
           optimization_guide::proto::LITE_PAGE_REDIRECT,
-      &optimization_target_decision, &optimization_type_decision,
           /*optimization_metadata=*/nullptr);
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::
                 kHadOptimizationFilterButNotLoadedInTime,
             optimization_type_decision);
@@ -1114,25 +1164,17 @@ TEST_F(OptimizationGuideHintsManagerTest,
                                   kBlackBlacklistBloomFilterNumBits, &config);
   ProcessHints(config, "1.0.0.0");
 
-  // Set ECT estimate to be "painful".
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           GURL("https://m.black.com/123"));
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
           navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
           optimization_guide::proto::LITE_PAGE_REDIRECT,
-      &optimization_target_decision, &optimization_type_decision,
           /*optimization_metadata=*/nullptr);
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::
                 kNotAllowedByOptimizationFilter,
             optimization_type_decision);
@@ -1162,25 +1204,17 @@ TEST_F(OptimizationGuideHintsManagerTest,
                                   kBlackBlacklistBloomFilterNumBits, &config);
   ProcessHints(config, "1.0.0.0");
 
-  // Set ECT estimate to be "painful".
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           GURL("https://whatever.com/123"));
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
           navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
           optimization_guide::proto::LITE_PAGE_REDIRECT,
-      &optimization_target_decision, &optimization_type_decision,
           /*optimization_metadata=*/nullptr);
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::
                 kAllowedByOptimizationFilter,
             optimization_type_decision);
@@ -1194,7 +1228,7 @@ TEST_F(OptimizationGuideHintsManagerTest,
   EXPECT_FALSE(navigation_data->has_page_hint_value());
 }
 
-TEST_F(OptimizationGuideHintsManagerTest, CanApplyOptimizationNoECTEstimate) {
+TEST_F(OptimizationGuideHintsManagerTest, ShouldTargetNavigationNoECTEstimate) {
   hints_manager()->RegisterOptimizationTypes(
       {optimization_guide::proto::LITE_PAGE_REDIRECT});
 
@@ -1216,34 +1250,19 @@ TEST_F(OptimizationGuideHintsManagerTest, CanApplyOptimizationNoECTEstimate) {
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           GURL("https://whatever.com/123"));
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
-  hints_manager()->CanApplyOptimization(
+  optimization_guide::OptimizationTargetDecision optimization_target_decision =
+      hints_manager()->ShouldTargetNavigation(
           navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::LITE_PAGE_REDIRECT,
-      &optimization_target_decision, &optimization_type_decision,
-      /*optimization_metadata=*/nullptr);
+          optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD);
 
   // Make sure decisions are logged correctly.
   EXPECT_EQ(
       optimization_guide::OptimizationTargetDecision::kPageLoadDoesNotMatch,
       optimization_target_decision);
-  EXPECT_EQ(optimization_guide::OptimizationTypeDecision::
-                kAllowedByOptimizationFilter,
-            optimization_type_decision);
-  // Make sure navigation data is populated correctly.
-  OptimizationGuideNavigationData* navigation_data =
-      OptimizationGuideNavigationData::GetFromNavigationHandle(
-          navigation_handle.get());
-  EXPECT_EQ(base::nullopt, navigation_data->has_hint_before_commit());
-  EXPECT_FALSE(navigation_data->has_hint_after_commit().value());
-  EXPECT_EQ(base::nullopt, navigation_data->serialized_hint_version_string());
-  EXPECT_FALSE(navigation_data->has_page_hint_value());
 }
 
 TEST_F(OptimizationGuideHintsManagerTest,
-       CanApplyOptimizationNoHintToTriggerHigherThan2G) {
+       ShouldTargetNavigationNoHintToTriggerHigherThan2G) {
   hints_manager()->RegisterOptimizationTypes(
       {optimization_guide::proto::LITE_PAGE_REDIRECT});
 
@@ -1265,39 +1284,21 @@ TEST_F(OptimizationGuideHintsManagerTest,
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           GURL("https://whatever.com/123"));
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
-  hints_manager()->CanApplyOptimization(
+  optimization_guide::OptimizationTargetDecision optimization_target_decision =
+      hints_manager()->ShouldTargetNavigation(
           navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::LITE_PAGE_REDIRECT,
-      &optimization_target_decision, &optimization_type_decision,
-      /*optimization_metadata=*/nullptr);
+          optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD);
 
   // Make sure decisions are logged correctly.
   EXPECT_EQ(
       optimization_guide::OptimizationTargetDecision::kPageLoadDoesNotMatch,
       optimization_target_decision);
-  EXPECT_EQ(optimization_guide::OptimizationTypeDecision::
-                kAllowedByOptimizationFilter,
-            optimization_type_decision);
-  // Make sure navigation data is populated correctly.
-  OptimizationGuideNavigationData* navigation_data =
-      OptimizationGuideNavigationData::GetFromNavigationHandle(
-          navigation_handle.get());
-  EXPECT_EQ(base::nullopt, navigation_data->has_hint_before_commit());
-  EXPECT_FALSE(navigation_data->has_hint_after_commit().value());
-  EXPECT_EQ(base::nullopt, navigation_data->serialized_hint_version_string());
-  EXPECT_FALSE(navigation_data->has_page_hint_value());
 }
 
 TEST_F(OptimizationGuideHintsManagerTest,
        CanApplyOptimizationAndPopulatesMetadataWithFirstOptThatMatchesNoExp) {
   InitializeWithDefaultConfig("1.0.0.0");
 
-  // Set ECT estimate so hint is activated.
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           url_with_hints());
@@ -1306,19 +1307,14 @@ TEST_F(OptimizationGuideHintsManagerTest,
                                                run_loop.QuitClosure());
   run_loop.Run();
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
   optimization_guide::OptimizationMetadata optimization_metadata;
-  hints_manager()->CanApplyOptimization(
-      navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::NOSCRIPT, &optimization_target_decision,
-      &optimization_type_decision, &optimization_metadata);
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
+      hints_manager()->CanApplyOptimization(navigation_handle.get(),
+                                            optimization_guide::proto::NOSCRIPT,
+                                            &optimization_metadata);
   EXPECT_EQ(1234, optimization_metadata.previews_metadata.inflation_percent());
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint,
             optimization_type_decision);
   // Make sure navigation data is populated correctly.
@@ -1332,7 +1328,7 @@ TEST_F(OptimizationGuideHintsManagerTest,
 }
 
 TEST_F(OptimizationGuideHintsManagerTest,
-       CanApplyOptimizationHasHintButNotSlowEnough) {
+       ShouldTargetNavigationButNotSlowEnough) {
   InitializeWithDefaultConfig("1.0.0.0");
 
   // Set ECT estimate so hint is activated.
@@ -1346,34 +1342,19 @@ TEST_F(OptimizationGuideHintsManagerTest,
                                                run_loop.QuitClosure());
   run_loop.Run();
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
-  optimization_guide::OptimizationMetadata optimization_metadata;
-  hints_manager()->CanApplyOptimization(
+  optimization_guide::OptimizationTargetDecision optimization_target_decision =
+      hints_manager()->ShouldTargetNavigation(
           navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::NOSCRIPT, &optimization_target_decision,
-      &optimization_type_decision, &optimization_metadata);
-  EXPECT_EQ(1234, optimization_metadata.previews_metadata.inflation_percent());
+          optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD);
 
   // Make sure decisions are logged correctly.
   EXPECT_EQ(
       optimization_guide::OptimizationTargetDecision::kPageLoadDoesNotMatch,
       optimization_target_decision);
-  EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint,
-            optimization_type_decision);
-  // Make sure navigation data is populated correctly.
-  OptimizationGuideNavigationData* navigation_data =
-      OptimizationGuideNavigationData::GetFromNavigationHandle(
-          navigation_handle.get());
-  EXPECT_TRUE(navigation_data->has_hint_before_commit().value());
-  EXPECT_TRUE(navigation_data->has_hint_after_commit().value());
-  EXPECT_EQ("someversion", navigation_data->serialized_hint_version_string());
-  ASSERT_TRUE(navigation_data->page_hint());
 }
 
 TEST_F(OptimizationGuideHintsManagerTest,
-       CanApplyOptimizationWithNonPainfulPageLoadTarget) {
+       ShouldTargetNavigationWithNonPainfulPageLoadTarget) {
   InitializeWithDefaultConfig("1.0.0.0");
 
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
@@ -1384,40 +1365,21 @@ TEST_F(OptimizationGuideHintsManagerTest,
                                                run_loop.QuitClosure());
   run_loop.Run();
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
-  optimization_guide::OptimizationMetadata optimization_metadata;
-  hints_manager()->CanApplyOptimization(
+  optimization_guide::OptimizationTargetDecision optimization_target_decision =
+      hints_manager()->ShouldTargetNavigation(
           navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_UNKNOWN,
-      optimization_guide::proto::NOSCRIPT, &optimization_target_decision,
-      &optimization_type_decision, &optimization_metadata);
-  // Make sure metadata is populated.
-  EXPECT_EQ(1234, optimization_metadata.previews_metadata.inflation_percent());
+          optimization_guide::proto::OPTIMIZATION_TARGET_UNKNOWN);
 
   // Make sure decisions are logged correctly.
   EXPECT_EQ(optimization_guide::OptimizationTargetDecision::
                 kModelNotAvailableOnClient,
             optimization_target_decision);
-  EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint,
-            optimization_type_decision);
-  // Make sure navigation data is populated correctly.
-  OptimizationGuideNavigationData* navigation_data =
-      OptimizationGuideNavigationData::GetFromNavigationHandle(
-          navigation_handle.get());
-  EXPECT_TRUE(navigation_data->has_hint_before_commit().value());
-  EXPECT_TRUE(navigation_data->has_hint_after_commit().value());
-  EXPECT_EQ("someversion", navigation_data->serialized_hint_version_string());
-  EXPECT_TRUE(navigation_data->has_page_hint_value());
 }
 
 TEST_F(OptimizationGuideHintsManagerTest,
        CanApplyOptimizationHasPageHintButNoMatchingOptType) {
   InitializeWithDefaultConfig("1.0.0.0");
 
-  // Set ECT estimate so hint is activated.
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           url_with_hints());
@@ -1426,19 +1388,12 @@ TEST_F(OptimizationGuideHintsManagerTest,
                                                run_loop.QuitClosure());
   run_loop.Run();
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
-  optimization_guide::OptimizationMetadata optimization_metadata;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
-      navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::DEFER_ALL_SCRIPT,
-      &optimization_target_decision, &optimization_type_decision,
+          navigation_handle.get(), optimization_guide::proto::DEFER_ALL_SCRIPT,
           /*optimization_metadata=*/nullptr);
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNotAllowedByHint,
             optimization_type_decision);
   // Make sure navigation data is populated correctly.
@@ -1455,9 +1410,6 @@ TEST_F(OptimizationGuideHintsManagerTest,
        CanApplyOptimizationUsesCachedPageHintFromNavigationData) {
   InitializeWithDefaultConfig("1.0.0.0");
 
-  // Set ECT estimate so hint is activated.
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           url_with_hints());
@@ -1473,19 +1425,12 @@ TEST_F(OptimizationGuideHintsManagerTest,
           navigation_handle.get());
   navigation_data->set_page_hint(nullptr);
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
-  optimization_guide::OptimizationMetadata optimization_metadata;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
-      navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::DEFER_ALL_SCRIPT,
-      &optimization_target_decision, &optimization_type_decision,
+          navigation_handle.get(), optimization_guide::proto::DEFER_ALL_SCRIPT,
           /*optimization_metadata=*/nullptr);
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNoMatchingPageHint,
             optimization_type_decision);
   // Make sure navigation data is populated correctly.
@@ -1542,19 +1487,12 @@ TEST_F(OptimizationGuideHintsManagerTest,
                                                run_loop.QuitClosure());
   run_loop.Run();
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
-  optimization_guide::OptimizationMetadata optimization_metadata;
-  hints_manager()->CanApplyOptimization(
-      navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::NOSCRIPT, &optimization_target_decision,
-      &optimization_type_decision,
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
+      hints_manager()->CanApplyOptimization(navigation_handle.get(),
+                                            optimization_guide::proto::NOSCRIPT,
                                             /*optimization_metadata=*/nullptr);
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNoMatchingPageHint,
             optimization_type_decision);
   // Make sure navigation data is populated correctly.
@@ -1571,27 +1509,19 @@ TEST_F(OptimizationGuideHintsManagerTest,
        CanApplyOptimizationNoHintForNavigationMetadataClearedAnyway) {
   InitializeWithDefaultConfig("1.0.0.0");
 
-  // Set ECT estimate so hint is activated.
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           GURL("https://nohint.com"));
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
   optimization_guide::OptimizationMetadata optimization_metadata;
   optimization_metadata.previews_metadata.set_inflation_percent(12345);
-  hints_manager()->CanApplyOptimization(
-      navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::NOSCRIPT, &optimization_target_decision,
-      &optimization_type_decision, &optimization_metadata);
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
+      hints_manager()->CanApplyOptimization(navigation_handle.get(),
+                                            optimization_guide::proto::NOSCRIPT,
+                                            &optimization_metadata);
   EXPECT_EQ(0, optimization_metadata.previews_metadata.inflation_percent());
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNoHintAvailable,
             optimization_type_decision);
   // Make sure navigation data is populated correctly.
@@ -1608,25 +1538,17 @@ TEST_F(OptimizationGuideHintsManagerTest,
        CanApplyOptimizationHasHintInCacheButNotLoaded) {
   InitializeWithDefaultConfig("1.0.0.0");
 
-  // Set ECT estimate so hint is activated.
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           url_with_hints());
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
   optimization_guide::OptimizationMetadata optimization_metadata;
-  hints_manager()->CanApplyOptimization(
-      navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::NOSCRIPT, &optimization_target_decision,
-      &optimization_type_decision, &optimization_metadata);
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
+      hints_manager()->CanApplyOptimization(navigation_handle.get(),
+                                            optimization_guide::proto::NOSCRIPT,
+                                            &optimization_metadata);
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(
       optimization_guide::OptimizationTypeDecision::kHadHintButNotLoadedInTime,
       optimization_type_decision);
@@ -1675,22 +1597,13 @@ TEST_F(OptimizationGuideHintsManagerTest,
                                                run_loop.QuitClosure());
   run_loop.Run();
 
-  // Set ECT estimate so hint is activated.
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
-
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
           navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
           optimization_guide::proto::LITE_PAGE_REDIRECT,
-      &optimization_target_decision, &optimization_type_decision,
           /*optimization_metadata=*/nullptr);
 
   // Make sure decision points logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::
                 kNotAllowedByOptimizationFilter,
             optimization_type_decision);
@@ -1741,21 +1654,13 @@ TEST_F(OptimizationGuideHintsManagerTest,
                                                run_loop.QuitClosure());
   run_loop.Run();
 
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_3G);
-
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
           navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
           optimization_guide::proto::LITE_PAGE_REDIRECT,
-      &optimization_target_decision, &optimization_type_decision,
           /*optimization_metadata=*/nullptr);
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::
                 kAllowedByOptimizationFilter,
             optimization_type_decision);
@@ -1786,9 +1691,6 @@ TEST_F(OptimizationGuideHintsManagerExperimentTest,
        CanApplyOptimizationAndPopulatesMetadataWithFirstOptThatMatchesWithExp) {
   InitializeWithDefaultConfig("1.0.0.0");
 
-  // Set ECT estimate so hint is activated.
-  hints_manager()->OnEffectiveConnectionTypeChanged(
-      net::EffectiveConnectionType::EFFECTIVE_CONNECTION_TYPE_SLOW_2G);
   std::unique_ptr<content::MockNavigationHandle> navigation_handle =
       CreateMockNavigationHandleWithOptimizationGuideWebContentsObserver(
           url_with_hints());
@@ -1797,19 +1699,14 @@ TEST_F(OptimizationGuideHintsManagerExperimentTest,
                                                run_loop.QuitClosure());
   run_loop.Run();
 
-  optimization_guide::OptimizationTargetDecision optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
   optimization_guide::OptimizationMetadata optimization_metadata;
-  hints_manager()->CanApplyOptimization(
-      navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::NOSCRIPT, &optimization_target_decision,
-      &optimization_type_decision, &optimization_metadata);
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
+      hints_manager()->CanApplyOptimization(navigation_handle.get(),
+                                            optimization_guide::proto::NOSCRIPT,
+                                            &optimization_metadata);
   EXPECT_EQ(12345, optimization_metadata.previews_metadata.inflation_percent());
 
   // Make sure decisions are logged correctly.
-  EXPECT_EQ(optimization_guide::OptimizationTargetDecision::kPageLoadMatches,
-            optimization_target_decision);
   EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint,
             optimization_type_decision);
   // Make sure navigation data is populated correctly.
@@ -2255,13 +2152,10 @@ TEST_F(OptimizationGuideHintsManagerFetchingTest,
           url_without_hints());
   hints_manager()->OnNavigationStartOrRedirect(navigation_handle.get(),
                                                base::DoNothing());
-  optimization_guide::OptimizationTargetDecision unused_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
-      navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::DEFER_ALL_SCRIPT, &unused_target_decision,
-      &optimization_type_decision, /*optimization_metadata=*/nullptr);
+          navigation_handle.get(), optimization_guide::proto::DEFER_ALL_SCRIPT,
+          /*optimization_metadata=*/nullptr);
 
   EXPECT_EQ(optimization_type_decision,
             optimization_guide::OptimizationTypeDecision::
@@ -2287,13 +2181,10 @@ TEST_F(OptimizationGuideHintsManagerFetchingTest,
                                                base::DoNothing());
   RunUntilIdle();
 
-  optimization_guide::OptimizationTargetDecision unused_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
-      navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::DEFER_ALL_SCRIPT, &unused_target_decision,
-      &optimization_type_decision, /*optimization_metadata=*/nullptr);
+          navigation_handle.get(), optimization_guide::proto::DEFER_ALL_SCRIPT,
+          /*optimization_metadata=*/nullptr);
 
   EXPECT_EQ(optimization_type_decision,
             optimization_guide::OptimizationTypeDecision::kNoHintAvailable);
@@ -2318,13 +2209,10 @@ TEST_F(OptimizationGuideHintsManagerFetchingTest,
                                                base::DoNothing());
   RunUntilIdle();
 
-  optimization_guide::OptimizationTargetDecision unused_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
       hints_manager()->CanApplyOptimization(
-      navigation_handle.get(),
-      optimization_guide::proto::OPTIMIZATION_TARGET_PAINFUL_PAGE_LOAD,
-      optimization_guide::proto::DEFER_ALL_SCRIPT, &unused_target_decision,
-      &optimization_type_decision, /*optimization_metadata=*/nullptr);
+          navigation_handle.get(), optimization_guide::proto::DEFER_ALL_SCRIPT,
+          /*optimization_metadata=*/nullptr);
 
   EXPECT_EQ(optimization_type_decision,
             optimization_guide::OptimizationTypeDecision::kNoHintAvailable);

chrome/browser/optimization_guide/optimization_guide_keyed_service.cc

@@ -210,13 +210,8 @@ OptimizationGuideKeyedService::ShouldTargetNavigation(
         navigation_handle, optimization_target);
   } else {
     DCHECK(hints_manager_);
-    optimization_guide::OptimizationTypeDecision
-        unused_optimization_type_decision;
-    hints_manager_->CanApplyOptimization(
-        navigation_handle, optimization_target,
-        optimization_guide::proto::OPTIMIZATION_NONE,
-        &optimization_target_decision, &unused_optimization_type_decision,
-        /*optimization_metadata=*/nullptr);
+    optimization_target_decision = hints_manager_->ShouldTargetNavigation(
+        navigation_handle, optimization_target);
   }
 
   LogOptimizationTargetDecision(navigation_handle, optimization_target,
@@ -232,13 +227,9 @@ OptimizationGuideKeyedService::CanApplyOptimization(
     optimization_guide::OptimizationMetadata* optimization_metadata) {
   DCHECK(hints_manager_);
 
-  optimization_guide::OptimizationTargetDecision
-      unused_optimization_target_decision;
-  optimization_guide::OptimizationTypeDecision optimization_type_decision;
-  hints_manager_->CanApplyOptimization(
-      navigation_handle, optimization_guide::proto::OPTIMIZATION_TARGET_UNKNOWN,
-      optimization_type, &unused_optimization_target_decision,
-      &optimization_type_decision, optimization_metadata);
+  optimization_guide::OptimizationTypeDecision optimization_type_decision =
+      hints_manager_->CanApplyOptimization(navigation_handle, optimization_type,
+                                           optimization_metadata);
 
   LogOptimizationTypeDecision(navigation_handle, optimization_type,
                               optimization_type_decision);