Improve browser test functionality for Opt Guide clients.

This change adds a function that optimization guide clients can use to
insert hints into the guide without knowledge of how the hints are
fetched and stored.


Bug: 1035698, 1074020
Change-Id: I30134ddafd93e4b0b564ff1a52f95e6943819b66
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2163577
Commit-Queue: Michael Crouse <mcrouse@chromium.org>
Auto-Submit: Michael Crouse <mcrouse@chromium.org>
Reviewed-by: Megan Jablonski <megjablon@chromium.org>
Reviewed-by: Sophie Chang <sophiechang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#762537}

chrome/browser/optimization_guide/optimization_guide_hints_manager.cc

@@ -42,6 +42,7 @@
 #include "components/optimization_guide/optimization_guide_service.h"
 #include "components/optimization_guide/optimization_guide_store.h"
 #include "components/optimization_guide/optimization_guide_switches.h"
+#include "components/optimization_guide/optimization_metadata.h"
 #include "components/optimization_guide/top_host_provider.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
@@ -1337,3 +1338,36 @@ void OptimizationGuideHintsManager::ClearFetchedHints() {
   optimization_guide::HintsFetcher::ClearHostsSuccessfullyFetched(
       pref_service_);
 }
+
+void OptimizationGuideHintsManager::AddHintForTesting(
+    const GURL& url,
+    optimization_guide::proto::OptimizationType optimization_type,
+    const base::Optional<optimization_guide::OptimizationMetadata>& metadata) {
+  std::unique_ptr<optimization_guide::proto::Hint> hint =
+      std::make_unique<optimization_guide::proto::Hint>();
+  hint->set_key(url.spec());
+  optimization_guide::proto::PageHint* page_hint = hint->add_page_hints();
+  page_hint->set_page_pattern("*");
+  optimization_guide::proto::Optimization* optimization =
+      page_hint->add_whitelisted_optimizations();
+  optimization->set_optimization_type(optimization_type);
+  if (!metadata) {
+    hint_cache_->AddHintForTesting(url, std::move(hint));
+    return;
+  }
+  if (metadata->previews_metadata()) {
+    *optimization->mutable_previews_metadata() = *metadata->previews_metadata();
+  } else if (metadata->loading_predictor_metadata()) {
+    *optimization->mutable_loading_predictor_metadata() =
+        *metadata->loading_predictor_metadata();
+  } else if (metadata->performance_hints_metadata()) {
+    *optimization->mutable_performance_hints_metadata() =
+        *metadata->performance_hints_metadata();
+  } else if (metadata->public_image_metadata()) {
+    *optimization->mutable_public_image_metadata() =
+        *metadata->public_image_metadata();
+  } else {
+    NOTREACHED();
+  }
+  hint_cache_->AddHintForTesting(url, std::move(hint));
+}

chrome/browser/optimization_guide/optimization_guide_hints_manager.h

@@ -50,6 +50,7 @@ namespace optimization_guide {
 class HintCache;
 class HintsFetcherFactory;
 class OptimizationFilter;
+class OptimizationMetadata;
 class OptimizationGuideService;
 enum class OptimizationTargetDecision;
 enum class OptimizationTypeDecision;
@@ -162,6 +163,12 @@ class OptimizationGuideHintsManager
   void OnNavigationFinish(const std::vector<GURL>& navigation_redirect_chain,
                           OptimizationGuideNavigationData* navigation_data);
 
+  // Add hints to the cache with the provided metadata. For testing only.
+  void AddHintForTesting(
+      const GURL& url,
+      optimization_guide::proto::OptimizationType optimization_type,
+      const base::Optional<optimization_guide::OptimizationMetadata>& metadata);
+
  private:
   FRIEND_TEST_ALL_PREFIXES(OptimizationGuideHintsManagerTest, IsGoogleURL);
   FRIEND_TEST_ALL_PREFIXES(OptimizationGuideHintsManagerFetchingTest,

chrome/browser/optimization_guide/optimization_guide_keyed_service.cc

@@ -8,6 +8,7 @@
 #include "base/callback_forward.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/optional.h"
 #include "chrome/browser/optimization_guide/optimization_guide_hints_manager.h"
 #include "chrome/browser/optimization_guide/optimization_guide_navigation_data.h"
 #include "chrome/browser/optimization_guide/optimization_guide_session_statistic.h"
@@ -262,6 +263,16 @@ void OptimizationGuideKeyedService::CanApplyOptimizationAsync(
       navigation_handle->GetURL(), optimization_type, std::move(callback));
 }
 
+void OptimizationGuideKeyedService::AddHintForTesting(
+    const GURL& url,
+    optimization_guide::proto::OptimizationType optimization_type,
+    const base::Optional<optimization_guide::OptimizationMetadata>& metadata) {
+  if (!hints_manager_)
+    return;
+
+  hints_manager_->AddHintForTesting(url, optimization_type, metadata);
+}
+
 void OptimizationGuideKeyedService::ClearData() {
   if (hints_manager_)
     hints_manager_->ClearFetchedHints();

chrome/browser/optimization_guide/optimization_guide_keyed_service.h

@@ -98,6 +98,13 @@ class OptimizationGuideKeyedService
       optimization_guide::proto::OptimizationType optimization_type,
       optimization_guide::OptimizationGuideDecisionCallback callback) override;
 
+  // Adds hints for a URL with provided metadata to the optimziation guide.
+  // For testing purposes only.
+  void AddHintForTesting(
+      const GURL& url,
+      optimization_guide::proto::OptimizationType optimization_type,
+      const base::Optional<optimization_guide::OptimizationMetadata>& metadata);
+
   // KeyedService implementation:
   void Shutdown() override;
 

chrome/browser/performance_hints/performance_hints_observer_unittest.cc

@@ -30,7 +30,6 @@ namespace {
 const char kTestUrl[] = "http://www.test.com/";
 }  // namespace
 
-// TODO(crbug/1035698): Migrate to TestOptimizationGuideDecider when provided.
 class MockOptimizationGuideKeyedService : public OptimizationGuideKeyedService {
  public:
   explicit MockOptimizationGuideKeyedService(
@@ -42,15 +41,6 @@ class MockOptimizationGuideKeyedService : public OptimizationGuideKeyedService {
       RegisterOptimizationTypesAndTargets,
       void(const std::vector<optimization_guide::proto::OptimizationType>&,
            const std::vector<optimization_guide::proto::OptimizationTarget>&));
-  MOCK_METHOD2(ShouldTargetNavigation,
-               optimization_guide::OptimizationGuideDecision(
-                   content::NavigationHandle*,
-                   optimization_guide::proto::OptimizationTarget));
-  MOCK_METHOD3(CanApplyOptimization,
-               optimization_guide::OptimizationGuideDecision(
-                   content::NavigationHandle*,
-                   optimization_guide::proto::OptimizationType,
-                   optimization_guide::OptimizationMetadata*));
   MOCK_METHOD3(CanApplyOptimizationAsync,
                void(content::NavigationHandle*,
                     optimization_guide::proto::OptimizationType,

components/optimization_guide/hint_cache.cc

@@ -302,4 +302,14 @@ void HintCache::SetClockForTesting(const base::Clock* clock) {
   clock_ = clock;
 }
 
+void HintCache::AddHintForTesting(const GURL& url,
+                                  std::unique_ptr<proto::Hint> hint) {
+  if (IsValidURLForURLKeyedHint(url)) {
+    url_keyed_hint_cache_.Put(
+        url.spec(),
+        std::make_unique<MemoryHint>(
+            base::Time::Now() + base::TimeDelta::FromDays(7), std::move(hint)));
+  }
+}
+
 }  // namespace optimization_guide

components/optimization_guide/hint_cache.h

@@ -133,6 +133,9 @@ class HintCache {
   // Override |clock_| for testing.
   void SetClockForTesting(const base::Clock* clock);
 
+  // Add hint to the URL-keyed cache. For testing only.
+  void AddHintForTesting(const GURL& gurl, std::unique_ptr<proto::Hint> hint);
+
  private:
   using HostKeyedHintCache =
       base::HashingMRUCache<OptimizationGuideStore::EntryKey,

components/optimization_guide/optimization_guide_decider.h

@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "base/callback_forward.h"
+#include "base/optional.h"
 #include "components/optimization_guide/optimization_metadata.h"
 #include "components/optimization_guide/proto/hints.pb.h"
 #include "components/optimization_guide/proto/models.pb.h"
@@ -16,6 +17,8 @@ namespace content {
 class NavigationHandle;
 }  // namespace content
 
+class GURL;
+
 namespace optimization_guide {
 
 // Represents the decision made by the optimization guide.

components/optimization_guide/optimization_metadata.h

@@ -12,6 +12,10 @@ namespace optimization_guide {
 
 // Contains metadata that could be attached to an optimization provided by the
 // Optimization Guide.
+//
+// Note: If a new optimization metadata is added,
+// |OptimizationGuideHintsManager::AddHintsForTesting| should be updated
+// to handle it.
 class OptimizationMetadata {
  public:
   OptimizationMetadata();

components/optimization_guide/test_hints_component_creator.cc

@@ -212,36 +212,6 @@ TestHintsComponentCreator::CreateHintsComponentInfoWithMixPageHints(
   return WriteConfigToFileAndReturnHintsComponentInfo(config);
 }
 
-optimization_guide::HintsComponentInfo
-TestHintsComponentCreator::CreateHintsComponentInfoWithPublicImageHints(
-    const std::vector<std::string>& page_hint_host_suffixes,
-    const std::string& page_pattern,
-    const std::vector<std::string>& public_image_urls) {
-  optimization_guide::proto::Configuration config;
-  for (const auto& page_hint_site : page_hint_host_suffixes) {
-    optimization_guide::proto::Hint* hint = config.add_hints();
-    hint->set_key(page_hint_site);
-    hint->set_key_representation(optimization_guide::proto::HOST_SUFFIX);
-    hint->set_version(GetDefaultHintVersionString());
-
-    optimization_guide::proto::PageHint* page_hint = hint->add_page_hints();
-    page_hint->set_page_pattern(page_pattern);
-
-    optimization_guide::proto::Optimization* optimization =
-        page_hint->add_whitelisted_optimizations();
-    optimization->set_optimization_type(
-        optimization_guide::proto::COMPRESS_PUBLIC_IMAGES);
-
-    optimization_guide::proto::PublicImageMetadata* public_image_metadata =
-        optimization->mutable_public_image_metadata();
-    for (auto url : public_image_urls) {
-      public_image_metadata->add_url(url);
-    }
-  }
-
-  return WriteConfigToFileAndReturnHintsComponentInfo(config);
-}
-
 base::FilePath TestHintsComponentCreator::GetFilePath(
     std::string file_path_suffix) {
   base::ScopedAllowBlockingForTesting allow_blocking;

components/optimization_guide/test_hints_component_creator.h

@@ -67,16 +67,6 @@ class TestHintsComponentCreator {
       const std::vector<std::string>& experimental_resource_patterns,
       const std::vector<std::string>& default_resource_patterns);
 
-  // Creates component data based on |whitelisted_host_suffixes| and
-  // |page_pattern| with page hints for type |optimization_type| blocking
-  // resources specified by |resource_patterns|, and returns the
-  // HintsComponentInfo for it.
-  optimization_guide::HintsComponentInfo
-  CreateHintsComponentInfoWithPublicImageHints(
-      const std::vector<std::string>& page_hint_host_suffixes,
-      const std::string& page_pattern,
-      const std::vector<std::string>& public_image_urls);
-
  private:
   // Returns the scoped temp directory path with the |file_path_suffix| that is
   // valid for the lifetime of this instance.