diff --git a/components/optimization_guide/core/hints_manager.cc b/components/optimization_guide/core/hints_manager.cc index 7d1138f151966..ae5e335894317 100644 --- a/components/optimization_guide/core/hints_manager.cc +++ b/components/optimization_guide/core/hints_manager.cc @@ -65,9 +65,9 @@ constexpr char kManualConfigComponentVersion[] = "0.0.0"; // Provides a random time delta in seconds between |kFetchRandomMinDelay| and // |kFetchRandomMaxDelay|. base::TimeDelta RandomFetchDelay() { - return base::Seconds(base::RandInt( - optimization_guide::features::ActiveTabsHintsFetchRandomMinDelaySecs(), - optimization_guide::features::ActiveTabsHintsFetchRandomMaxDelaySecs())); + return base::Seconds( + base::RandInt(features::ActiveTabsHintsFetchRandomMinDelaySecs(), + features::ActiveTabsHintsFetchRandomMaxDelaySecs())); } void MaybeRunUpdateClosure(base::OnceClosure update_closure) { @@ -78,39 +78,35 @@ void MaybeRunUpdateClosure(base::OnceClosure update_closure) { // Returns whether the particular component version can be processed, and if it // can be, locks the semaphore (in the form of a pref) to signal that the // processing of this particular version has started. -bool CanProcessComponentVersion( - PrefService* pref_service, - const base::Version& version, - optimization_guide::ProcessHintsComponentResult* out_result) { +bool CanProcessComponentVersion(PrefService* pref_service, + const base::Version& version, + ProcessHintsComponentResult* out_result) { DCHECK(version.IsValid()); DCHECK(out_result); - const std::string previous_attempted_version_string = pref_service->GetString( - optimization_guide::prefs::kPendingHintsProcessingVersion); + const std::string previous_attempted_version_string = + pref_service->GetString(prefs::kPendingHintsProcessingVersion); if (!previous_attempted_version_string.empty()) { const base::Version previous_attempted_version = base::Version(previous_attempted_version_string); if (!previous_attempted_version.IsValid()) { DLOG(ERROR) << "Bad contents in hints processing pref"; // Clear pref for fresh start next time. - pref_service->ClearPref( - optimization_guide::prefs::kPendingHintsProcessingVersion); - *out_result = optimization_guide::ProcessHintsComponentResult:: - kFailedPreviouslyAttemptedVersionInvalid; + pref_service->ClearPref(prefs::kPendingHintsProcessingVersion); + *out_result = + ProcessHintsComponentResult::kFailedPreviouslyAttemptedVersionInvalid; return false; } if (previous_attempted_version.CompareTo(version) == 0) { - *out_result = optimization_guide::ProcessHintsComponentResult:: - kFailedFinishProcessing; + *out_result = ProcessHintsComponentResult::kFailedFinishProcessing; // Previously attempted same version without completion. return false; } } // Write config version to pref. - pref_service->SetString( - optimization_guide::prefs::kPendingHintsProcessingVersion, - version.GetString()); + pref_service->SetString(prefs::kPendingHintsProcessingVersion, + version.GetString()); return true; } @@ -119,11 +115,10 @@ bool CanProcessComponentVersion( // populated with the metadata provided by the hint, if applicable. If // |page_hint| is not provided or |optimization_type| is not allowlisted, this // will return false. -bool IsOptimizationTypeAllowed( - const google::protobuf::RepeatedPtrField< - optimization_guide::proto::Optimization>& optimizations, - optimization_guide::proto::OptimizationType optimization_type, - optimization_guide::OptimizationMetadata* optimization_metadata) { +bool IsOptimizationTypeAllowed(const google::protobuf::RepeatedPtrField< + proto::Optimization>& optimizations, + proto::OptimizationType optimization_type, + OptimizationMetadata* optimization_metadata) { for (const auto& optimization : optimizations) { if (optimization_type != optimization.optimization_type()) continue; @@ -132,22 +127,22 @@ bool IsOptimizationTypeAllowed( // metadata if applicable and return. if (optimization_metadata) { switch (optimization.metadata_case()) { - case optimization_guide::proto::Optimization::kPerformanceHintsMetadata: + case proto::Optimization::kPerformanceHintsMetadata: optimization_metadata->set_performance_hints_metadata( optimization.performance_hints_metadata()); break; - case optimization_guide::proto::Optimization::kPublicImageMetadata: + case proto::Optimization::kPublicImageMetadata: optimization_metadata->set_public_image_metadata( optimization.public_image_metadata()); break; - case optimization_guide::proto::Optimization::kLoadingPredictorMetadata: + case proto::Optimization::kLoadingPredictorMetadata: optimization_metadata->set_loading_predictor_metadata( optimization.loading_predictor_metadata()); break; - case optimization_guide::proto::Optimization::kAnyMetadata: + case proto::Optimization::kAnyMetadata: optimization_metadata->set_any_metadata(optimization.any_metadata()); break; - case optimization_guide::proto::Optimization::METADATA_NOT_SET: + case proto::Optimization::METADATA_NOT_SET: // Some optimization types do not have metadata, make sure we do not // DCHECK. break; @@ -166,16 +161,14 @@ class ScopedHintsManagerRaceNavigationHintsFetchAttemptRecorder { public: explicit ScopedHintsManagerRaceNavigationHintsFetchAttemptRecorder( OptimizationGuideNavigationData* navigation_data) - : race_attempt_status_( - optimization_guide::RaceNavigationFetchAttemptStatus::kUnknown), + : race_attempt_status_(RaceNavigationFetchAttemptStatus::kUnknown), navigation_data_(navigation_data) {} ~ScopedHintsManagerRaceNavigationHintsFetchAttemptRecorder() { - DCHECK_NE(race_attempt_status_, - optimization_guide::RaceNavigationFetchAttemptStatus::kUnknown); + DCHECK_NE(race_attempt_status_, RaceNavigationFetchAttemptStatus::kUnknown); DCHECK_NE( race_attempt_status_, - optimization_guide::RaceNavigationFetchAttemptStatus:: + RaceNavigationFetchAttemptStatus:: kDeprecatedRaceNavigationFetchNotAttemptedTooManyConcurrentFetches); base::UmaHistogramEnumeration( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", @@ -185,25 +178,24 @@ class ScopedHintsManagerRaceNavigationHintsFetchAttemptRecorder { } void set_race_attempt_status( - optimization_guide::RaceNavigationFetchAttemptStatus - race_attempt_status) { + RaceNavigationFetchAttemptStatus race_attempt_status) { race_attempt_status_ = race_attempt_status; } private: - optimization_guide::RaceNavigationFetchAttemptStatus race_attempt_status_; + RaceNavigationFetchAttemptStatus race_attempt_status_; raw_ptr navigation_data_; }; // Returns true if the optimization type should be ignored when is newly // registered as the optimization type is likely launched. bool ShouldIgnoreNewlyRegisteredOptimizationType( - optimization_guide::proto::OptimizationType optimization_type) { + proto::OptimizationType optimization_type) { switch (optimization_type) { - case optimization_guide::proto::NOSCRIPT: - case optimization_guide::proto::RESOURCE_LOADING: - case optimization_guide::proto::LITE_PAGE_REDIRECT: - case optimization_guide::proto::DEFER_ALL_SCRIPT: + case proto::NOSCRIPT: + case proto::RESOURCE_LOADING: + case proto::LITE_PAGE_REDIRECT: + case proto::DEFER_ALL_SCRIPT: return true; default: return false; @@ -212,22 +204,19 @@ bool ShouldIgnoreNewlyRegisteredOptimizationType( class ScopedCanApplyOptimizationLogger { public: - ScopedCanApplyOptimizationLogger( - optimization_guide::proto::OptimizationType opt_type, - GURL url) - : decision_(optimization_guide::OptimizationGuideDecision::kUnknown), - type_decision_(optimization_guide::OptimizationTypeDecision::kUnknown), + ScopedCanApplyOptimizationLogger(proto::OptimizationType opt_type, GURL url) + : decision_(OptimizationGuideDecision::kUnknown), + type_decision_(OptimizationTypeDecision::kUnknown), opt_type_(opt_type), has_metadata_(false), url_(url) {} ~ScopedCanApplyOptimizationLogger() { - if (!optimization_guide::switches::IsDebugLogsEnabled()) + if (!switches::IsDebugLogsEnabled()) return; - DCHECK_NE(type_decision_, - optimization_guide::OptimizationTypeDecision::kUnknown); + DCHECK_NE(type_decision_, OptimizationTypeDecision::kUnknown); DVLOG(0) << "OptimizationGuide: CanApplyOptimization: " - << optimization_guide::GetStringNameForOptimizationType(opt_type_) + << GetStringNameForOptimizationType(opt_type_) << "\nqueried on: " << url_ << "\nDecision: " << GetStringForOptimizationGuideDecision(decision_) << "\nTypeDecision: " << static_cast(type_decision_) @@ -236,8 +225,7 @@ class ScopedCanApplyOptimizationLogger { void set_has_metadata() { has_metadata_ = true; } - void set_type_decision( - optimization_guide::OptimizationTypeDecision type_decision) { + void set_type_decision(OptimizationTypeDecision type_decision) { type_decision_ = type_decision; decision_ = HintsManager::GetOptimizationGuideDecisionFromOptimizationTypeDecision( @@ -245,22 +233,22 @@ class ScopedCanApplyOptimizationLogger { } private: - optimization_guide::OptimizationGuideDecision decision_; - optimization_guide::OptimizationTypeDecision type_decision_; - optimization_guide::proto::OptimizationType opt_type_; + OptimizationGuideDecision decision_; + OptimizationTypeDecision type_decision_; + proto::OptimizationType opt_type_; bool has_metadata_; GURL url_; }; // Reads component file and parses it into a Configuration proto. Should not be // called on the UI thread. -std::unique_ptr ReadComponentFile( - const optimization_guide::HintsComponentInfo& info) { - optimization_guide::ProcessHintsComponentResult out_result; - std::unique_ptr config = - optimization_guide::ProcessHintsComponent(info, &out_result); +std::unique_ptr ReadComponentFile( + const HintsComponentInfo& info) { + ProcessHintsComponentResult out_result; + std::unique_ptr config = + ProcessHintsComponent(info, &out_result); if (!config) { - optimization_guide::RecordProcessHintsComponentResult(out_result); + RecordProcessHintsComponentResult(out_result); return nullptr; } @@ -275,28 +263,25 @@ HintsManager::HintsManager( bool is_off_the_record, const std::string& application_locale, PrefService* pref_service, - optimization_guide::OptimizationGuideStore* hint_store, - optimization_guide::TopHostProvider* top_host_provider, - optimization_guide::TabUrlProvider* tab_url_provider, + OptimizationGuideStore* hint_store, + TopHostProvider* top_host_provider, + TabUrlProvider* tab_url_provider, scoped_refptr url_loader_factory, network::NetworkConnectionTracker* network_connection_tracker, - std::unique_ptr - push_notification_manager) + std::unique_ptr push_notification_manager) : is_off_the_record_(is_off_the_record), application_locale_(application_locale), pref_service_(pref_service), - hint_cache_(std::make_unique( - hint_store, - optimization_guide::features::MaxHostKeyedHintCacheSize())), + hint_cache_( + std::make_unique(hint_store, + features::MaxHostKeyedHintCacheSize())), page_navigation_hints_fetchers_( - optimization_guide::features::MaxConcurrentPageNavigationFetches()), - hints_fetcher_factory_( - std::make_unique( - url_loader_factory, - optimization_guide::features:: - GetOptimizationGuideServiceGetHintsURL(), - pref_service, - network_connection_tracker)), + features::MaxConcurrentPageNavigationFetches()), + hints_fetcher_factory_(std::make_unique( + url_loader_factory, + features::GetOptimizationGuideServiceGetHintsURL(), + pref_service, + network_connection_tracker)), top_host_provider_(top_host_provider), tab_url_provider_(tab_url_provider), push_notification_manager_(std::move(push_notification_manager)), @@ -306,10 +291,10 @@ HintsManager::HintsManager( if (push_notification_manager_) push_notification_manager_->SetDelegate(this); - hint_cache_->Initialize(optimization_guide::switches:: - ShouldPurgeOptimizationGuideStoreOnStartup(), - base::BindOnce(&HintsManager::OnHintCacheInitialized, - weak_ptr_factory_.GetWeakPtr())); + hint_cache_->Initialize( + switches::ShouldPurgeOptimizationGuideStoreOnStartup(), + base::BindOnce(&HintsManager::OnHintCacheInitialized, + weak_ptr_factory_.GetWeakPtr())); } HintsManager::~HintsManager() { @@ -318,8 +303,7 @@ HintsManager::~HintsManager() { void HintsManager::Shutdown() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); - optimization_guide::OptimizationHintsComponentUpdateListener::GetInstance() - ->RemoveObserver(this); + OptimizationHintsComponentUpdateListener::GetInstance()->RemoveObserver(this); base::UmaHistogramBoolean("OptimizationGuide.ProcessingComponentAtShutdown", is_processing_component_); @@ -328,58 +312,51 @@ void HintsManager::Shutdown() { // down, we should clear the pref since the function to clear the pref will // not run after shut down and we will think that we failed to process the // component due to a crash. - pref_service_->ClearPref( - optimization_guide::prefs::kPendingHintsProcessingVersion); + pref_service_->ClearPref(prefs::kPendingHintsProcessingVersion); } } // static -optimization_guide::OptimizationGuideDecision +OptimizationGuideDecision HintsManager::GetOptimizationGuideDecisionFromOptimizationTypeDecision( - optimization_guide::OptimizationTypeDecision optimization_type_decision) { + OptimizationTypeDecision optimization_type_decision) { switch (optimization_type_decision) { - case optimization_guide::OptimizationTypeDecision:: - kAllowedByOptimizationFilter: - case optimization_guide::OptimizationTypeDecision::kAllowedByHint: - return optimization_guide::OptimizationGuideDecision::kTrue; - case optimization_guide::OptimizationTypeDecision::kUnknown: - case optimization_guide::OptimizationTypeDecision:: - kHadOptimizationFilterButNotLoadedInTime: - case optimization_guide::OptimizationTypeDecision:: - kHadHintButNotLoadedInTime: - case optimization_guide::OptimizationTypeDecision:: - kHintFetchStartedButNotAvailableInTime: - case optimization_guide::OptimizationTypeDecision::kDeciderNotInitialized: - return optimization_guide::OptimizationGuideDecision::kUnknown; - case optimization_guide::OptimizationTypeDecision::kNotAllowedByHint: - case optimization_guide::OptimizationTypeDecision::kNoMatchingPageHint: - case optimization_guide::OptimizationTypeDecision::kNoHintAvailable: - case optimization_guide::OptimizationTypeDecision:: - kNotAllowedByOptimizationFilter: - return optimization_guide::OptimizationGuideDecision::kFalse; + case OptimizationTypeDecision::kAllowedByOptimizationFilter: + case OptimizationTypeDecision::kAllowedByHint: + return OptimizationGuideDecision::kTrue; + case OptimizationTypeDecision::kUnknown: + case OptimizationTypeDecision::kHadOptimizationFilterButNotLoadedInTime: + case OptimizationTypeDecision::kHadHintButNotLoadedInTime: + case OptimizationTypeDecision::kHintFetchStartedButNotAvailableInTime: + case OptimizationTypeDecision::kDeciderNotInitialized: + return OptimizationGuideDecision::kUnknown; + case OptimizationTypeDecision::kNotAllowedByHint: + case OptimizationTypeDecision::kNoMatchingPageHint: + case OptimizationTypeDecision::kNoHintAvailable: + case OptimizationTypeDecision::kNotAllowedByOptimizationFilter: + return OptimizationGuideDecision::kFalse; } } -void HintsManager::OnHintsComponentAvailable( - const optimization_guide::HintsComponentInfo& info) { +void HintsManager::OnHintsComponentAvailable(const HintsComponentInfo& info) { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); // Check for if hint component is disabled. This check is needed because the // optimization guide still registers with the service as an observer for // components as a signal during testing. - if (optimization_guide::switches::IsHintComponentProcessingDisabled()) { + if (switches::IsHintComponentProcessingDisabled()) { MaybeRunUpdateClosure(std::move(next_update_closure_)); return; } - optimization_guide::ProcessHintsComponentResult out_result; + ProcessHintsComponentResult out_result; if (!CanProcessComponentVersion(pref_service_, info.version, &out_result)) { - optimization_guide::RecordProcessHintsComponentResult(out_result); + RecordProcessHintsComponentResult(out_result); MaybeRunUpdateClosure(std::move(next_update_closure_)); return; } - std::unique_ptr update_data = + std::unique_ptr update_data = is_off_the_record_ ? nullptr : hint_cache_->MaybeCreateUpdateDataForComponentHints(info.version); @@ -408,11 +385,9 @@ void HintsManager::OnHintsComponentAvailable( } void HintsManager::ProcessOptimizationFilters( - const google::protobuf::RepeatedPtrField< - optimization_guide::proto::OptimizationFilter>& + const google::protobuf::RepeatedPtrField& allowlist_optimization_filters, - const google::protobuf::RepeatedPtrField< - optimization_guide::proto::OptimizationFilter>& + const google::protobuf::RepeatedPtrField& blocklist_optimization_filters) { optimization_types_with_filter_.clear(); allowlist_optimization_filters_.clear(); @@ -424,12 +399,11 @@ void HintsManager::ProcessOptimizationFilters( } void HintsManager::ProcessOptimizationFilterSet( - const google::protobuf::RepeatedPtrField< - optimization_guide::proto::OptimizationFilter>& filters, + const google::protobuf::RepeatedPtrField& + filters, bool is_allowlist) { for (const auto& filter : filters) { - if (filter.optimization_type() != - optimization_guide::proto::TYPE_UNSPECIFIED) { + if (filter.optimization_type() != proto::TYPE_UNSPECIFIED) { optimization_types_with_filter_.insert(filter.optimization_type()); } @@ -439,27 +413,25 @@ void HintsManager::ProcessOptimizationFilterSet( continue; } - optimization_guide::RecordOptimizationFilterStatus( + RecordOptimizationFilterStatus( filter.optimization_type(), - optimization_guide::OptimizationFilterStatus::kFoundServerFilterConfig); + OptimizationFilterStatus::kFoundServerFilterConfig); // Do not parse duplicate optimization filters. if (allowlist_optimization_filters_.find(filter.optimization_type()) != allowlist_optimization_filters_.end() || blocklist_optimization_filters_.find(filter.optimization_type()) != blocklist_optimization_filters_.end()) { - optimization_guide::RecordOptimizationFilterStatus( + RecordOptimizationFilterStatus( filter.optimization_type(), - optimization_guide::OptimizationFilterStatus:: - kFailedServerFilterDuplicateConfig); + OptimizationFilterStatus::kFailedServerFilterDuplicateConfig); continue; } // Parse optimization filter. - optimization_guide::OptimizationFilterStatus status; - std::unique_ptr - optimization_filter = - optimization_guide::ProcessOptimizationFilter(filter, &status); + OptimizationFilterStatus status; + std::unique_ptr optimization_filter = + ProcessOptimizationFilter(filter, &status); if (optimization_filter) { if (is_allowlist) { allowlist_optimization_filters_.insert( @@ -469,8 +441,7 @@ void HintsManager::ProcessOptimizationFilterSet( {filter.optimization_type(), std::move(optimization_filter)}); } } - optimization_guide::RecordOptimizationFilterStatus( - filter.optimization_type(), status); + RecordOptimizationFilterStatus(filter.optimization_type(), status); } } @@ -484,10 +455,10 @@ void HintsManager::OnHintCacheInitialized() { // Check if there is a valid hint proto given on the command line first. We // don't normally expect one, but if one is provided then use that and do not // register as an observer as the opt_guide service. - std::unique_ptr manual_config = - optimization_guide::switches::ParseComponentConfigFromCommandLine(); + std::unique_ptr manual_config = + switches::ParseComponentConfigFromCommandLine(); if (manual_config) { - std::unique_ptr update_data = + std::unique_ptr update_data = is_off_the_record_ ? nullptr : hint_cache_->MaybeCreateUpdateDataForComponentHints( @@ -507,21 +478,19 @@ void HintsManager::OnHintCacheInitialized() { // Register as an observer regardless of hint proto override usage. This is // needed as a signal during testing. - optimization_guide::OptimizationHintsComponentUpdateListener::GetInstance() - ->AddObserver(this); + OptimizationHintsComponentUpdateListener::GetInstance()->AddObserver(this); } void HintsManager::UpdateComponentHints( base::OnceClosure update_closure, - std::unique_ptr update_data, - std::unique_ptr config) { + std::unique_ptr update_data, + std::unique_ptr config) { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); // If we get here, the component file has been processed correctly and did not // crash the device. is_processing_component_ = false; - pref_service_->ClearPref( - optimization_guide::prefs::kPendingHintsProcessingVersion); + pref_service_->ClearPref(prefs::kPendingHintsProcessingVersion); if (!config) { MaybeRunUpdateClosure(std::move(update_closure)); @@ -535,15 +504,12 @@ void HintsManager::UpdateComponentHints( if (update_data && !is_off_the_record_) { bool did_process_hints = hint_cache_->ProcessAndCacheHints( config->mutable_hints(), update_data.get()); - optimization_guide::RecordProcessHintsComponentResult( - did_process_hints - ? optimization_guide::ProcessHintsComponentResult::kSuccess - : optimization_guide::ProcessHintsComponentResult:: - kProcessedNoHints); + RecordProcessHintsComponentResult( + did_process_hints ? ProcessHintsComponentResult::kSuccess + : ProcessHintsComponentResult::kProcessedNoHints); } else { - optimization_guide::RecordProcessHintsComponentResult( - optimization_guide::ProcessHintsComponentResult:: - kSkippedProcessingHints); + RecordProcessHintsComponentResult( + ProcessHintsComponentResult::kSkippedProcessingHints); } if (update_data) { @@ -564,9 +530,8 @@ void HintsManager::OnComponentHintsUpdated(base::OnceClosure update_closure, // Record the result of updating the hints. This is used as a signal for the // hints being fully processed in testing. - LOCAL_HISTOGRAM_BOOLEAN( - optimization_guide::kComponentHintsUpdatedResultHistogramString, - hints_updated); + LOCAL_HISTOGRAM_BOOLEAN(kComponentHintsUpdatedResultHistogramString, + hints_updated); // Initiate the hints fetch scheduling if deferred startup handling is not // enabled. Otherwise OnDeferredStartup() will iniitate it. @@ -576,11 +541,10 @@ void HintsManager::OnComponentHintsUpdated(base::OnceClosure update_closure, } void HintsManager::InitiateHintsFetchScheduling() { - if (optimization_guide::features:: - ShouldBatchUpdateHintsForActiveTabsAndTopHosts()) { + if (features::ShouldBatchUpdateHintsForActiveTabsAndTopHosts()) { SetLastHintsFetchAttemptTime(clock_->Now()); - if (optimization_guide::switches::ShouldOverrideFetchHintsTimer() || + if (switches::ShouldOverrideFetchHintsTimer() || features::ShouldDeferStartupActiveTabsHintsFetch()) { FetchHintsForActiveTabs(); } else if (!active_tabs_hints_fetch_timer_.IsRunning()) { @@ -600,8 +564,7 @@ void HintsManager::ListenForNextUpdateForTesting( } void HintsManager::SetHintsFetcherFactoryForTesting( - std::unique_ptr - hints_fetcher_factory) { + std::unique_ptr hints_fetcher_factory) { hints_fetcher_factory_ = std::move(hints_fetcher_factory); } @@ -613,13 +576,13 @@ void HintsManager::ScheduleActiveTabsHintsFetch() { DCHECK(!active_tabs_hints_fetch_timer_.IsRunning()); const base::TimeDelta active_tabs_refresh_duration = - optimization_guide::features::GetActiveTabsFetchRefreshDuration(); + features::GetActiveTabsFetchRefreshDuration(); const base::TimeDelta time_since_last_fetch = clock_->Now() - GetLastHintsFetchAttemptTime(); if (time_since_last_fetch >= active_tabs_refresh_duration) { // Fetched hints in the store should be updated and an attempt has not // been made in last - // |optimization_guide::features::GetActiveTabsFetchRefreshDuration()|. + // |features::GetActiveTabsFetchRefreshDuration()|. SetLastHintsFetchAttemptTime(clock_->Now()); active_tabs_hints_fetch_timer_.Start( FROM_HERE, RandomFetchDelay(), this, @@ -640,11 +603,11 @@ const std::vector HintsManager::GetActiveTabURLsToRefresh() { return {}; std::vector active_tab_urls = tab_url_provider_->GetUrlsOfActiveTabs( - optimization_guide::features::GetActiveTabsStalenessTolerance()); + features::GetActiveTabsStalenessTolerance()); std::set urls_to_refresh; for (const auto& url : active_tab_urls) { - if (!optimization_guide::IsValidURLForURLKeyedHint(url)) + if (!IsValidURLForURLKeyedHint(url)) continue; if (!hint_cache_->HasURLKeyedEntryForURL(url)) @@ -656,12 +619,11 @@ const std::vector HintsManager::GetActiveTabURLsToRefresh() { void HintsManager::FetchHintsForActiveTabs() { active_tabs_hints_fetch_timer_.Stop(); active_tabs_hints_fetch_timer_.Start( - FROM_HERE, - optimization_guide::features::GetActiveTabsFetchRefreshDuration(), this, + FROM_HERE, features::GetActiveTabsFetchRefreshDuration(), this, &HintsManager::ScheduleActiveTabsHintsFetch); - if (!optimization_guide::IsUserPermittedToFetchFromRemoteOptimizationGuide( - is_off_the_record_, pref_service_)) { + if (!IsUserPermittedToFetchFromRemoteOptimizationGuide(is_off_the_record_, + pref_service_)) { return; } @@ -690,7 +652,7 @@ void HintsManager::FetchHintsForActiveTabs() { // Add hosts of active tabs to list of hosts to fetch for. Since we are mainly // fetching for updated information on tabs, add those to the front of the // list. - if (optimization_guide::switches::IsDebugLogsEnabled()) { + if (switches::IsDebugLogsEnabled()) { DVLOG(0) << "OptimizationGuide: ActiveTabsFetching starting fetch for: "; DVLOG(0) << "OptimizationGuide: Registered Optimization Types: "; for (const auto& optimization_type : registered_optimization_types_) { @@ -702,7 +664,7 @@ void HintsManager::FetchHintsForActiveTabs() { base::flat_set top_hosts_set = base::flat_set(top_hosts.begin(), top_hosts.end()); for (const auto& url : active_tab_urls_to_refresh) { - if (optimization_guide::switches::IsDebugLogsEnabled()) + if (switches::IsDebugLogsEnabled()) DVLOG(0) << "OptimizationGuide: URL: " << url; if (!url.has_host() || top_hosts_set.find(url.host()) == top_hosts_set.end()) { @@ -711,15 +673,14 @@ void HintsManager::FetchHintsForActiveTabs() { if (!hint_cache_->HasHint(url.host())) { top_hosts_set.insert(url.host()); top_hosts.insert(top_hosts.begin(), url.host()); - if (optimization_guide::switches::IsDebugLogsEnabled()) + if (switches::IsDebugLogsEnabled()) DVLOG(0) << "OptimizationGuide: Host: " << url.host(); } } batch_update_hints_fetcher_->FetchOptimizationGuideServiceHints( top_hosts, active_tab_urls_to_refresh, registered_optimization_types_, - optimization_guide::proto::CONTEXT_BATCH_UPDATE_ACTIVE_TABS, - application_locale_, + proto::CONTEXT_BATCH_UPDATE_ACTIVE_TABS, application_locale_, base::BindOnce(&HintsManager::OnHintsForActiveTabsFetched, weak_ptr_factory_.GetWeakPtr(), top_hosts_set, base::flat_set(active_tab_urls_to_refresh.begin(), @@ -729,19 +690,18 @@ void HintsManager::FetchHintsForActiveTabs() { void HintsManager::OnHintsForActiveTabsFetched( const base::flat_set& hosts_fetched, const base::flat_set& urls_fetched, - absl::optional> + absl::optional> get_hints_response) { if (!get_hints_response) return; hint_cache_->UpdateFetchedHints( std::move(*get_hints_response), - clock_->Now() + - optimization_guide::features::GetActiveTabsFetchRefreshDuration(), + clock_->Now() + features::GetActiveTabsFetchRefreshDuration(), hosts_fetched, urls_fetched, base::BindOnce(&HintsManager::OnFetchedActiveTabsHintsStored, weak_ptr_factory_.GetWeakPtr())); - if (optimization_guide::switches::IsDebugLogsEnabled()) + if (switches::IsDebugLogsEnabled()) DVLOG(0) << "OptimizationGuide: OnHintsForActiveTabsFetched complete"; } @@ -750,7 +710,7 @@ void HintsManager::OnPageNavigationHintsFetched( const absl::optional& navigation_url, const base::flat_set& page_navigation_urls_requested, const base::flat_set& page_navigation_hosts_requested, - absl::optional> + absl::optional> get_hints_response) { if (!get_hints_response.has_value() || !get_hints_response.value()) { if (navigation_url) { @@ -762,8 +722,7 @@ void HintsManager::OnPageNavigationHintsFetched( hint_cache_->UpdateFetchedHints( std::move(*get_hints_response), - clock_->Now() + - optimization_guide::features::GetActiveTabsFetchRefreshDuration(), + clock_->Now() + features::GetActiveTabsFetchRefreshDuration(), page_navigation_hosts_requested, page_navigation_urls_requested, base::BindOnce(&HintsManager::OnFetchedPageNavigationHintsStored, weak_ptr_factory_.GetWeakPtr(), navigation_data_weak_ptr, @@ -774,7 +733,7 @@ void HintsManager::OnFetchedActiveTabsHintsStored() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); LOCAL_HISTOGRAM_BOOLEAN("OptimizationGuide.FetchedHints.Stored", true); - if (!optimization_guide::features::ShouldPersistHintsToDisk()) { + if (!features::ShouldPersistHintsToDisk()) { // If we aren't persisting hints to disk, there's no point in purging // hints from disk or starting a new fetch since at this point we should // just be fetching everything on page navigation and only storing @@ -818,15 +777,14 @@ void HintsManager::CleanUpFetcherForNavigation(const GURL& navigation_url) { base::Time HintsManager::GetLastHintsFetchAttemptTime() const { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); - return base::Time::FromDeltaSinceWindowsEpoch( - base::Microseconds(pref_service_->GetInt64( - optimization_guide::prefs::kHintsFetcherLastFetchAttempt))); + return base::Time::FromDeltaSinceWindowsEpoch(base::Microseconds( + pref_service_->GetInt64(prefs::kHintsFetcherLastFetchAttempt))); } void HintsManager::SetLastHintsFetchAttemptTime(base::Time last_attempt_time) { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); pref_service_->SetInt64( - optimization_guide::prefs::kHintsFetcherLastFetchAttempt, + prefs::kHintsFetcherLastFetchAttempt, last_attempt_time.ToDeltaSinceWindowsEpoch().InMicroseconds()); } @@ -855,7 +813,7 @@ void HintsManager::FetchHintsForURLs(std::vector target_urls, DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); // Collect hosts, stripping duplicates, but preserving the ordering. - optimization_guide::InsertionOrderedSet target_hosts; + InsertionOrderedSet target_hosts; for (const auto& url : target_urls) { target_hosts.insert(url.host()); } @@ -880,14 +838,12 @@ void HintsManager::FetchHintsForURLs(std::vector target_urls, target_urls, target_hosts.set())); } -void HintsManager::OnHintLoaded( - base::OnceClosure callback, - const optimization_guide::proto::Hint* loaded_hint) const { +void HintsManager::OnHintLoaded(base::OnceClosure callback, + const proto::Hint* loaded_hint) const { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); // Record the result of loading a hint. This is used as a signal for testing. - LOCAL_HISTOGRAM_BOOLEAN(optimization_guide::kLoadedHintLocalHistogramString, - loaded_hint); + LOCAL_HISTOGRAM_BOOLEAN(kLoadedHintLocalHistogramString, loaded_hint); // Run the callback now that the hint is loaded. This is used as a signal by // tests. @@ -895,16 +851,14 @@ void HintsManager::OnHintLoaded( } void HintsManager::RegisterOptimizationTypes( - const std::vector& - optimization_types) { + const std::vector& optimization_types) { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); bool should_load_new_optimization_filter = false; DictionaryPrefUpdate previously_registered_opt_types( - pref_service_, - optimization_guide::prefs::kPreviouslyRegisteredOptimizationTypes); + pref_service_, prefs::kPreviouslyRegisteredOptimizationTypes); for (const auto optimization_type : optimization_types) { - if (optimization_type == optimization_guide::proto::TYPE_UNSPECIFIED) + if (optimization_type == proto::TYPE_UNSPECIFIED) continue; if (registered_optimization_types_.find(optimization_type) != @@ -913,14 +867,13 @@ void HintsManager::RegisterOptimizationTypes( } registered_optimization_types_.insert(optimization_type); - if (optimization_guide::switches::IsDebugLogsEnabled()) { + if (switches::IsDebugLogsEnabled()) { DVLOG(0) << "OptimizationGuide: Registered new OptimizationType: " - << optimization_guide::proto::OptimizationType_Name( - optimization_type); + << proto::OptimizationType_Name(optimization_type); } absl::optional value = previously_registered_opt_types->FindBoolKey( - optimization_guide::proto::OptimizationType_Name(optimization_type)); + proto::OptimizationType_Name(optimization_type)); if (!value) { if (!is_off_the_record_ && !ShouldIgnoreNewlyRegisteredOptimizationType(optimization_type) && @@ -929,8 +882,7 @@ void HintsManager::RegisterOptimizationTypes( should_clear_hints_for_new_type_ = true; } previously_registered_opt_types->SetBoolKey( - optimization_guide::proto::OptimizationType_Name(optimization_type), - true); + proto::OptimizationType_Name(optimization_type), true); } if (!should_load_new_optimization_filter) { @@ -949,9 +901,9 @@ void HintsManager::RegisterOptimizationTypes( } if (should_load_new_optimization_filter) { - if (optimization_guide::switches::IsHintComponentProcessingDisabled()) { - std::unique_ptr manual_config = - optimization_guide::switches::ParseComponentConfigFromCommandLine(); + if (switches::IsHintComponentProcessingDisabled()) { + std::unique_ptr manual_config = + switches::ParseComponentConfigFromCommandLine(); if (manual_config->optimization_allowlists_size() > 0 || manual_config->optimization_blocklists_size() > 0) { ProcessOptimizationFilters(manual_config->optimization_allowlists(), @@ -967,14 +919,14 @@ void HintsManager::RegisterOptimizationTypes( } bool HintsManager::HasLoadedOptimizationAllowlist( - optimization_guide::proto::OptimizationType optimization_type) { + proto::OptimizationType optimization_type) { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); return allowlist_optimization_filters_.find(optimization_type) != allowlist_optimization_filters_.end(); } bool HintsManager::HasLoadedOptimizationBlocklist( - optimization_guide::proto::OptimizationType optimization_type) { + proto::OptimizationType optimization_type) { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); return blocklist_optimization_filters_.find(optimization_type) != blocklist_optimization_filters_.end(); @@ -982,24 +934,23 @@ bool HintsManager::HasLoadedOptimizationBlocklist( void HintsManager::CanApplyOptimizationAsync( const GURL& navigation_url, - optimization_guide::proto::OptimizationType optimization_type, - optimization_guide::OptimizationGuideDecisionCallback callback) { + proto::OptimizationType optimization_type, + OptimizationGuideDecisionCallback callback) { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); - optimization_guide::OptimizationMetadata metadata; - optimization_guide::OptimizationTypeDecision type_decision = + OptimizationMetadata metadata; + OptimizationTypeDecision type_decision = CanApplyOptimization(navigation_url, optimization_type, &metadata); - optimization_guide::OptimizationGuideDecision decision = + OptimizationGuideDecision decision = GetOptimizationGuideDecisionFromOptimizationTypeDecision(type_decision); // It's possible that a hint that applies to |navigation_url| will come in // later, so only run the callback if we are sure we can apply the decision. - if (decision == optimization_guide::OptimizationGuideDecision::kTrue || + if (decision == OptimizationGuideDecision::kTrue || HasAllInformationForDecisionAvailable(navigation_url, optimization_type)) { base::UmaHistogramEnumeration( "OptimizationGuide.ApplyDecisionAsync." + - optimization_guide::GetStringNameForOptimizationType( - optimization_type), + GetStringNameForOptimizationType(optimization_type), type_decision); std::move(callback).Run(decision, metadata); return; @@ -1009,10 +960,10 @@ void HintsManager::CanApplyOptimizationAsync( std::move(callback)); } -optimization_guide::OptimizationTypeDecision HintsManager::CanApplyOptimization( +OptimizationTypeDecision HintsManager::CanApplyOptimization( const GURL& navigation_url, - optimization_guide::proto::OptimizationType optimization_type, - optimization_guide::OptimizationMetadata* optimization_metadata) { + proto::OptimizationType optimization_type, + OptimizationMetadata* optimization_metadata) { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); ScopedCanApplyOptimizationLogger scoped_logger(optimization_type, @@ -1029,17 +980,15 @@ optimization_guide::OptimizationTypeDecision HintsManager::CanApplyOptimization( // just return. if (registered_optimization_types_.find(optimization_type) == registered_optimization_types_.end()) { - scoped_logger.set_type_decision( - optimization_guide::OptimizationTypeDecision::kNoHintAvailable); - return optimization_guide::OptimizationTypeDecision::kNoHintAvailable; + scoped_logger.set_type_decision(OptimizationTypeDecision::kNoHintAvailable); + return OptimizationTypeDecision::kNoHintAvailable; } // If the URL doesn't have a host, we cannot query the hint for it, so just // return early. if (!navigation_url.has_host()) { - scoped_logger.set_type_decision( - optimization_guide::OptimizationTypeDecision::kNoHintAvailable); - return optimization_guide::OptimizationTypeDecision::kNoHintAvailable; + scoped_logger.set_type_decision(OptimizationTypeDecision::kNoHintAvailable); + return OptimizationTypeDecision::kNoHintAvailable; } const auto& host = navigation_url.host(); @@ -1053,10 +1002,8 @@ optimization_guide::OptimizationTypeDecision HintsManager::CanApplyOptimization( const auto type_decision = allowlist_optimization_filters_[optimization_type]->Matches( navigation_url) - ? optimization_guide::OptimizationTypeDecision:: - kAllowedByOptimizationFilter - : optimization_guide::OptimizationTypeDecision:: - kNotAllowedByOptimizationFilter; + ? OptimizationTypeDecision::kAllowedByOptimizationFilter + : OptimizationTypeDecision::kNotAllowedByOptimizationFilter; scoped_logger.set_type_decision(type_decision); return type_decision; } @@ -1068,10 +1015,8 @@ optimization_guide::OptimizationTypeDecision HintsManager::CanApplyOptimization( const auto type_decision = blocklist_optimization_filters_[optimization_type]->Matches( navigation_url) - ? optimization_guide::OptimizationTypeDecision:: - kNotAllowedByOptimizationFilter - : optimization_guide::OptimizationTypeDecision:: - kAllowedByOptimizationFilter; + ? OptimizationTypeDecision::kNotAllowedByOptimizationFilter + : OptimizationTypeDecision::kAllowedByOptimizationFilter; scoped_logger.set_type_decision(type_decision); return type_decision; } @@ -1081,14 +1026,12 @@ optimization_guide::OptimizationTypeDecision HintsManager::CanApplyOptimization( if (optimization_types_with_filter_.find(optimization_type) != optimization_types_with_filter_.end()) { scoped_logger.set_type_decision( - optimization_guide::OptimizationTypeDecision:: - kHadOptimizationFilterButNotLoadedInTime); - return optimization_guide::OptimizationTypeDecision:: - kHadOptimizationFilterButNotLoadedInTime; + OptimizationTypeDecision::kHadOptimizationFilterButNotLoadedInTime); + return OptimizationTypeDecision::kHadOptimizationFilterButNotLoadedInTime; } // First, check if the optimization type is allowlisted by a URL-keyed hint. - const optimization_guide::proto::Hint* url_keyed_hint = + const proto::Hint* url_keyed_hint = hint_cache_->GetURLKeyedHint(navigation_url); if (url_keyed_hint) { DCHECK_EQ(url_keyed_hint->page_hints_size(), 1); @@ -1097,73 +1040,63 @@ optimization_guide::OptimizationTypeDecision HintsManager::CanApplyOptimization( url_keyed_hint->page_hints(0).allowlisted_optimizations(), optimization_type, optimization_metadata)) { scoped_logger.set_type_decision( - optimization_guide::OptimizationTypeDecision::kAllowedByHint); + OptimizationTypeDecision::kAllowedByHint); if (optimization_metadata && !optimization_metadata->empty()) scoped_logger.set_has_metadata(); - return optimization_guide::OptimizationTypeDecision::kAllowedByHint; + return OptimizationTypeDecision::kAllowedByHint; } } } // Check if we have a hint already loaded for this navigation. - const optimization_guide::proto::Hint* loaded_hint = - hint_cache_->GetHostKeyedHintIfLoaded(host); + const proto::Hint* loaded_hint = hint_cache_->GetHostKeyedHintIfLoaded(host); if (!loaded_hint) { if (hint_cache_->HasHint(host)) { // If we do not have a hint already loaded and we do not have one in the // 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 (optimization_guide::features::ShouldPersistHintsToDisk()) { + if (features::ShouldPersistHintsToDisk()) { scoped_logger.set_type_decision( - optimization_guide::OptimizationTypeDecision:: - kHadHintButNotLoadedInTime); - return optimization_guide::OptimizationTypeDecision:: - kHadHintButNotLoadedInTime; + OptimizationTypeDecision::kHadHintButNotLoadedInTime); + return OptimizationTypeDecision::kHadHintButNotLoadedInTime; } else { scoped_logger.set_type_decision( - optimization_guide::OptimizationTypeDecision::kNoHintAvailable); - return optimization_guide::OptimizationTypeDecision::kNoHintAvailable; + OptimizationTypeDecision::kNoHintAvailable); + return OptimizationTypeDecision::kNoHintAvailable; } } if (IsHintBeingFetchedForNavigation(navigation_url)) { scoped_logger.set_type_decision( - optimization_guide::OptimizationTypeDecision:: - kHintFetchStartedButNotAvailableInTime); - return optimization_guide::OptimizationTypeDecision:: - kHintFetchStartedButNotAvailableInTime; + OptimizationTypeDecision::kHintFetchStartedButNotAvailableInTime); + return OptimizationTypeDecision::kHintFetchStartedButNotAvailableInTime; } - scoped_logger.set_type_decision( - optimization_guide::OptimizationTypeDecision::kNoHintAvailable); - return optimization_guide::OptimizationTypeDecision::kNoHintAvailable; + scoped_logger.set_type_decision(OptimizationTypeDecision::kNoHintAvailable); + return OptimizationTypeDecision::kNoHintAvailable; } if (IsOptimizationTypeAllowed(loaded_hint->allowlisted_optimizations(), optimization_type, optimization_metadata)) { - scoped_logger.set_type_decision( - optimization_guide::OptimizationTypeDecision::kAllowedByHint); + scoped_logger.set_type_decision(OptimizationTypeDecision::kAllowedByHint); if (optimization_metadata && !optimization_metadata->empty()) scoped_logger.set_has_metadata(); - return optimization_guide::OptimizationTypeDecision::kAllowedByHint; + return OptimizationTypeDecision::kAllowedByHint; } - const optimization_guide::proto::PageHint* matched_page_hint = - loaded_hint - ? optimization_guide::FindPageHintForURL(navigation_url, loaded_hint) - : nullptr; + const proto::PageHint* matched_page_hint = + loaded_hint ? FindPageHintForURL(navigation_url, loaded_hint) : nullptr; if (!matched_page_hint) { scoped_logger.set_type_decision( - optimization_guide::OptimizationTypeDecision::kNotAllowedByHint); - return optimization_guide::OptimizationTypeDecision::kNotAllowedByHint; + OptimizationTypeDecision::kNotAllowedByHint); + return OptimizationTypeDecision::kNotAllowedByHint; } bool is_allowed = IsOptimizationTypeAllowed(matched_page_hint->allowlisted_optimizations(), optimization_type, optimization_metadata); - const auto type_decision = - is_allowed - ? optimization_guide::OptimizationTypeDecision::kAllowedByHint - : optimization_guide::OptimizationTypeDecision::kNotAllowedByHint; + const auto type_decision = is_allowed + ? OptimizationTypeDecision::kAllowedByHint + : OptimizationTypeDecision::kNotAllowedByHint; scoped_logger.set_type_decision(type_decision); if (optimization_metadata && !optimization_metadata->empty()) scoped_logger.set_has_metadata(); @@ -1194,19 +1127,18 @@ void HintsManager::OnReadyToInvokeRegisteredCallbacks( for (auto& opt_type_and_callbacks : registered_callbacks_.at(navigation_url)) { - optimization_guide::proto::OptimizationType opt_type = - opt_type_and_callbacks.first; + proto::OptimizationType opt_type = opt_type_and_callbacks.first; for (auto& callback : opt_type_and_callbacks.second) { - optimization_guide::OptimizationMetadata metadata; - optimization_guide::OptimizationTypeDecision type_decision = + OptimizationMetadata metadata; + OptimizationTypeDecision type_decision = CanApplyOptimization(navigation_url, opt_type, &metadata); - optimization_guide::OptimizationGuideDecision decision = + OptimizationGuideDecision decision = GetOptimizationGuideDecisionFromOptimizationTypeDecision( type_decision); base::UmaHistogramEnumeration( "OptimizationGuide.ApplyDecisionAsync." + - optimization_guide::GetStringNameForOptimizationType(opt_type), + GetStringNameForOptimizationType(opt_type), type_decision); std::move(callback).Run(decision, metadata); } @@ -1233,8 +1165,8 @@ bool HintsManager::IsAllowedToFetchNavigationHints(const GURL& url) { if (!HasOptimizationTypeToFetchFor()) return false; - if (!optimization_guide::IsUserPermittedToFetchFromRemoteOptimizationGuide( - is_off_the_record_, pref_service_)) { + if (!IsUserPermittedToFetchFromRemoteOptimizationGuide(is_off_the_record_, + pref_service_)) { return false; } DCHECK(!is_off_the_record_); @@ -1249,8 +1181,7 @@ void HintsManager::OnNavigationStartOrRedirect( LoadHintForURL(navigation_data->navigation_url(), std::move(callback)); - if (optimization_guide::switches:: - DisableFetchingHintsAtNavigationStartForTesting()) { + if (switches::DisableFetchingHintsAtNavigationStartForTesting()) { return; } @@ -1275,7 +1206,7 @@ void HintsManager::MaybeFetchHintsForNavigation( // the logic to decide if we also require fetching hints for the host. if (IsHintBeingFetchedForNavigation(url)) { race_navigation_recorder.set_race_attempt_status( - optimization_guide::RaceNavigationFetchAttemptStatus:: + RaceNavigationFetchAttemptStatus:: kRaceNavigationFetchAlreadyInProgress); // Just set the hints fetch start to the start of the navigation, so we can @@ -1289,21 +1220,18 @@ void HintsManager::MaybeFetchHintsForNavigation( if (!hint_cache_->HasHint(url.host())) { hosts.push_back(url.host()); race_navigation_recorder.set_race_attempt_status( - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHost); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHost); } if (!hint_cache_->HasURLKeyedEntryForURL(url)) { urls.push_back(url); race_navigation_recorder.set_race_attempt_status( - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchURL); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchURL); } if (hosts.empty() && urls.empty()) { race_navigation_recorder.set_race_attempt_status( - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchNotAttempted); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchNotAttempted); return; } @@ -1317,7 +1245,7 @@ void HintsManager::MaybeFetchHintsForNavigation( bool fetch_attempted = it->second->FetchOptimizationGuideServiceHints( hosts, urls, registered_optimization_types_, - optimization_guide::proto::CONTEXT_PAGE_NAVIGATION, application_locale_, + proto::CONTEXT_PAGE_NAVIGATION, application_locale_, base::BindOnce(&HintsManager::OnPageNavigationHintsFetched, weak_ptr_factory_.GetWeakPtr(), navigation_data->GetWeakPtr(), url, @@ -1328,8 +1256,7 @@ void HintsManager::MaybeFetchHintsForNavigation( if (!hosts.empty() && !urls.empty()) { race_navigation_recorder.set_race_attempt_status( - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHostAndURL); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHostAndURL); DVLOG(0) << "OptimizationGuide: Fetch hints for Navigation: "; DVLOG(0) << "OptimizationGuide: Registered Optimization Types: "; for (const auto& optimization_type : registered_optimization_types_) { @@ -1351,8 +1278,7 @@ void HintsManager::MaybeFetchHintsForNavigation( } } else { race_navigation_recorder.set_race_attempt_status( - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchNotAttempted); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchNotAttempted); } } @@ -1375,27 +1301,25 @@ void HintsManager::OnDeferredStartup() { InitiateHintsFetchScheduling(); } -optimization_guide::OptimizationGuideStore* HintsManager::hint_store() { +OptimizationGuideStore* HintsManager::hint_store() { return hint_cache_->hint_store(); } -optimization_guide::HintCache* HintsManager::hint_cache() { +HintCache* HintsManager::hint_cache() { return hint_cache_.get(); } -optimization_guide::PushNotificationManager* -HintsManager::push_notification_manager() { +PushNotificationManager* HintsManager::push_notification_manager() { return push_notification_manager_.get(); } -optimization_guide::HintsFetcherFactory* -HintsManager::GetHintsFetcherFactory() { +HintsFetcherFactory* HintsManager::GetHintsFetcherFactory() { return hints_fetcher_factory_.get(); } bool HintsManager::HasAllInformationForDecisionAvailable( const GURL& navigation_url, - optimization_guide::proto::OptimizationType optimization_type) { + proto::OptimizationType optimization_type) { if (HasLoadedOptimizationAllowlist(optimization_type) || HasLoadedOptimizationBlocklist(optimization_type)) { // If we have an optimization filter for the optimization type, it is @@ -1436,27 +1360,24 @@ bool HintsManager::HasAllInformationForDecisionAvailable( void HintsManager::ClearFetchedHints() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); hint_cache_->ClearFetchedHints(); - optimization_guide::HintsFetcher::ClearHostsSuccessfullyFetched( - pref_service_); + HintsFetcher::ClearHostsSuccessfullyFetched(pref_service_); } void HintsManager::ClearHostKeyedHints() { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); hint_cache_->ClearHostKeyedHints(); - optimization_guide::HintsFetcher::ClearHostsSuccessfullyFetched( - pref_service_); + HintsFetcher::ClearHostsSuccessfullyFetched(pref_service_); } void HintsManager::AddHintForTesting( const GURL& url, - optimization_guide::proto::OptimizationType optimization_type, - const absl::optional& metadata) { - std::unique_ptr hint = - std::make_unique(); + proto::OptimizationType optimization_type, + const absl::optional& metadata) { + std::unique_ptr hint = std::make_unique(); hint->set_key(url.spec()); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->set_page_pattern("*"); - optimization_guide::proto::Optimization* optimization = + proto::Optimization* optimization = page_hint->add_allowlisted_optimizations(); optimization->set_optimization_type(optimization_type); if (!metadata) { @@ -1484,21 +1405,21 @@ void HintsManager::AddHintForTesting( void HintsManager::RemoveFetchedEntriesByHintKeys( base::OnceClosure on_success, - optimization_guide::proto::KeyRepresentation key_representation, + proto::KeyRepresentation key_representation, const base::flat_set& hint_keys) { DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); // Make sure the key representation is something that we expect. switch (key_representation) { - case optimization_guide::proto::KeyRepresentation::HOST: - case optimization_guide::proto::KeyRepresentation::FULL_URL: + case proto::KeyRepresentation::HOST: + case proto::KeyRepresentation::FULL_URL: break; default: NOTREACHED(); return; } - if (key_representation == optimization_guide::proto::FULL_URL) { + if (key_representation == proto::FULL_URL) { base::flat_set urls_to_remove; base::flat_set hosts_to_remove; // It is possible that the hints may have upgraded from being HOST keyed to @@ -1517,8 +1438,7 @@ void HintsManager::RemoveFetchedEntriesByHintKeys( // Also clear the HintFetcher's host pref. for (const std::string& host : hosts_to_remove) { - optimization_guide::HintsFetcher::ClearSingleFetchedHost(pref_service_, - host); + HintsFetcher::ClearSingleFetchedHost(pref_service_, host); } hint_cache_->RemoveHintsForURLs(urls_to_remove); @@ -1528,8 +1448,7 @@ void HintsManager::RemoveFetchedEntriesByHintKeys( // Also clear the HintFetcher's host pref. for (const std::string& host : hint_keys) { - optimization_guide::HintsFetcher::ClearSingleFetchedHost(pref_service_, - host); + HintsFetcher::ClearSingleFetchedHost(pref_service_, host); } hint_cache_->RemoveHintsForHosts(std::move(on_success), hint_keys); diff --git a/components/optimization_guide/core/hints_manager.h b/components/optimization_guide/core/hints_manager.h index 39f54ebba640b..b6b6c30012ea6 100644 --- a/components/optimization_guide/core/hints_manager.h +++ b/components/optimization_guide/core/hints_manager.h @@ -56,13 +56,12 @@ class HintsManager : public OptimizationHintsComponentObserver, bool is_off_the_record, const std::string& application_locale, PrefService* pref_service, - optimization_guide::OptimizationGuideStore* hint_store, - optimization_guide::TopHostProvider* top_host_provider, - optimization_guide::TabUrlProvider* tab_url_provider, + OptimizationGuideStore* hint_store, + TopHostProvider* top_host_provider, + TabUrlProvider* tab_url_provider, scoped_refptr url_loader_factory, network::NetworkConnectionTracker* network_connection_tracker, - std::unique_ptr - push_notification_manager); + std::unique_ptr push_notification_manager); ~HintsManager() override; @@ -73,13 +72,12 @@ class HintsManager : public OptimizationHintsComponentObserver, void Shutdown(); // Returns the OptimizationGuideDecision from |optimization_type_decision|. - static optimization_guide::OptimizationGuideDecision + static OptimizationGuideDecision GetOptimizationGuideDecisionFromOptimizationTypeDecision( - optimization_guide::OptimizationTypeDecision optimization_type_decision); + OptimizationTypeDecision optimization_type_decision); - // optimization_guide::OptimizationHintsComponentObserver implementation: - void OnHintsComponentAvailable( - const optimization_guide::HintsComponentInfo& info) override; + // OptimizationHintsComponentObserver implementation: + void OnHintsComponentAvailable(const HintsComponentInfo& info) override; // |next_update_closure| is called the next time OnHintsComponentAvailable() // is called and the corresponding hints have been updated. @@ -88,38 +86,37 @@ class HintsManager : public OptimizationHintsComponentObserver, // Registers the optimization types that have the potential for hints to be // called by consumers of the Optimization Guide. void RegisterOptimizationTypes( - const std::vector& - optimization_types); + const std::vector& optimization_types); // Returns the optimization types that are registered. - base::flat_set - registered_optimization_types() const { + base::flat_set registered_optimization_types() + const { return registered_optimization_types_; } // Returns whether there is an optimization allowlist loaded for // |optimization_type|. bool HasLoadedOptimizationAllowlist( - optimization_guide::proto::OptimizationType optimization_type); + proto::OptimizationType optimization_type); // Returns whether there is an optimization blocklist loaded for // |optimization_type|. bool HasLoadedOptimizationBlocklist( - optimization_guide::proto::OptimizationType optimization_type); + proto::OptimizationType optimization_type); // Returns the OptimizationTypeDecision based on the given parameters. // |optimization_metadata| will be populated, if applicable. - optimization_guide::OptimizationTypeDecision CanApplyOptimization( + OptimizationTypeDecision CanApplyOptimization( const GURL& navigation_url, - optimization_guide::proto::OptimizationType optimization_type, - optimization_guide::OptimizationMetadata* optimization_metadata); + proto::OptimizationType optimization_type, + OptimizationMetadata* optimization_metadata); // Invokes |callback| with the decision for |navigation_url| and // |optimization_type|, when sufficient information has been collected by // |this| to make the decision. Virtual for testing. virtual void CanApplyOptimizationAsync( const GURL& navigation_url, - optimization_guide::proto::OptimizationType optimization_type, - optimization_guide::OptimizationGuideDecisionCallback callback); + proto::OptimizationType optimization_type, + OptimizationGuideDecisionCallback callback); // Clears all fetched hints from |hint_cache_|. void ClearFetchedHints(); @@ -129,14 +126,13 @@ class HintsManager : public OptimizationHintsComponentObserver, void ClearHostKeyedHints(); // Returns the current batch update hints fetcher. - optimization_guide::HintsFetcher* batch_update_hints_fetcher() const { + HintsFetcher* batch_update_hints_fetcher() const { return batch_update_hints_fetcher_.get(); } // Overrides |hints_fetcher_factory| for testing. void SetHintsFetcherFactoryForTesting( - std::unique_ptr - hints_fetcher_factory); + std::unique_ptr hints_fetcher_factory); // Overrides |clock_| for testing. void SetClockForTesting(const base::Clock* clock); @@ -162,10 +158,10 @@ class HintsManager : public OptimizationHintsComponentObserver, void FetchHintsForURLs(std::vector target_urls, proto::RequestContext request_context); - // optimization_guide::PushNotificationManager::Delegate: + // PushNotificationManager::Delegate: void RemoveFetchedEntriesByHintKeys( base::OnceClosure on_success, - optimization_guide::proto::KeyRepresentation key_representation, + proto::KeyRepresentation key_representation, const base::flat_set& hint_keys) override; void PurgeFetchedEntries(base::OnceClosure on_success) override; @@ -174,50 +170,45 @@ class HintsManager : public OptimizationHintsComponentObserver, bool IsAllowedToFetchNavigationHints(const GURL& url); // Returns the hint cache for |this|. - optimization_guide::HintCache* hint_cache(); + HintCache* hint_cache(); // Returns the persistent store for |this|. - optimization_guide::OptimizationGuideStore* hint_store(); + OptimizationGuideStore* hint_store(); // Returns the push notification manager for |this|. May be nullptr; - optimization_guide::PushNotificationManager* push_notification_manager(); + PushNotificationManager* push_notification_manager(); // Add hints to the cache with the provided metadata. For testing only. - void AddHintForTesting( - const GURL& url, - optimization_guide::proto::OptimizationType optimization_type, - const absl::optional& metadata); + void AddHintForTesting(const GURL& url, + proto::OptimizationType optimization_type, + const absl::optional& metadata); private: friend class ::OptimizationGuideTestAppInterfaceWrapper; // Processes the optimization filters contained in the hints component. void ProcessOptimizationFilters( - const google::protobuf::RepeatedPtrField< - optimization_guide::proto::OptimizationFilter>& + const google::protobuf::RepeatedPtrField& allowlist_optimization_filters, - const google::protobuf::RepeatedPtrField< - optimization_guide::proto::OptimizationFilter>& + const google::protobuf::RepeatedPtrField& blocklist_optimization_filters); // Process a set of optimization filters. // // |is_allowlist| will be used to ensure that the filters are either uses as // allowlists or blocklists. - void ProcessOptimizationFilterSet( - const google::protobuf::RepeatedPtrField< - optimization_guide::proto::OptimizationFilter>& filters, - bool is_allowlist); + void ProcessOptimizationFilterSet(const google::protobuf::RepeatedPtrField< + proto::OptimizationFilter>& filters, + bool is_allowlist); // Callback run after the hint cache is fully initialized. At this point, // the HintsManager is ready to process hints. void OnHintCacheInitialized(); // Updates the cache with the latest hints sent by the Component Updater. - void UpdateComponentHints( - base::OnceClosure update_closure, - std::unique_ptr update_data, - std::unique_ptr config); + void UpdateComponentHints(base::OnceClosure update_closure, + std::unique_ptr update_data, + std::unique_ptr config); // Called when the hints have been fully updated with the latest hints from // the Component Updater. This is used as a signal during tests. @@ -246,8 +237,7 @@ class HintsManager : public OptimizationHintsComponentObserver, void OnHintsForActiveTabsFetched( const base::flat_set& hosts_fetched, const base::flat_set& urls_fetched, - absl::optional< - std::unique_ptr> + absl::optional> get_hints_response); // Called when the hints for a navigation have been fetched from the remote @@ -262,8 +252,7 @@ class HintsManager : public OptimizationHintsComponentObserver, const absl::optional& navigation_url, const base::flat_set& page_navigation_urls_requested, const base::flat_set& page_navigation_hosts_requested, - absl::optional< - std::unique_ptr> + absl::optional> get_hints_response); // Called when the fetched hints have been stored in |hint_cache| and are @@ -294,7 +283,7 @@ class HintsManager : public OptimizationHintsComponentObserver, // Called when the request to load a hint has completed. void OnHintLoaded(base::OnceClosure callback, - const optimization_guide::proto::Hint* loaded_hint) const; + const proto::Hint* loaded_hint) const; // Loads the hint if available for navigation to |url|. // |callback| is run when the request has finished regardless of whether there @@ -332,13 +321,13 @@ class HintsManager : public OptimizationHintsComponentObserver, // |navigation_url| and |optimization type}. bool HasAllInformationForDecisionAvailable( const GURL& navigation_url, - optimization_guide::proto::OptimizationType optimization_type); + proto::OptimizationType optimization_type); - optimization_guide::HintsFetcherFactory* GetHintsFetcherFactory(); + HintsFetcherFactory* GetHintsFetcherFactory(); // The information of the latest component delivered by // |optimization_guide_service_|. - absl::optional hints_component_info_; + absl::optional hints_component_info_; // Whether the component is currently being processed. bool is_processing_component_ = false; @@ -347,32 +336,26 @@ class HintsManager : public OptimizationHintsComponentObserver, // manager. // // Should only be read and modified on the UI thread. - base::flat_set - registered_optimization_types_; + base::flat_set registered_optimization_types_; // The set of optimization types that the component specified by // |component_info_| has optimization filters for. - base::flat_set - optimization_types_with_filter_; + base::flat_set optimization_types_with_filter_; // A map from optimization type to the host filter that holds the allowlist // for that type. - base::flat_map> + base::flat_map> allowlist_optimization_filters_; // A map from optimization type to the host filter that holds the blocklist // for that type. - base::flat_map> + base::flat_map> blocklist_optimization_filters_; // A map from URL to a map of callbacks keyed by their optimization type. - base::flat_map< - GURL, - base::flat_map< - optimization_guide::proto::OptimizationType, - std::vector>> + base::flat_map>> registered_callbacks_; // Whether |this| was created for an off the record profile. @@ -386,29 +369,28 @@ class HintsManager : public OptimizationHintsComponentObserver, // The hint cache that holds both hints received from the component and // fetched from the remote Optimization Guide Service. - std::unique_ptr hint_cache_; + std::unique_ptr hint_cache_; // The fetcher that handles making requests for hints for multiple hosts from // the remote Optimization Guide Service. - std::unique_ptr batch_update_hints_fetcher_; + std::unique_ptr batch_update_hints_fetcher_; // A cache keyed by navigation URL to the fetcher making a request for a hint // for that URL and/or host to the remote Optimization Guide Service that // keeps track of when an entry has been placed in the cache. - base::LRUCache> + base::LRUCache> page_navigation_hints_fetchers_; // The factory used to create hints fetchers. It is mostly used to create // new fetchers for use under the page navigation context, but will also be // used to create the initial fetcher for the batch update context. - std::unique_ptr - hints_fetcher_factory_; + std::unique_ptr hints_fetcher_factory_; // The top host provider that can be queried. Not owned. - raw_ptr top_host_provider_ = nullptr; + raw_ptr top_host_provider_ = nullptr; // The tab URL provider that can be queried. Not owned. - raw_ptr tab_url_provider_ = nullptr; + raw_ptr tab_url_provider_ = nullptr; // The timer used to schedule fetching hints from the remote Optimization // Guide Service. @@ -416,8 +398,7 @@ class HintsManager : public OptimizationHintsComponentObserver, // The class that handles push notification processing and informs |this| of // what to do through the implemented Delegate above. - std::unique_ptr - push_notification_manager_; + std::unique_ptr push_notification_manager_; // The clock used to schedule fetching from the remote Optimization Guide // Service. diff --git a/components/optimization_guide/core/hints_manager_unittest.cc b/components/optimization_guide/core/hints_manager_unittest.cc index 51a3106d7f837..d4f124c7174a4 100644 --- a/components/optimization_guide/core/hints_manager_unittest.cc +++ b/components/optimization_guide/core/hints_manager_unittest.cc @@ -54,69 +54,63 @@ constexpr int kUpdateFetchHintsTimeSecs = 61 * 60; // 1 hours and 1 minutes. const int kDefaultHostBloomFilterNumHashFunctions = 7; const int kDefaultHostBloomFilterNumBits = 511; -void PopulateBloomFilterWithDefaultHost( - optimization_guide::BloomFilter* bloom_filter) { +void PopulateBloomFilterWithDefaultHost(BloomFilter* bloom_filter) { bloom_filter->Add("host.com"); } -void AddBloomFilterToConfig( - optimization_guide::proto::OptimizationType optimization_type, - const optimization_guide::BloomFilter& bloom_filter, - int num_hash_functions, - int num_bits, - bool is_allowlist, - optimization_guide::proto::Configuration* config) { +void AddBloomFilterToConfig(proto::OptimizationType optimization_type, + const BloomFilter& bloom_filter, + int num_hash_functions, + int num_bits, + bool is_allowlist, + proto::Configuration* config) { std::string bloom_filter_data( reinterpret_cast(&bloom_filter.bytes()[0]), bloom_filter.bytes().size()); - optimization_guide::proto::OptimizationFilter* of_proto = + proto::OptimizationFilter* of_proto = is_allowlist ? config->add_optimization_allowlists() : config->add_optimization_blocklists(); of_proto->set_optimization_type(optimization_type); - std::unique_ptr bloom_filter_proto = - std::make_unique(); + std::unique_ptr bloom_filter_proto = + std::make_unique(); bloom_filter_proto->set_num_hash_functions(num_hash_functions); bloom_filter_proto->set_num_bits(num_bits); bloom_filter_proto->set_data(bloom_filter_data); of_proto->set_allocated_bloom_filter(bloom_filter_proto.release()); } -std::unique_ptr BuildHintsResponse( +std::unique_ptr BuildHintsResponse( const std::vector& hosts, const std::vector& urls) { - std::unique_ptr - get_hints_response = - std::make_unique(); + std::unique_ptr get_hints_response = + std::make_unique(); for (const auto& host : hosts) { - optimization_guide::proto::Hint* hint = get_hints_response->add_hints(); - hint->set_key_representation(optimization_guide::proto::HOST); + proto::Hint* hint = get_hints_response->add_hints(); + hint->set_key_representation(proto::HOST); hint->set_key(host); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->set_page_pattern("page pattern"); - optimization_guide::proto::Optimization* opt = - page_hint->add_allowlisted_optimizations(); - opt->set_optimization_type(optimization_guide::proto::DEFER_ALL_SCRIPT); + proto::Optimization* opt = page_hint->add_allowlisted_optimizations(); + opt->set_optimization_type(proto::DEFER_ALL_SCRIPT); } for (const auto& url : urls) { - optimization_guide::proto::Hint* hint = get_hints_response->add_hints(); - hint->set_key_representation(optimization_guide::proto::FULL_URL); + proto::Hint* hint = get_hints_response->add_hints(); + hint->set_key_representation(proto::FULL_URL); hint->set_key(url); hint->mutable_max_cache_duration()->set_seconds(60 * 60); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->set_page_pattern(url); - optimization_guide::proto::Optimization* opt = - page_hint->add_allowlisted_optimizations(); - opt->set_optimization_type( - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES); + proto::Optimization* opt = page_hint->add_allowlisted_optimizations(); + opt->set_optimization_type(proto::COMPRESS_PUBLIC_IMAGES); opt->mutable_public_image_metadata()->add_url("someurl"); } return get_hints_response; } void RunHintsFetchedCallbackWithResponse( - optimization_guide::HintsFetchedCallback hints_fetched_callback, - std::unique_ptr response) { + HintsFetchedCallback hints_fetched_callback, + std::unique_ptr response) { std::move(hints_fetched_callback).Run(std::move(response)); } @@ -137,14 +131,14 @@ SetUpDeferStartupActiveTabsHintsFetch(bool is_enabled) { params["defer_startup_active_tabs_hints_fetch"] = is_enabled ? "true" : "false"; scoped_feature_list->InitAndEnableFeatureWithParameters( - optimization_guide::features::kOptimizationHints, params); + features::kOptimizationHints, params); return scoped_feature_list; } } // namespace // A mock class implementation of TopHostProvider. -class FakeTopHostProvider : public optimization_guide::TopHostProvider { +class FakeTopHostProvider : public TopHostProvider { public: explicit FakeTopHostProvider(const std::vector& top_hosts) : top_hosts_(top_hosts) {} @@ -163,7 +157,7 @@ class FakeTopHostProvider : public optimization_guide::TopHostProvider { }; // A mock class implementation of TabUrlProvider. -class FakeTabUrlProvider : public optimization_guide::TabUrlProvider { +class FakeTabUrlProvider : public TabUrlProvider { public: const std::vector GetUrlsOfActiveTabs( const base::TimeDelta& duration_since_last_shown) override { @@ -190,7 +184,7 @@ enum class HintsFetcherEndState { // A mock class implementation of HintsFetcher. It will iterate through the // provided fetch states each time it is called. If it reaches the end of the // loop, it will just continue using the last fetch state. -class TestHintsFetcher : public optimization_guide::HintsFetcher { +class TestHintsFetcher : public HintsFetcher { public: TestHintsFetcher( scoped_refptr url_loader_factory, @@ -209,12 +203,10 @@ class TestHintsFetcher : public optimization_guide::HintsFetcher { bool FetchOptimizationGuideServiceHints( const std::vector& hosts, const std::vector& urls, - const base::flat_set& - optimization_types, - optimization_guide::proto::RequestContext request_context, + const base::flat_set& optimization_types, + proto::RequestContext request_context, const std::string& locale, - optimization_guide::HintsFetchedCallback hints_fetched_callback) - override { + HintsFetchedCallback hints_fetched_callback) override { HintsFetcherEndState fetch_state = num_fetches_requested_ < static_cast(fetch_states_.size()) ? fetch_states_[num_fetches_requested_] @@ -268,7 +260,7 @@ class TestHintsFetcher : public optimization_guide::HintsFetcher { // A mock class of HintsFetcherFactory that returns instances of // TestHintsFetchers with the provided fetch state. -class TestHintsFetcherFactory : public optimization_guide::HintsFetcherFactory { +class TestHintsFetcherFactory : public HintsFetcherFactory { public: TestHintsFetcherFactory( scoped_refptr url_loader_factory, @@ -282,7 +274,7 @@ class TestHintsFetcherFactory : public optimization_guide::HintsFetcherFactory { network_connection_tracker), fetch_states_(fetch_states) {} - std::unique_ptr BuildInstance() override { + std::unique_ptr BuildInstance() override { return std::make_unique( url_loader_factory_, optimization_guide_service_url_, pref_service_, network_connection_tracker_, fetch_states_); @@ -292,12 +284,11 @@ class TestHintsFetcherFactory : public optimization_guide::HintsFetcherFactory { std::vector fetch_states_; }; -class HintsManagerTest - : public optimization_guide::ProtoDatabaseProviderTestBase { +class HintsManagerTest : public ProtoDatabaseProviderTestBase { public: HintsManagerTest() { scoped_feature_list_.InitAndEnableFeatureWithParameters( - optimization_guide::features::kOptimizationHints, + features::kOptimizationHints, GetOptimizationHintsDefaultFeatureParams()); } ~HintsManagerTest() override = default; @@ -306,23 +297,22 @@ class HintsManagerTest HintsManagerTest& operator=(const HintsManagerTest&) = delete; void SetUp() override { - optimization_guide::ProtoDatabaseProviderTestBase::SetUp(); + ProtoDatabaseProviderTestBase::SetUp(); CreateHintsManager(/*top_host_provider=*/nullptr); } void TearDown() override { ResetHintsManager(); - optimization_guide::ProtoDatabaseProviderTestBase::TearDown(); + ProtoDatabaseProviderTestBase::TearDown(); } - void CreateHintsManager( - optimization_guide::TopHostProvider* top_host_provider) { + void CreateHintsManager(TopHostProvider* top_host_provider) { if (hints_manager_) ResetHintsManager(); pref_service_ = std::make_unique(); - optimization_guide::prefs::RegisterProfilePrefs(pref_service_->registry()); + prefs::RegisterProfilePrefs(pref_service_->registry()); pref_service_->registry()->RegisterBooleanPref( data_reduction_proxy::prefs::kDataSaverEnabled, false); unified_consent::UnifiedConsentService::RegisterPrefs( @@ -332,7 +322,7 @@ class HintsManagerTest base::MakeRefCounted( &test_url_loader_factory_); - hint_store_ = std::make_unique( + hint_store_ = std::make_unique( db_provider_.get(), temp_dir(), task_environment_.GetMainThreadTaskRunner()); @@ -361,7 +351,7 @@ class HintsManagerTest } void ProcessInvalidHintsComponentInfo(const std::string& version) { - optimization_guide::HintsComponentInfo info( + HintsComponentInfo info( base::Version(version), temp_dir().Append(FILE_PATH_LITERAL("notaconfigfile"))); @@ -372,7 +362,7 @@ class HintsManagerTest } void ProcessHintsComponentInfoWithBadConfig(const std::string& version) { - optimization_guide::HintsComponentInfo info( + HintsComponentInfo info( base::Version(version), temp_dir().Append(FILE_PATH_LITERAL("badconfig.pb"))); ASSERT_EQ(7, base::WriteFile(info.path, "garbage", 7)); @@ -381,10 +371,10 @@ class HintsManagerTest RunUntilIdle(); } - void ProcessHints(const optimization_guide::proto::Configuration& config, + void ProcessHints(const proto::Configuration& config, const std::string& version, bool should_wait = true) { - optimization_guide::HintsComponentInfo info( + HintsComponentInfo info( base::Version(version), temp_dir().Append(FILE_PATH_LITERAL("somefile.pb"))); ASSERT_NO_FATAL_FAILURE(WriteConfigToFile(config, info.path)); @@ -399,30 +389,28 @@ class HintsManagerTest void InitializeWithDefaultConfig(const std::string& version, bool should_wait = true) { - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint1 = config.add_hints(); + proto::Configuration config; + proto::Hint* hint1 = config.add_hints(); hint1->set_key("somedomain.org"); - hint1->set_key_representation(optimization_guide::proto::HOST); + hint1->set_key_representation(proto::HOST); hint1->set_version("someversion"); - optimization_guide::proto::PageHint* page_hint1 = hint1->add_page_hints(); + proto::PageHint* page_hint1 = hint1->add_page_hints(); page_hint1->set_page_pattern("/news/"); - optimization_guide::proto::Optimization* default_opt = + proto::Optimization* default_opt = page_hint1->add_allowlisted_optimizations(); - default_opt->set_optimization_type(optimization_guide::proto::NOSCRIPT); + default_opt->set_optimization_type(proto::NOSCRIPT); // Add another hint so somedomain.org hint is not in-memory initially. - optimization_guide::proto::Hint* hint2 = config.add_hints(); + proto::Hint* hint2 = config.add_hints(); hint2->set_key("somedomain2.org"); - hint2->set_key_representation(optimization_guide::proto::HOST); + hint2->set_key_representation(proto::HOST); hint2->set_version("someversion"); - optimization_guide::proto::Optimization* opt = - hint2->add_allowlisted_optimizations(); - opt->set_optimization_type(optimization_guide::proto::NOSCRIPT); + proto::Optimization* opt = hint2->add_allowlisted_optimizations(); + opt->set_optimization_type(proto::NOSCRIPT); ProcessHints(config, version, should_wait); } - std::unique_ptr - BuildTestHintsFetcherFactory( + std::unique_ptr BuildTestHintsFetcherFactory( const std::vector& fetch_states) { return std::make_unique( url_loader_factory_, GURL("https://hintsserver.com"), pref_service(), @@ -438,8 +426,7 @@ class HintsManagerTest // |optimization_types|. std::unique_ptr CreateTestNavigationData( const GURL& url, - const std::vector& - optimization_types) { + const std::vector& optimization_types) { auto navigation_data = std::make_unique( /*navigation_id=*/1, /*navigation_start*/ base::TimeTicks::Now()); navigation_data->set_navigation_url(url); @@ -497,7 +484,7 @@ class HintsManagerTest } private: - void WriteConfigToFile(const optimization_guide::proto::Configuration& config, + void WriteConfigToFile(const proto::Configuration& config, const base::FilePath& filePath) { std::string serialized_config; ASSERT_TRUE(config.SerializeToString(&serialized_config)); @@ -509,7 +496,7 @@ class HintsManagerTest base::test::TaskEnvironment task_environment_{ base::test::TaskEnvironment::TimeSource::MOCK_TIME}; base::test::ScopedFeatureList scoped_feature_list_; - std::unique_ptr hint_store_; + std::unique_ptr hint_store_; std::unique_ptr tab_url_provider_; std::unique_ptr hints_manager_; std::unique_ptr pref_service_; @@ -520,24 +507,24 @@ class HintsManagerTest TEST_F(HintsManagerTest, ProcessHintsWithValidCommandLineOverride) { base::HistogramTester histogram_tester; - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint = config.add_hints(); + proto::Configuration config; + proto::Hint* hint = config.add_hints(); hint->set_key("somedomain.org"); - hint->set_key_representation(optimization_guide::proto::HOST); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + hint->set_key_representation(proto::HOST); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->set_page_pattern("noscript_default_2g"); - optimization_guide::proto::Optimization* optimization = + proto::Optimization* optimization = page_hint->add_allowlisted_optimizations(); - optimization->set_optimization_type(optimization_guide::proto::NOSCRIPT); - optimization_guide::BloomFilter bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + optimization->set_optimization_type(proto::NOSCRIPT); + BloomFilter bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&bloom_filter); - AddBloomFilterToConfig(optimization_guide::proto::LITE_PAGE_REDIRECT, - bloom_filter, kDefaultHostBloomFilterNumHashFunctions, + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, /*is_allowlist=*/false, &config); - AddBloomFilterToConfig(optimization_guide::proto::PERFORMANCE_HINTS, - bloom_filter, kDefaultHostBloomFilterNumHashFunctions, + AddBloomFilterToConfig(proto::PERFORMANCE_HINTS, bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, /*is_allowlist=*/true, &config); @@ -546,16 +533,14 @@ TEST_F(HintsManagerTest, ProcessHintsWithValidCommandLineOverride) { base::Base64Encode(encoded_config, &encoded_config); base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( - optimization_guide::switches::kHintsProtoOverride, encoded_config); + switches::kHintsProtoOverride, encoded_config); CreateHintsManager(/*top_host_provider=*/nullptr); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); // The below histogram should not be recorded since hints weren't coming // directly from the component. - histogram_tester.ExpectUniqueSample( - "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kSuccess, 1); + histogram_tester.ExpectUniqueSample("OptimizationGuide.ProcessHintsResult", + ProcessHintsComponentResult::kSuccess, 1); // However, we still expect the local histogram for the hints being updated to // be recorded. histogram_tester.ExpectUniqueSample( @@ -567,24 +552,23 @@ TEST_F(HintsManagerTest, ProcessHintsWithValidCommandLineOverride) { RunUntilIdle(); EXPECT_TRUE(hints_manager()->HasLoadedOptimizationBlocklist( - optimization_guide::proto::LITE_PAGE_REDIRECT)); + proto::LITE_PAGE_REDIRECT)); EXPECT_FALSE(hints_manager()->HasLoadedOptimizationAllowlist( - optimization_guide::proto::PERFORMANCE_HINTS)); + proto::PERFORMANCE_HINTS)); // Now register a new type with an allowlist that has not yet been loaded. - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::PERFORMANCE_HINTS}); + hints_manager()->RegisterOptimizationTypes({proto::PERFORMANCE_HINTS}); RunUntilIdle(); EXPECT_TRUE(hints_manager()->HasLoadedOptimizationAllowlist( - optimization_guide::proto::PERFORMANCE_HINTS)); + proto::PERFORMANCE_HINTS)); } TEST_F(HintsManagerTest, ProcessHintsWithInvalidCommandLineOverride) { base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( - optimization_guide::switches::kHintsProtoOverride, "this-is-not-a-proto"); + switches::kHintsProtoOverride, "this-is-not-a-proto"); CreateHintsManager(/*top_host_provider=*/nullptr); // The below histogram should not be recorded since hints weren't coming @@ -597,15 +581,15 @@ TEST_F(HintsManagerTest, ProcessHintsWithInvalidCommandLineOverride) { TEST_F(HintsManagerTest, ProcessHintsWithCommandLineOverrideShouldNotBeOverriddenByNewComponent) { - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint = config.add_hints(); + proto::Configuration config; + proto::Hint* hint = config.add_hints(); hint->set_key("somedomain.org"); - hint->set_key_representation(optimization_guide::proto::HOST); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + hint->set_key_representation(proto::HOST); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->set_page_pattern("noscript_default_2g"); - optimization_guide::proto::Optimization* optimization = + proto::Optimization* optimization = page_hint->add_allowlisted_optimizations(); - optimization->set_optimization_type(optimization_guide::proto::NOSCRIPT); + optimization->set_optimization_type(proto::NOSCRIPT); std::string encoded_config; config.SerializeToString(&encoded_config); @@ -614,11 +598,11 @@ TEST_F(HintsManagerTest, { base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( - optimization_guide::switches::kHintsProtoOverride, encoded_config); + switches::kHintsProtoOverride, encoded_config); CreateHintsManager(/*top_host_provider=*/nullptr); - histogram_tester.ExpectUniqueSample( - "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kSuccess, 1); + histogram_tester.ExpectUniqueSample("OptimizationGuide.ProcessHintsResult", + ProcessHintsComponentResult::kSuccess, + 1); histogram_tester.ExpectUniqueSample( "OptimizationGuide.UpdateComponentHints.Result", true, 1); } @@ -637,34 +621,33 @@ TEST_F(HintsManagerTest, } TEST_F(HintsManagerTest, ParseTwoConfigVersions) { - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint1 = config.add_hints(); + proto::Configuration config; + proto::Hint* hint1 = config.add_hints(); hint1->set_key("somedomain.org"); - hint1->set_key_representation(optimization_guide::proto::HOST); + hint1->set_key_representation(proto::HOST); hint1->set_version("someversion"); - optimization_guide::proto::PageHint* page_hint1 = hint1->add_page_hints(); + proto::PageHint* page_hint1 = hint1->add_page_hints(); page_hint1->set_page_pattern("/news/"); - optimization_guide::proto::Optimization* optimization1 = + proto::Optimization* optimization1 = page_hint1->add_allowlisted_optimizations(); - optimization1->set_optimization_type( - optimization_guide::proto::RESOURCE_LOADING); + optimization1->set_optimization_type(proto::RESOURCE_LOADING); // Test the first time parsing the config. { base::HistogramTester histogram_tester; InitializeWithDefaultConfig("1.0.0.0"); - histogram_tester.ExpectUniqueSample( - "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kSuccess, 1); + histogram_tester.ExpectUniqueSample("OptimizationGuide.ProcessHintsResult", + ProcessHintsComponentResult::kSuccess, + 1); } // Test the second time parsing the config. This should also update the hints. { base::HistogramTester histogram_tester; InitializeWithDefaultConfig("2.0.0.0"); - histogram_tester.ExpectUniqueSample( - "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kSuccess, 1); + histogram_tester.ExpectUniqueSample("OptimizationGuide.ProcessHintsResult", + ProcessHintsComponentResult::kSuccess, + 1); } } @@ -673,9 +656,9 @@ TEST_F(HintsManagerTest, ParseInvalidConfigVersions) { { base::HistogramTester histogram_tester; InitializeWithDefaultConfig("1.0.0.0"); - histogram_tester.ExpectUniqueSample( - "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kSuccess, 1); + histogram_tester.ExpectUniqueSample("OptimizationGuide.ProcessHintsResult", + ProcessHintsComponentResult::kSuccess, + 1); } { @@ -685,9 +668,7 @@ TEST_F(HintsManagerTest, ParseInvalidConfigVersions) { // for the hints to not be updated. histogram_tester.ExpectUniqueSample( "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult:: - kFailedInvalidConfiguration, - 1); + ProcessHintsComponentResult::kFailedInvalidConfiguration, 1); } } @@ -700,9 +681,7 @@ TEST_F(HintsManagerTest, ComponentProcessingWhileShutdown) { "OptimizationGuide.ProcessingComponentAtShutdown", true, 1); EXPECT_TRUE( - pref_service() - ->GetString(optimization_guide::prefs::kPendingHintsProcessingVersion) - .empty()); + pref_service()->GetString(prefs::kPendingHintsProcessingVersion).empty()); } TEST_F(HintsManagerTest, ParseOlderConfigVersions) { @@ -710,9 +689,9 @@ TEST_F(HintsManagerTest, ParseOlderConfigVersions) { { base::HistogramTester histogram_tester; InitializeWithDefaultConfig("10.0.0.0"); - histogram_tester.ExpectUniqueSample( - "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kSuccess, 1); + histogram_tester.ExpectUniqueSample("OptimizationGuide.ProcessHintsResult", + ProcessHintsComponentResult::kSuccess, + 1); } // Test the second time parsing the config. This will be treated by the cache @@ -724,9 +703,7 @@ TEST_F(HintsManagerTest, ParseOlderConfigVersions) { // for the hints to not be updated. histogram_tester.ExpectUniqueSample( "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult:: - kSkippedProcessingHints, - 1); + ProcessHintsComponentResult::kSkippedProcessingHints, 1); } } @@ -737,9 +714,9 @@ TEST_F(HintsManagerTest, ParseDuplicateConfigVersions) { { base::HistogramTester histogram_tester; InitializeWithDefaultConfig(version); - histogram_tester.ExpectUniqueSample( - "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kSuccess, 1); + histogram_tester.ExpectUniqueSample("OptimizationGuide.ProcessHintsResult", + ProcessHintsComponentResult::kSuccess, + 1); } // Test the second time parsing the config. This will be treated by the cache @@ -749,9 +726,7 @@ TEST_F(HintsManagerTest, ParseDuplicateConfigVersions) { InitializeWithDefaultConfig(version); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult:: - kSkippedProcessingHints, - 1); + ProcessHintsComponentResult::kSkippedProcessingHints, 1); } } @@ -760,13 +735,12 @@ TEST_F(HintsManagerTest, ComponentInfoDidNotContainConfig) { ProcessInvalidHintsComponentInfo("1.0.0.0"); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kFailedReadingFile, 1); + ProcessHintsComponentResult::kFailedReadingFile, 1); } TEST_F(HintsManagerTest, ProcessHintsWithExistingPref) { // Write hints processing pref for version 2.0.0. - pref_service()->SetString( - optimization_guide::prefs::kPendingHintsProcessingVersion, "2.0.0"); + pref_service()->SetString(prefs::kPendingHintsProcessingVersion, "2.0.0"); // Verify config not processed for same version (2.0.0) and pref not cleared. { @@ -774,36 +748,29 @@ TEST_F(HintsManagerTest, ProcessHintsWithExistingPref) { InitializeWithDefaultConfig("2.0.0"); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult:: - kFailedFinishProcessing, - 1); - EXPECT_FALSE( - pref_service() - ->GetString( - optimization_guide::prefs::kPendingHintsProcessingVersion) - .empty()); + ProcessHintsComponentResult::kFailedFinishProcessing, 1); + EXPECT_FALSE(pref_service() + ->GetString(prefs::kPendingHintsProcessingVersion) + .empty()); } // Now verify config is processed for different version and pref cleared. { base::HistogramTester histogram_tester; InitializeWithDefaultConfig("3.0.0"); - EXPECT_TRUE( - pref_service() - ->GetString( - optimization_guide::prefs::kPendingHintsProcessingVersion) - .empty()); - histogram_tester.ExpectUniqueSample( - "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kSuccess, 1); + EXPECT_TRUE(pref_service() + ->GetString(prefs::kPendingHintsProcessingVersion) + .empty()); + histogram_tester.ExpectUniqueSample("OptimizationGuide.ProcessHintsResult", + ProcessHintsComponentResult::kSuccess, + 1); } } TEST_F(HintsManagerTest, ProcessHintsWithExistingPrefDoesNotClearOrCountAsMidProcessing) { // Write hints processing pref for version 2.0.0. - pref_service()->SetString( - optimization_guide::prefs::kPendingHintsProcessingVersion, "2.0.0"); + pref_service()->SetString(prefs::kPendingHintsProcessingVersion, "2.0.0"); // Verify component for same version counts as "failed". base::HistogramTester histogram_tester; @@ -812,38 +779,31 @@ TEST_F(HintsManagerTest, histogram_tester.ExpectUniqueSample( "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kFailedFinishProcessing, - 1); + ProcessHintsComponentResult::kFailedFinishProcessing, 1); // Verify that pref still not cleared at shutdown and was not counted as // mid-processing. histogram_tester.ExpectUniqueSample( "OptimizationGuide.ProcessingComponentAtShutdown", false, 1); EXPECT_FALSE( - pref_service() - ->GetString(optimization_guide::prefs::kPendingHintsProcessingVersion) - .empty()); + pref_service()->GetString(prefs::kPendingHintsProcessingVersion).empty()); } TEST_F(HintsManagerTest, ProcessHintsWithInvalidPref) { // Create pref file with invalid version. - pref_service()->SetString( - optimization_guide::prefs::kPendingHintsProcessingVersion, "bad-2.0.0"); + pref_service()->SetString(prefs::kPendingHintsProcessingVersion, "bad-2.0.0"); // Verify config not processed for existing pref with bad value but // that the pref is cleared. { base::HistogramTester histogram_tester; InitializeWithDefaultConfig("2.0.0"); - EXPECT_TRUE( - pref_service() - ->GetString( - optimization_guide::prefs::kPendingHintsProcessingVersion) - .empty()); + EXPECT_TRUE(pref_service() + ->GetString(prefs::kPendingHintsProcessingVersion) + .empty()); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult:: - kFailedPreviouslyAttemptedVersionInvalid, + ProcessHintsComponentResult::kFailedPreviouslyAttemptedVersionInvalid, 1); } @@ -851,14 +811,12 @@ TEST_F(HintsManagerTest, ProcessHintsWithInvalidPref) { { base::HistogramTester histogram_tester; InitializeWithDefaultConfig("2.0.0"); - EXPECT_TRUE( - pref_service() - ->GetString( - optimization_guide::prefs::kPendingHintsProcessingVersion) - .empty()); - histogram_tester.ExpectUniqueSample( - "OptimizationGuide.ProcessHintsResult", - optimization_guide::ProcessHintsComponentResult::kSuccess, 1); + EXPECT_TRUE(pref_service() + ->GetString(prefs::kPendingHintsProcessingVersion) + .empty()); + histogram_tester.ExpectUniqueSample("OptimizationGuide.ProcessHintsResult", + ProcessHintsComponentResult::kSuccess, + 1); } } @@ -908,20 +866,20 @@ TEST_F(HintsManagerTest, OnNavigationStartOrRedirectNoHost) { } TEST_F(HintsManagerTest, OptimizationFiltersAreOnlyLoadedIfTypeIsRegistered) { - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&bloom_filter); - AddBloomFilterToConfig(optimization_guide::proto::LITE_PAGE_REDIRECT, - bloom_filter, kDefaultHostBloomFilterNumHashFunctions, + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, /*is_allowlist=*/false, &config); - AddBloomFilterToConfig(optimization_guide::proto::NOSCRIPT, bloom_filter, + AddBloomFilterToConfig(proto::NOSCRIPT, bloom_filter, kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, /*is_allowlist=*/false, &config); - AddBloomFilterToConfig(optimization_guide::proto::DEFER_ALL_SCRIPT, - bloom_filter, kDefaultHostBloomFilterNumHashFunctions, + AddBloomFilterToConfig(proto::DEFER_ALL_SCRIPT, bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, /*is_allowlist=*/true, &config); @@ -944,27 +902,25 @@ TEST_F(HintsManagerTest, OptimizationFiltersAreOnlyLoadedIfTypeIsRegistered) { base::RunLoop run_loop; hints_manager()->ListenForNextUpdateForTesting(run_loop.QuitClosure()); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); run_loop.Run(); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.LitePageRedirect", - optimization_guide::OptimizationFilterStatus::kFoundServerFilterConfig, - 1); + OptimizationFilterStatus::kFoundServerFilterConfig, 1); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.LitePageRedirect", - optimization_guide::OptimizationFilterStatus::kCreatedServerFilter, 1); + OptimizationFilterStatus::kCreatedServerFilter, 1); histogram_tester.ExpectTotalCount( "OptimizationGuide.OptimizationFilterStatus.NoScript", 0); histogram_tester.ExpectTotalCount( "OptimizationGuide.OptimizationFilterStatus.DeferAllScript", 0); EXPECT_TRUE(hints_manager()->HasLoadedOptimizationBlocklist( - optimization_guide::proto::LITE_PAGE_REDIRECT)); - EXPECT_FALSE(hints_manager()->HasLoadedOptimizationBlocklist( - optimization_guide::proto::NOSCRIPT)); + proto::LITE_PAGE_REDIRECT)); + EXPECT_FALSE( + hints_manager()->HasLoadedOptimizationBlocklist(proto::NOSCRIPT)); EXPECT_FALSE(hints_manager()->HasLoadedOptimizationAllowlist( - optimization_guide::proto::DEFER_ALL_SCRIPT)); + proto::DEFER_ALL_SCRIPT)); } // Re-registering the same optimization type does not re-load the filter. @@ -973,8 +929,7 @@ TEST_F(HintsManagerTest, OptimizationFiltersAreOnlyLoadedIfTypeIsRegistered) { base::RunLoop run_loop; hints_manager()->ListenForNextUpdateForTesting(run_loop.QuitClosure()); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); run_loop.Run(); histogram_tester.ExpectTotalCount( @@ -992,8 +947,7 @@ TEST_F(HintsManagerTest, OptimizationFiltersAreOnlyLoadedIfTypeIsRegistered) { base::RunLoop run_loop; hints_manager()->ListenForNextUpdateForTesting(run_loop.QuitClosure()); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::PERFORMANCE_HINTS}); + hints_manager()->RegisterOptimizationTypes({proto::PERFORMANCE_HINTS}); run_loop.Run(); histogram_tester.ExpectTotalCount( @@ -1012,160 +966,143 @@ TEST_F(HintsManagerTest, OptimizationFiltersAreOnlyLoadedIfTypeIsRegistered) { base::RunLoop run_loop; hints_manager()->ListenForNextUpdateForTesting(run_loop.QuitClosure()); hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::NOSCRIPT, - optimization_guide::proto::DEFER_ALL_SCRIPT}); + {proto::NOSCRIPT, proto::DEFER_ALL_SCRIPT}); run_loop.Run(); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.LitePageRedirect", - optimization_guide::OptimizationFilterStatus::kFoundServerFilterConfig, - 1); + OptimizationFilterStatus::kFoundServerFilterConfig, 1); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.LitePageRedirect", - optimization_guide::OptimizationFilterStatus::kCreatedServerFilter, 1); + OptimizationFilterStatus::kCreatedServerFilter, 1); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.NoScript", - optimization_guide::OptimizationFilterStatus::kFoundServerFilterConfig, - 1); + OptimizationFilterStatus::kFoundServerFilterConfig, 1); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.NoScript", - optimization_guide::OptimizationFilterStatus::kCreatedServerFilter, 1); + OptimizationFilterStatus::kCreatedServerFilter, 1); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.DeferAllScript", - optimization_guide::OptimizationFilterStatus::kFoundServerFilterConfig, - 1); + OptimizationFilterStatus::kFoundServerFilterConfig, 1); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.DeferAllScript", - optimization_guide::OptimizationFilterStatus::kCreatedServerFilter, 1); - EXPECT_TRUE(hints_manager()->HasLoadedOptimizationBlocklist( - optimization_guide::proto::LITE_PAGE_REDIRECT)); + OptimizationFilterStatus::kCreatedServerFilter, 1); EXPECT_TRUE(hints_manager()->HasLoadedOptimizationBlocklist( - optimization_guide::proto::NOSCRIPT)); + proto::LITE_PAGE_REDIRECT)); + EXPECT_TRUE( + hints_manager()->HasLoadedOptimizationBlocklist(proto::NOSCRIPT)); EXPECT_TRUE(hints_manager()->HasLoadedOptimizationAllowlist( - optimization_guide::proto::DEFER_ALL_SCRIPT)); + proto::DEFER_ALL_SCRIPT)); } } TEST_F(HintsManagerTest, OptimizationFiltersOnlyLoadOncePerType) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); base::HistogramTester histogram_tester; - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter blocklist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter blocklist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&blocklist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/false, &config); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/false, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/false, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/false, &config); // Make sure it will only load one of an allowlist or a blocklist. - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/true, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/true, &config); ProcessHints(config, "1.0.0.0"); // We found 2 LPR blocklists: parsed one and duped the other. histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.LitePageRedirect", - optimization_guide::OptimizationFilterStatus::kFoundServerFilterConfig, - 3); + OptimizationFilterStatus::kFoundServerFilterConfig, 3); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.LitePageRedirect", - optimization_guide::OptimizationFilterStatus::kCreatedServerFilter, 1); + OptimizationFilterStatus::kCreatedServerFilter, 1); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.LitePageRedirect", - optimization_guide::OptimizationFilterStatus:: - kFailedServerFilterDuplicateConfig, - 2); + OptimizationFilterStatus::kFailedServerFilterDuplicateConfig, 2); } TEST_F(HintsManagerTest, InvalidOptimizationFilterNotLoaded) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); base::HistogramTester histogram_tester; - int too_many_bits = - optimization_guide::features::MaxServerBloomFilterByteSize() * 8 + 1; + int too_many_bits = features::MaxServerBloomFilterByteSize() * 8 + 1; - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter blocklist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, too_many_bits); + proto::Configuration config; + BloomFilter blocklist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + too_many_bits); PopulateBloomFilterWithDefaultHost(&blocklist_bloom_filter); - AddBloomFilterToConfig(optimization_guide::proto::LITE_PAGE_REDIRECT, - blocklist_bloom_filter, + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, kDefaultHostBloomFilterNumHashFunctions, too_many_bits, /*is_allowlist=*/false, &config); ProcessHints(config, "1.0.0.0"); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.LitePageRedirect", - optimization_guide::OptimizationFilterStatus::kFoundServerFilterConfig, - 1); + OptimizationFilterStatus::kFoundServerFilterConfig, 1); histogram_tester.ExpectBucketCount( "OptimizationGuide.OptimizationFilterStatus.LitePageRedirect", - optimization_guide::OptimizationFilterStatus::kFailedServerFilterTooBig, - 1); + OptimizationFilterStatus::kFailedServerFilterTooBig, 1); EXPECT_FALSE(hints_manager()->HasLoadedOptimizationBlocklist( - optimization_guide::proto::LITE_PAGE_REDIRECT)); + proto::LITE_PAGE_REDIRECT)); } TEST_F(HintsManagerTest, CanApplyOptimizationUrlWithNoHost) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter blocklist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter blocklist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&blocklist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/false, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/false, &config); ProcessHints(config, "1.0.0.0"); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - GURL("urlwithnohost"), optimization_guide::proto::LITE_PAGE_REDIRECT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(GURL("urlwithnohost"), + proto::LITE_PAGE_REDIRECT, + /*optimization_metadata=*/nullptr); // Make sure decisions are logged correctly. - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNoHintAvailable, + EXPECT_EQ(OptimizationTypeDecision::kNoHintAvailable, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationHasFilterForTypeButNotLoadedYet) { - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter blocklist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter blocklist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&blocklist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/false, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/false, &config); ProcessHints(config, "1.0.0.0"); // Append the switch for processing hints to force the filter to not get // loaded. base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kHintsProtoOverride); - - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - GURL("https://whatever.com/123"), - optimization_guide::proto::LITE_PAGE_REDIRECT, - /*optimization_metadata=*/nullptr); - - EXPECT_EQ(optimization_guide::OptimizationTypeDecision:: - kHadOptimizationFilterButNotLoadedInTime, + switches::kHintsProtoOverride); + + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(GURL("https://whatever.com/123"), + proto::LITE_PAGE_REDIRECT, + /*optimization_metadata=*/nullptr); + + EXPECT_EQ(OptimizationTypeDecision::kHadOptimizationFilterButNotLoadedInTime, optimization_type_decision); // Run until idle to ensure we don't crash because the test object has gone @@ -1175,288 +1112,262 @@ TEST_F(HintsManagerTest, CanApplyOptimizationHasFilterForTypeButNotLoadedYet) { TEST_F(HintsManagerTest, CanApplyOptimizationHasLoadedFilterForTypeUrlInAllowlist) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter allowlist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter allowlist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&allowlist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, allowlist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/true, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, allowlist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/true, &config); ProcessHints(config, "1.0.0.0"); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - GURL("https://m.host.com/123"), - optimization_guide::proto::LITE_PAGE_REDIRECT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(GURL("https://m.host.com/123"), + proto::LITE_PAGE_REDIRECT, + /*optimization_metadata=*/nullptr); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision:: - kAllowedByOptimizationFilter, + EXPECT_EQ(OptimizationTypeDecision::kAllowedByOptimizationFilter, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationHasLoadedFilterForTypeUrlInBlocklist) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter blocklist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter blocklist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&blocklist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/false, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/false, &config); ProcessHints(config, "1.0.0.0"); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - GURL("https://m.host.com/123"), - optimization_guide::proto::LITE_PAGE_REDIRECT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(GURL("https://m.host.com/123"), + proto::LITE_PAGE_REDIRECT, + /*optimization_metadata=*/nullptr); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision:: - kNotAllowedByOptimizationFilter, + EXPECT_EQ(OptimizationTypeDecision::kNotAllowedByOptimizationFilter, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationHasLoadedFilterForTypeUrlNotInAllowlistFilter) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter allowlist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter allowlist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&allowlist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, allowlist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/true, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, allowlist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/true, &config); ProcessHints(config, "1.0.0.0"); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - GURL("https://whatever.com/123"), - optimization_guide::proto::LITE_PAGE_REDIRECT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(GURL("https://whatever.com/123"), + proto::LITE_PAGE_REDIRECT, + /*optimization_metadata=*/nullptr); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision:: - kNotAllowedByOptimizationFilter, + EXPECT_EQ(OptimizationTypeDecision::kNotAllowedByOptimizationFilter, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationHasLoadedFilterForTypeUrlNotInBlocklistFilter) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter blocklist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter blocklist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&blocklist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/false, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/false, &config); ProcessHints(config, "1.0.0.0"); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - GURL("https://whatever.com/123"), - optimization_guide::proto::LITE_PAGE_REDIRECT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(GURL("https://whatever.com/123"), + proto::LITE_PAGE_REDIRECT, + /*optimization_metadata=*/nullptr); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision:: - kAllowedByOptimizationFilter, + EXPECT_EQ(OptimizationTypeDecision::kAllowedByOptimizationFilter, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationOptimizationTypeAllowlistedAtTopLevel) { - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint1 = config.add_hints(); + proto::Configuration config; + proto::Hint* hint1 = config.add_hints(); hint1->set_key("somedomain.org"); - hint1->set_key_representation(optimization_guide::proto::HOST); + hint1->set_key_representation(proto::HOST); hint1->set_version("someversion"); - optimization_guide::proto::Optimization* opt1 = - hint1->add_allowlisted_optimizations(); - opt1->set_optimization_type(optimization_guide::proto::RESOURCE_LOADING); + proto::Optimization* opt1 = hint1->add_allowlisted_optimizations(); + opt1->set_optimization_type(proto::RESOURCE_LOADING); ProcessHints(config, "1.0.0.0"); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::RESOURCE_LOADING}); + hints_manager()->RegisterOptimizationTypes({proto::RESOURCE_LOADING}); - auto navigation_data = CreateTestNavigationData( - url_with_hints(), {optimization_guide::proto::RESOURCE_LOADING}); + auto navigation_data = + CreateTestNavigationData(url_with_hints(), {proto::RESOURCE_LOADING}); base::RunLoop run_loop; CallOnNavigationStartOrRedirect(navigation_data.get(), run_loop.QuitClosure()); run_loop.Run(); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::RESOURCE_LOADING, &optimization_metadata); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint, + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::RESOURCE_LOADING, + &optimization_metadata); + EXPECT_EQ(OptimizationTypeDecision::kAllowedByHint, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationHasPageHintButNoMatchingOptType) { InitializeWithDefaultConfig("1.0.0.0"); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); - auto navigation_data = CreateTestNavigationData( - url_with_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(url_with_hints(), {proto::DEFER_ALL_SCRIPT}); base::RunLoop run_loop; CallOnNavigationStartOrRedirect(navigation_data.get(), run_loop.QuitClosure()); run_loop.Run(); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::DEFER_ALL_SCRIPT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::DEFER_ALL_SCRIPT, + /*optimization_metadata=*/nullptr); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNotAllowedByHint, + EXPECT_EQ(OptimizationTypeDecision::kNotAllowedByHint, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationAndPopulatesPerformanceHintsMetadata) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::PERFORMANCE_HINTS}); - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint = config.add_hints(); + hints_manager()->RegisterOptimizationTypes({proto::PERFORMANCE_HINTS}); + proto::Configuration config; + proto::Hint* hint = config.add_hints(); hint->set_key("somedomain.org"); - hint->set_key_representation(optimization_guide::proto::HOST); + hint->set_key_representation(proto::HOST); hint->set_version("someversion"); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->set_page_pattern("/news/"); - optimization_guide::proto::Optimization* opt = - page_hint->add_allowlisted_optimizations(); - opt->set_optimization_type(optimization_guide::proto::PERFORMANCE_HINTS); - optimization_guide::proto::PerformanceHint* performance_hint = + proto::Optimization* opt = page_hint->add_allowlisted_optimizations(); + opt->set_optimization_type(proto::PERFORMANCE_HINTS); + proto::PerformanceHint* performance_hint = opt->mutable_performance_hints_metadata()->add_performance_hints(); performance_hint->set_wildcard_pattern("somedomain.org"); - performance_hint->set_performance_class( - optimization_guide::proto::PERFORMANCE_SLOW); + performance_hint->set_performance_class(proto::PERFORMANCE_SLOW); ProcessHints(config, "1.0.0.0"); base::RunLoop run_loop; - auto navigation_data = CreateTestNavigationData( - url_with_hints(), {optimization_guide::proto::PERFORMANCE_HINTS}); + auto navigation_data = + CreateTestNavigationData(url_with_hints(), {proto::PERFORMANCE_HINTS}); CallOnNavigationStartOrRedirect(navigation_data.get(), run_loop.QuitClosure()); run_loop.Run(); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::PERFORMANCE_HINTS, &optimization_metadata); + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::PERFORMANCE_HINTS, + &optimization_metadata); // Make sure performance hints metadata is populated. EXPECT_TRUE(optimization_metadata.performance_hints_metadata().has_value()); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint, + EXPECT_EQ(OptimizationTypeDecision::kAllowedByHint, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationAndPopulatesPublicImageMetadata) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint = config.add_hints(); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); + proto::Configuration config; + proto::Hint* hint = config.add_hints(); hint->set_key("somedomain.org"); - hint->set_key_representation(optimization_guide::proto::HOST); + hint->set_key_representation(proto::HOST); hint->set_version("someversion"); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->set_page_pattern("/news/"); - optimization_guide::proto::Optimization* opt = - page_hint->add_allowlisted_optimizations(); - opt->set_optimization_type(optimization_guide::proto::COMPRESS_PUBLIC_IMAGES); + proto::Optimization* opt = page_hint->add_allowlisted_optimizations(); + opt->set_optimization_type(proto::COMPRESS_PUBLIC_IMAGES); opt->mutable_public_image_metadata()->add_url("someimage"); ProcessHints(config, "1.0.0.0"); auto navigation_data = CreateTestNavigationData( - url_with_hints(), {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_with_hints(), {proto::COMPRESS_PUBLIC_IMAGES}); base::RunLoop run_loop; CallOnNavigationStartOrRedirect(navigation_data.get(), run_loop.QuitClosure()); run_loop.Run(); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - &optimization_metadata); + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::COMPRESS_PUBLIC_IMAGES, + &optimization_metadata); // Make sure public images metadata is populated. EXPECT_TRUE(optimization_metadata.public_image_metadata().has_value()); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint, + EXPECT_EQ(OptimizationTypeDecision::kAllowedByHint, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationAndPopulatesLoadingPredictorMetadata) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LOADING_PREDICTOR}); - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint = config.add_hints(); + hints_manager()->RegisterOptimizationTypes({proto::LOADING_PREDICTOR}); + proto::Configuration config; + proto::Hint* hint = config.add_hints(); hint->set_key("somedomain.org"); - hint->set_key_representation(optimization_guide::proto::HOST); + hint->set_key_representation(proto::HOST); hint->set_version("someversion"); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->set_page_pattern("/news/"); - optimization_guide::proto::Optimization* opt = - page_hint->add_allowlisted_optimizations(); - opt->set_optimization_type(optimization_guide::proto::LOADING_PREDICTOR); + proto::Optimization* opt = page_hint->add_allowlisted_optimizations(); + opt->set_optimization_type(proto::LOADING_PREDICTOR); opt->mutable_loading_predictor_metadata()->add_subresources()->set_url( "https://resource.com/"); ProcessHints(config, "1.0.0.0"); - auto navigation_data = CreateTestNavigationData( - url_with_hints(), {optimization_guide::proto::LOADING_PREDICTOR}); + auto navigation_data = + CreateTestNavigationData(url_with_hints(), {proto::LOADING_PREDICTOR}); base::RunLoop run_loop; CallOnNavigationStartOrRedirect(navigation_data.get(), run_loop.QuitClosure()); run_loop.Run(); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::LOADING_PREDICTOR, &optimization_metadata); + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::LOADING_PREDICTOR, + &optimization_metadata); // Make sure loading predictor metadata is populated. EXPECT_TRUE(optimization_metadata.loading_predictor_metadata().has_value()); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint, + EXPECT_EQ(OptimizationTypeDecision::kAllowedByHint, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationAndPopulatesAnyMetadata) { - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LOADING_PREDICTOR}); - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint = config.add_hints(); + hints_manager()->RegisterOptimizationTypes({proto::LOADING_PREDICTOR}); + proto::Configuration config; + proto::Hint* hint = config.add_hints(); hint->set_key("somedomain.org"); - hint->set_key_representation(optimization_guide::proto::HOST); + hint->set_key_representation(proto::HOST); hint->set_version("someversion"); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->set_page_pattern("/news/"); - optimization_guide::proto::Optimization* opt = - page_hint->add_allowlisted_optimizations(); - opt->set_optimization_type(optimization_guide::proto::LOADING_PREDICTOR); - optimization_guide::proto::LoadingPredictorMetadata lp_metadata; + proto::Optimization* opt = page_hint->add_allowlisted_optimizations(); + opt->set_optimization_type(proto::LOADING_PREDICTOR); + proto::LoadingPredictorMetadata lp_metadata; lp_metadata.add_subresources()->set_url("https://resource.com/"); lp_metadata.SerializeToString(opt->mutable_any_metadata()->mutable_value()); opt->mutable_any_metadata()->set_type_url( @@ -1464,24 +1375,23 @@ TEST_F(HintsManagerTest, CanApplyOptimizationAndPopulatesAnyMetadata) { ProcessHints(config, "1.0.0.0"); - auto navigation_data = CreateTestNavigationData( - url_with_hints(), {optimization_guide::proto::LOADING_PREDICTOR}); + auto navigation_data = + CreateTestNavigationData(url_with_hints(), {proto::LOADING_PREDICTOR}); base::RunLoop run_loop; CallOnNavigationStartOrRedirect(navigation_data.get(), run_loop.QuitClosure()); run_loop.Run(); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::LOADING_PREDICTOR, &optimization_metadata); + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::LOADING_PREDICTOR, + &optimization_metadata); // Make sure loading predictor metadata is populated. EXPECT_TRUE( - optimization_metadata - .ParsedMetadata() + optimization_metadata.ParsedMetadata() .has_value()); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint, + EXPECT_EQ(OptimizationTypeDecision::kAllowedByHint, optimization_type_decision); } @@ -1497,14 +1407,13 @@ TEST_F(HintsManagerTest, CanApplyOptimizationNoMatchingPageHint) { run_loop.QuitClosure()); run_loop.Run(); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::NOSCRIPT}); - optimization_guide::OptimizationTypeDecision optimization_type_decision = + hints_manager()->RegisterOptimizationTypes({proto::NOSCRIPT}); + OptimizationTypeDecision optimization_type_decision = hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), - optimization_guide::proto::NOSCRIPT, + proto::NOSCRIPT, /*optimization_metadata=*/nullptr); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNotAllowedByHint, + EXPECT_EQ(OptimizationTypeDecision::kNotAllowedByHint, optimization_type_decision); } @@ -1513,71 +1422,64 @@ TEST_F(HintsManagerTest, InitializeWithDefaultConfig("1.0.0.0"); auto navigation_data = CreateTestNavigationData( - GURL("https://nohint.com"), - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + GURL("https://nohint.com"), {proto::COMPRESS_PUBLIC_IMAGES}); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::NOSCRIPT}); - optimization_guide::OptimizationMetadata optimization_metadata; + hints_manager()->RegisterOptimizationTypes({proto::NOSCRIPT}); + OptimizationMetadata optimization_metadata; - optimization_guide::proto::PerformanceHintsMetadata hints_metadata; + proto::PerformanceHintsMetadata hints_metadata; auto* hint = hints_metadata.add_performance_hints(); hint->set_wildcard_pattern("test.com"); - hint->set_performance_class(optimization_guide::proto::PERFORMANCE_SLOW); - optimization_guide::OptimizationMetadata metadata; + hint->set_performance_class(proto::PERFORMANCE_SLOW); + OptimizationMetadata metadata; optimization_metadata.set_performance_hints_metadata(hints_metadata); - optimization_guide::OptimizationTypeDecision optimization_type_decision = + OptimizationTypeDecision optimization_type_decision = hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), - optimization_guide::proto::NOSCRIPT, + proto::NOSCRIPT, &optimization_metadata); EXPECT_FALSE(optimization_metadata.performance_hints_metadata().has_value()); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNoHintAvailable, + EXPECT_EQ(OptimizationTypeDecision::kNoHintAvailable, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationHasHintInCacheButNotLoaded) { InitializeWithDefaultConfig("1.0.0.0"); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::NOSCRIPT}); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization(url_with_hints(), - optimization_guide::proto::NOSCRIPT, + hints_manager()->RegisterOptimizationTypes({proto::NOSCRIPT}); + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(url_with_hints(), proto::NOSCRIPT, &optimization_metadata); - EXPECT_EQ( - optimization_guide::OptimizationTypeDecision::kHadHintButNotLoadedInTime, - optimization_type_decision); + EXPECT_EQ(OptimizationTypeDecision::kHadHintButNotLoadedInTime, + optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationFilterTakesPrecedence) { auto navigation_data = CreateTestNavigationData( GURL("https://m.host.com/urlinfilterandhints"), {}); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint1 = config.add_hints(); + proto::Configuration config; + proto::Hint* hint1 = config.add_hints(); hint1->set_key("host.com"); - hint1->set_key_representation(optimization_guide::proto::HOST); + hint1->set_key_representation(proto::HOST); hint1->set_version("someversion"); - optimization_guide::proto::PageHint* page_hint1 = hint1->add_page_hints(); + proto::PageHint* page_hint1 = hint1->add_page_hints(); page_hint1->set_page_pattern("https://m.host.com"); - optimization_guide::proto::Optimization* optimization1 = + proto::Optimization* optimization1 = page_hint1->add_allowlisted_optimizations(); - optimization1->set_optimization_type( - optimization_guide::proto::LITE_PAGE_REDIRECT); - optimization_guide::BloomFilter blocklist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + optimization1->set_optimization_type(proto::LITE_PAGE_REDIRECT); + BloomFilter blocklist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&blocklist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/false, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/false, &config); ProcessHints(config, "1.0.0.0"); base::RunLoop run_loop; @@ -1585,45 +1487,41 @@ TEST_F(HintsManagerTest, CanApplyOptimizationFilterTakesPrecedence) { run_loop.QuitClosure()); run_loop.Run(); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::LITE_PAGE_REDIRECT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::LITE_PAGE_REDIRECT, + /*optimization_metadata=*/nullptr); // Make sure decision points logged correctly. - EXPECT_EQ(optimization_guide::OptimizationTypeDecision:: - kNotAllowedByOptimizationFilter, + EXPECT_EQ(OptimizationTypeDecision::kNotAllowedByOptimizationFilter, optimization_type_decision); } TEST_F(HintsManagerTest, CanApplyOptimizationFilterTakesPrecedenceMatchesFilter) { - auto navigation_data = CreateTestNavigationData( - GURL("https://notfiltered.com/whatever"), - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + auto navigation_data = + CreateTestNavigationData(GURL("https://notfiltered.com/whatever"), + {proto::COMPRESS_PUBLIC_IMAGES}); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint1 = config.add_hints(); + proto::Configuration config; + proto::Hint* hint1 = config.add_hints(); hint1->set_key("notfiltered.com"); - hint1->set_key_representation(optimization_guide::proto::HOST); + hint1->set_key_representation(proto::HOST); hint1->set_version("someversion"); - optimization_guide::proto::PageHint* page_hint1 = hint1->add_page_hints(); + proto::PageHint* page_hint1 = hint1->add_page_hints(); page_hint1->set_page_pattern("https://notfiltered.com"); - optimization_guide::proto::Optimization* optimization1 = + proto::Optimization* optimization1 = page_hint1->add_allowlisted_optimizations(); - optimization1->set_optimization_type( - optimization_guide::proto::LITE_PAGE_REDIRECT); - optimization_guide::BloomFilter blocklist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + optimization1->set_optimization_type(proto::LITE_PAGE_REDIRECT); + BloomFilter blocklist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&blocklist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/false, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/false, &config); ProcessHints(config, "1.0.0.0"); base::RunLoop run_loop; @@ -1631,14 +1529,12 @@ TEST_F(HintsManagerTest, run_loop.QuitClosure()); run_loop.Run(); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::LITE_PAGE_REDIRECT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::LITE_PAGE_REDIRECT, + /*optimization_metadata=*/nullptr); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision:: - kAllowedByOptimizationFilter, + EXPECT_EQ(OptimizationTypeDecision::kAllowedByOptimizationFilter, optimization_type_decision); } @@ -1646,7 +1542,7 @@ class HintsManagerFetchingDisabledTest : public HintsManagerTest { public: HintsManagerFetchingDisabledTest() { scoped_list_.InitAndDisableFeature( - optimization_guide::features::kRemoteOptimizationGuideFetching); + features::kRemoteOptimizationGuideFetching); } private: @@ -1656,7 +1552,7 @@ class HintsManagerFetchingDisabledTest : public HintsManagerTest { TEST_F(HintsManagerFetchingDisabledTest, HintsFetchNotAllowedIfFeatureIsNotEnabled) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); + switches::kDisableCheckingUserPermissionsForTesting); std::unique_ptr top_host_provider = std::make_unique( @@ -1676,25 +1572,22 @@ TEST_F(HintsManagerTest, CanApplyOptimizationAsyncReturnsRightAwayIfNotAllowedToFetch) { base::HistogramTester histogram_tester; - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_without_hints(), {proto::COMPRESS_PUBLIC_IMAGES}); hints_manager()->CanApplyOptimizationAsync( - url_without_hints(), optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse, - decision); - })); + url_without_hints(), proto::COMPRESS_PUBLIC_IMAGES, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kFalse, decision); + })); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.CompressPublicImages", - optimization_guide::OptimizationTypeDecision::kNoHintAvailable, 1); + OptimizationTypeDecision::kNoHintAvailable, 1); } TEST_F( @@ -1702,12 +1595,11 @@ TEST_F( CanApplyOptimizationAsyncReturnsRightAwayIfNotAllowedToFetchAndNotAllowlistedByAvailableHint) { base::HistogramTester histogram_tester; - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); auto navigation_data = CreateTestNavigationData( - url_with_hints(), {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_with_hints(), {proto::COMPRESS_PUBLIC_IMAGES}); // Wait for hint to be loaded. base::RunLoop run_loop; CallOnNavigationStartOrRedirect(navigation_data.get(), @@ -1715,39 +1607,36 @@ TEST_F( run_loop.Run(); hints_manager()->CanApplyOptimizationAsync( - url_with_hints(), optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse, - decision); - })); + url_with_hints(), proto::COMPRESS_PUBLIC_IMAGES, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kFalse, decision); + })); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.CompressPublicImages", - optimization_guide::OptimizationTypeDecision::kNotAllowedByHint, 1); + OptimizationTypeDecision::kNotAllowedByHint, 1); } TEST_F(HintsManagerTest, RemoveFetchedEntriesByHintKeys_Host) { int cache_duration_in_secs = 60; GURL url("https://host.com/r/cats"); - std::unique_ptr - get_hints_response = - std::make_unique(); + std::unique_ptr get_hints_response = + std::make_unique(); - optimization_guide::proto::Hint* hint = get_hints_response->add_hints(); + proto::Hint* hint = get_hints_response->add_hints(); hint->set_key(url.spec()); - hint->set_key_representation(optimization_guide::proto::FULL_URL); + hint->set_key_representation(proto::FULL_URL); hint->mutable_max_cache_duration()->set_seconds(cache_duration_in_secs); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->add_allowlisted_optimizations()->set_optimization_type( - optimization_guide::proto::PERFORMANCE_HINTS); + proto::PERFORMANCE_HINTS); page_hint->set_page_pattern("whatever/*"); hint = get_hints_response->add_hints(); - hint->set_key_representation(optimization_guide::proto::HOST); + hint->set_key_representation(proto::HOST); hint->set_key(url.host()); page_hint = hint->add_page_hints(); page_hint->set_page_pattern("anything/*"); @@ -1761,8 +1650,7 @@ TEST_F(HintsManagerTest, RemoveFetchedEntriesByHintKeys_Host) { run_loop = std::make_unique(); hints_manager()->RemoveFetchedEntriesByHintKeys( - run_loop->QuitClosure(), - optimization_guide::proto::KeyRepresentation::HOST, {url.host()}); + run_loop->QuitClosure(), proto::KeyRepresentation::HOST, {url.host()}); run_loop->Run(); EXPECT_FALSE(hints_manager()->hint_cache()->HasHint(url.host())); @@ -1773,21 +1661,20 @@ TEST_F(HintsManagerTest, RemoveFetchedEntriesByHintKeys_URL) { int cache_duration_in_secs = 60; GURL url("https://host.com/r/cats"); - std::unique_ptr - get_hints_response = - std::make_unique(); + std::unique_ptr get_hints_response = + std::make_unique(); - optimization_guide::proto::Hint* hint = get_hints_response->add_hints(); + proto::Hint* hint = get_hints_response->add_hints(); hint->set_key(url.spec()); - hint->set_key_representation(optimization_guide::proto::FULL_URL); + hint->set_key_representation(proto::FULL_URL); hint->mutable_max_cache_duration()->set_seconds(cache_duration_in_secs); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->add_allowlisted_optimizations()->set_optimization_type( - optimization_guide::proto::PERFORMANCE_HINTS); + proto::PERFORMANCE_HINTS); page_hint->set_page_pattern("whatever/*"); hint = get_hints_response->add_hints(); - hint->set_key_representation(optimization_guide::proto::HOST); + hint->set_key_representation(proto::HOST); hint->set_key(url.host()); page_hint = hint->add_page_hints(); page_hint->set_page_pattern("anything/*"); @@ -1801,8 +1688,8 @@ TEST_F(HintsManagerTest, RemoveFetchedEntriesByHintKeys_URL) { run_loop = std::make_unique(); hints_manager()->RemoveFetchedEntriesByHintKeys( - run_loop->QuitClosure(), - optimization_guide::proto::KeyRepresentation::FULL_URL, {url.spec()}); + run_loop->QuitClosure(), proto::KeyRepresentation::FULL_URL, + {url.spec()}); run_loop->Run(); // Both the host and url entries should have been removed to support upgrading @@ -1815,21 +1702,20 @@ TEST_F(HintsManagerTest, PurgeFetchedEntries) { int cache_duration_in_secs = 60; GURL url("https://host.com/r/cats"); - std::unique_ptr - get_hints_response = - std::make_unique(); + std::unique_ptr get_hints_response = + std::make_unique(); - optimization_guide::proto::Hint* hint = get_hints_response->add_hints(); + proto::Hint* hint = get_hints_response->add_hints(); hint->set_key(url.spec()); - hint->set_key_representation(optimization_guide::proto::FULL_URL); + hint->set_key_representation(proto::FULL_URL); hint->mutable_max_cache_duration()->set_seconds(cache_duration_in_secs); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->add_allowlisted_optimizations()->set_optimization_type( - optimization_guide::proto::PERFORMANCE_HINTS); + proto::PERFORMANCE_HINTS); page_hint->set_page_pattern("whatever/*"); hint = get_hints_response->add_hints(); - hint->set_key_representation(optimization_guide::proto::HOST); + hint->set_key_representation(proto::HOST); hint->set_key(url.host()); page_hint = hint->add_page_hints(); page_hint->set_page_pattern("anything/*"); @@ -1851,58 +1737,54 @@ TEST_F(HintsManagerTest, PurgeFetchedEntries) { TEST_F(HintsManagerTest, HintFetcherPrefUpdated_URL) { base::Time expiry = base::Time::Now() + base::Hours(1); - optimization_guide::HintsFetcher::AddFetchedHostForTesting( - pref_service(), "host-key.com", expiry); - optimization_guide::HintsFetcher::AddFetchedHostForTesting( - pref_service(), "url-key.com", expiry); + HintsFetcher::AddFetchedHostForTesting(pref_service(), "host-key.com", + expiry); + HintsFetcher::AddFetchedHostForTesting(pref_service(), "url-key.com", expiry); - ASSERT_TRUE(optimization_guide::HintsFetcher::WasHostCoveredByFetch( - pref_service(), "host-key.com")); - ASSERT_TRUE(optimization_guide::HintsFetcher::WasHostCoveredByFetch( - pref_service(), "url-key.com")); + ASSERT_TRUE( + HintsFetcher::WasHostCoveredByFetch(pref_service(), "host-key.com")); + ASSERT_TRUE( + HintsFetcher::WasHostCoveredByFetch(pref_service(), "url-key.com")); std::unique_ptr run_loop = std::make_unique(); hints_manager()->RemoveFetchedEntriesByHintKeys( - run_loop->QuitClosure(), - optimization_guide::proto::KeyRepresentation::FULL_URL, + run_loop->QuitClosure(), proto::KeyRepresentation::FULL_URL, { GURL("https://host-key.com/page").spec(), GURL("https://url-key.com/page").spec(), }); run_loop->Run(); - EXPECT_FALSE(optimization_guide::HintsFetcher::WasHostCoveredByFetch( - pref_service(), "host-key.com")); - EXPECT_FALSE(optimization_guide::HintsFetcher::WasHostCoveredByFetch( - pref_service(), "url-key.com")); + EXPECT_FALSE( + HintsFetcher::WasHostCoveredByFetch(pref_service(), "host-key.com")); + EXPECT_FALSE( + HintsFetcher::WasHostCoveredByFetch(pref_service(), "url-key.com")); } TEST_F(HintsManagerTest, HintFetcherPrefUpdated_Hosts) { base::Time expiry = base::Time::Now() + base::Hours(1); - optimization_guide::HintsFetcher::AddFetchedHostForTesting( - pref_service(), "host-key.com", expiry); - optimization_guide::HintsFetcher::AddFetchedHostForTesting( - pref_service(), "url-key.com", expiry); + HintsFetcher::AddFetchedHostForTesting(pref_service(), "host-key.com", + expiry); + HintsFetcher::AddFetchedHostForTesting(pref_service(), "url-key.com", expiry); - ASSERT_TRUE(optimization_guide::HintsFetcher::WasHostCoveredByFetch( - pref_service(), "host-key.com")); - ASSERT_TRUE(optimization_guide::HintsFetcher::WasHostCoveredByFetch( - pref_service(), "url-key.com")); + ASSERT_TRUE( + HintsFetcher::WasHostCoveredByFetch(pref_service(), "host-key.com")); + ASSERT_TRUE( + HintsFetcher::WasHostCoveredByFetch(pref_service(), "url-key.com")); std::unique_ptr run_loop = std::make_unique(); hints_manager()->RemoveFetchedEntriesByHintKeys( - run_loop->QuitClosure(), - optimization_guide::proto::KeyRepresentation::HOST, + run_loop->QuitClosure(), proto::KeyRepresentation::HOST, { "host-key.com", "url-key.com", }); run_loop->Run(); - EXPECT_FALSE(optimization_guide::HintsFetcher::WasHostCoveredByFetch( - pref_service(), "host-key.com")); - EXPECT_FALSE(optimization_guide::HintsFetcher::WasHostCoveredByFetch( - pref_service(), "url-key.com")); + EXPECT_FALSE( + HintsFetcher::WasHostCoveredByFetch(pref_service(), "host-key.com")); + EXPECT_FALSE( + HintsFetcher::WasHostCoveredByFetch(pref_service(), "url-key.com")); } class HintsManagerFetchingTest : public HintsManagerTest { @@ -1911,12 +1793,11 @@ class HintsManagerFetchingTest : public HintsManagerTest { scoped_list_.InitWithFeaturesAndParameters( { { - optimization_guide::features::kRemoteOptimizationGuideFetching, + features::kRemoteOptimizationGuideFetching, {{"max_concurrent_page_navigation_fetches", "2"}}, }, }, - {optimization_guide::features:: - kRemoteOptimizationGuideFetchingAnonymousDataConsent}); + {features::kRemoteOptimizationGuideFetchingAnonymousDataConsent}); } private: @@ -1928,10 +1809,9 @@ class HintsManagerFetchingTest : public HintsManagerTest { TEST_F(HintsManagerFetchingTest, HintsFetchNotAllowedIfFeatureIsEnabledButUserNotAllowed) { base::CommandLine::ForCurrentProcess()->RemoveSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); + switches::kDisableCheckingUserPermissionsForTesting); CreateHintsManager(/*top_host_provider=*/nullptr); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithHostHints})); @@ -1950,7 +1830,7 @@ TEST_F(HintsManagerFetchingTest, std::vector({"example1.com", "example2.com"})); base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); + switches::kDisableCheckingUserPermissionsForTesting); CreateHintsManager(top_host_provider.get()); hints_manager()->SetHintsFetcherFactoryForTesting( @@ -1967,26 +1847,25 @@ TEST_F(HintsManagerFetchingTest, TEST_F(HintsManagerFetchingTest, OnlyFilterTypesRegisteredHintsFetchNotAttempted) { - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter allowlist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter allowlist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&allowlist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, allowlist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/true, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, allowlist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/true, &config); std::unique_ptr top_host_provider = std::make_unique( std::vector({"example1.com", "example2.com"})); base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); + switches::kDisableCheckingUserPermissionsForTesting); CreateHintsManager(top_host_provider.get()); ProcessHints(config, "1.0.0.0"); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithHostHints})); @@ -2002,13 +1881,12 @@ TEST_F(HintsManagerFetchingTest, HintsFetcherEnabledNoHostsOrUrlsToFetch) { auto scoped_feature_list = SetUpDeferStartupActiveTabsHintsFetch(false); base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); + switches::kDisableCheckingUserPermissionsForTesting); std::unique_ptr top_host_provider = std::make_unique(std::vector({})); CreateHintsManager(top_host_provider.get()); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithHostHints})); @@ -2038,13 +1916,12 @@ TEST_F(HintsManagerFetchingTest, HintsFetcherEnabledNoHostsButHasUrlsToFetch) { auto scoped_feature_list = SetUpDeferStartupActiveTabsHintsFetch(false); base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); + switches::kDisableCheckingUserPermissionsForTesting); std::unique_ptr top_host_provider = std::make_unique(std::vector({})); CreateHintsManager(top_host_provider.get()); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithHostHints})); @@ -2087,13 +1964,12 @@ TEST_F(HintsManagerFetchingTest, HintsFetcherTimerFetchOnStartup) { auto scoped_feature_list = SetUpDeferStartupActiveTabsHintsFetch(false); base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); + switches::kDisableCheckingUserPermissionsForTesting); std::unique_ptr top_host_provider = std::make_unique(std::vector({})); CreateHintsManager(top_host_provider.get()); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithHostHints})); @@ -2133,13 +2009,12 @@ TEST_F(HintsManagerFetchingTest, HintsFetcherDeferredStartup) { base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); + switches::kDisableCheckingUserPermissionsForTesting); std::unique_ptr top_host_provider = std::make_unique(std::vector({})); CreateHintsManager(top_host_provider.get()); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithHostHints})); @@ -2173,24 +2048,23 @@ TEST_F(HintsManagerFetchingTest, HintsFetcherDeferredStartup) { TEST_F(HintsManagerFetchingTest, HintsFetched_RegisteredOptimizationTypes_AllWithOptFilter) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter allowlist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter allowlist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&allowlist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, allowlist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/true, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, allowlist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/true, &config); ProcessHints(config, "1.0.0.0"); // Set to online so fetch is activated. SetConnectionOnline(); - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::LITE_PAGE_REDIRECT}); + auto navigation_data = CreateTestNavigationData(url_without_hints(), + {proto::LITE_PAGE_REDIRECT}); base::HistogramTester histogram_tester; CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); @@ -2205,15 +2079,14 @@ TEST_F(HintsManagerFetchingTest, TEST_F(HintsManagerFetchingTest, HintsFetchedAtNavigationTime) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); InitializeWithDefaultConfig("1.0.0.0"); // Set to online so fetch is activated. SetConnectionOnline(); - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(url_without_hints(), {proto::DEFER_ALL_SCRIPT}); base::HistogramTester histogram_tester; CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); @@ -2224,23 +2097,20 @@ TEST_F(HintsManagerFetchingTest, HintsFetchedAtNavigationTime) { "OptimizationGuide.HintsFetcher.GetHintsRequest.UrlCount", 1, 1); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHostAndURL, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHostAndURL, 1); } TEST_F(HintsManagerFetchingTest, HintsFetchedAtNavigationTime_FetchNotAttempted) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); InitializeWithDefaultConfig("1.0.0.0"); // Set to online so fetch is activated. SetConnectionOnline(); - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(url_without_hints(), {proto::DEFER_ALL_SCRIPT}); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory({HintsFetcherEndState::kFetchFailed})); base::HistogramTester histogram_tester; @@ -2253,17 +2123,14 @@ TEST_F(HintsManagerFetchingTest, "OptimizationGuide.HintsFetcher.GetHintsRequest.UrlCount", 0); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchNotAttempted, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchNotAttempted, 1); } TEST_F(HintsManagerFetchingTest, HintsFetchedAtNavigationTime_HasComponentHintButNotFetched) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); InitializeWithDefaultConfig("1.0.0.0"); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( @@ -2271,8 +2138,8 @@ TEST_F(HintsManagerFetchingTest, // Set to online so fetch is activated. SetConnectionOnline(); - auto navigation_data = CreateTestNavigationData( - url_with_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(url_with_hints(), {proto::DEFER_ALL_SCRIPT}); base::HistogramTester histogram_tester; CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); @@ -2280,42 +2147,38 @@ TEST_F(HintsManagerFetchingTest, "OptimizationGuide.HintsFetcher.GetHintsRequest.HostCount", 0); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchURL, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchURL, 1); } TEST_F(HintsManagerFetchingTest, HintsFetchedAtNavigationTime_DoesNotRemoveManualOverride) { GURL example_url("http://www.example.com/hasoverride"); - optimization_guide::proto::Configuration config; - optimization_guide::proto::Hint* hint = config.add_hints(); + proto::Configuration config; + proto::Hint* hint = config.add_hints(); hint->set_key(example_url.spec()); - hint->set_key_representation(optimization_guide::proto::FULL_URL); - optimization_guide::proto::PageHint* page_hint = hint->add_page_hints(); + hint->set_key_representation(proto::FULL_URL); + proto::PageHint* page_hint = hint->add_page_hints(); page_hint->set_page_pattern("*"); - optimization_guide::proto::Optimization* opt = - page_hint->add_allowlisted_optimizations(); - opt->set_optimization_type(optimization_guide::proto::DEFER_ALL_SCRIPT); + proto::Optimization* opt = page_hint->add_allowlisted_optimizations(); + opt->set_optimization_type(proto::DEFER_ALL_SCRIPT); std::string encoded_config; config.SerializeToString(&encoded_config); base::Base64Encode(encoded_config, &encoded_config); base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( - optimization_guide::switches::kHintsProtoOverride, encoded_config); + switches::kHintsProtoOverride, encoded_config); // Re-create hints manager with override. CreateHintsManager(/*top_host_provider=*/nullptr); base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); // Set to online so fetch is activated. SetConnectionOnline(); - auto navigation_data = CreateTestNavigationData( - example_url, {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(example_url, {proto::DEFER_ALL_SCRIPT}); base::HistogramTester histogram_tester; CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); @@ -2325,25 +2188,21 @@ TEST_F(HintsManagerFetchingTest, "OptimizationGuide.HintsFetcher.GetHintsRequest.UrlCount", 0, 1); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHost, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHost, 1); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::DEFER_ALL_SCRIPT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::DEFER_ALL_SCRIPT, + /*optimization_metadata=*/nullptr); EXPECT_EQ(optimization_type_decision, - optimization_guide::OptimizationTypeDecision::kAllowedByHint); + OptimizationTypeDecision::kAllowedByHint); } TEST_F(HintsManagerFetchingTest, URLHintsNotFetchedAtNavigationTime) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); InitializeWithDefaultConfig("1.0.0.0"); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( @@ -2354,8 +2213,8 @@ TEST_F(HintsManagerFetchingTest, URLHintsNotFetchedAtNavigationTime) { { base::HistogramTester histogram_tester; - auto navigation_data = CreateTestNavigationData( - url_with_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(url_with_hints(), {proto::DEFER_ALL_SCRIPT}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); @@ -2366,14 +2225,11 @@ TEST_F(HintsManagerFetchingTest, URLHintsNotFetchedAtNavigationTime) { // Make sure navigation data is populated correctly. EXPECT_TRUE(navigation_data->hints_fetch_latency().has_value()); EXPECT_EQ(navigation_data->hints_fetch_attempt_status(), - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchURL); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchURL); histogram_tester.ExpectBucketCount( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchURL, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchURL, 1); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager." "PageNavigationHintsReturnedBeforeDataFlushed", @@ -2383,22 +2239,20 @@ TEST_F(HintsManagerFetchingTest, URLHintsNotFetchedAtNavigationTime) { { base::HistogramTester histogram_tester; - auto navigation_data = CreateTestNavigationData( - url_with_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(url_with_hints(), {proto::DEFER_ALL_SCRIPT}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); histogram_tester.ExpectBucketCount( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchNotAttempted, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchNotAttempted, 1); // Make sure navigation data is populated correctly. EXPECT_FALSE(navigation_data->hints_fetch_latency().has_value()); - EXPECT_EQ(navigation_data->hints_fetch_attempt_status(), - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchNotAttempted); + EXPECT_EQ( + navigation_data->hints_fetch_attempt_status(), + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchNotAttempted); histogram_tester.ExpectTotalCount( "OptimizationGuide.HintsManager." "PageNavigationHintsReturnedBeforeDataFlushed", @@ -2408,9 +2262,8 @@ TEST_F(HintsManagerFetchingTest, URLHintsNotFetchedAtNavigationTime) { TEST_F(HintsManagerFetchingTest, URLWithNoHintsNotRefetchedAtNavigationTime) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); InitializeWithDefaultConfig("1.0.0.0"); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( @@ -2421,8 +2274,8 @@ TEST_F(HintsManagerFetchingTest, URLWithNoHintsNotRefetchedAtNavigationTime) { base::HistogramTester histogram_tester; { - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = CreateTestNavigationData(url_without_hints(), + {proto::DEFER_ALL_SCRIPT}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); @@ -2432,67 +2285,57 @@ TEST_F(HintsManagerFetchingTest, URLWithNoHintsNotRefetchedAtNavigationTime) { // Make sure navigation data is populated correctly. EXPECT_TRUE(navigation_data->hints_fetch_latency().has_value()); EXPECT_EQ(navigation_data->hints_fetch_attempt_status(), - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHostAndURL); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHostAndURL); histogram_tester.ExpectBucketCount( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHostAndURL, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHostAndURL, 1); RunUntilIdle(); } { - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = CreateTestNavigationData(url_without_hints(), + {proto::DEFER_ALL_SCRIPT}); base::RunLoop run_loop; - navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + navigation_data = CreateTestNavigationData(url_without_hints(), + {proto::DEFER_ALL_SCRIPT}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); histogram_tester.ExpectBucketCount( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHost, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHost, 1); EXPECT_TRUE(navigation_data->hints_fetch_latency().has_value()); EXPECT_EQ(navigation_data->hints_fetch_attempt_status(), - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHost); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHost); } } TEST_F(HintsManagerFetchingTest, CanApplyOptimizationCalledMidFetch) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); InitializeWithDefaultConfig("1.0.0.0"); // Set to online so fetch is activated. SetConnectionOnline(); - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(url_without_hints(), {proto::DEFER_ALL_SCRIPT}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::DEFER_ALL_SCRIPT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::DEFER_ALL_SCRIPT, + /*optimization_metadata=*/nullptr); EXPECT_EQ(optimization_type_decision, - optimization_guide::OptimizationTypeDecision:: - kHintFetchStartedButNotAvailableInTime); + OptimizationTypeDecision::kHintFetchStartedButNotAvailableInTime); } TEST_F(HintsManagerFetchingTest, CanApplyOptimizationCalledPostFetchButNoHintsCameBack) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); InitializeWithDefaultConfig("1.0.0.0"); hints_manager()->SetHintsFetcherFactoryForTesting( @@ -2501,27 +2344,25 @@ TEST_F(HintsManagerFetchingTest, // Set to online so fetch is activated. SetConnectionOnline(); - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(url_without_hints(), {proto::DEFER_ALL_SCRIPT}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::DEFER_ALL_SCRIPT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::DEFER_ALL_SCRIPT, + /*optimization_metadata=*/nullptr); EXPECT_EQ(optimization_type_decision, - optimization_guide::OptimizationTypeDecision::kNoHintAvailable); + OptimizationTypeDecision::kNoHintAvailable); } TEST_F(HintsManagerFetchingTest, CanApplyOptimizationCalledPostFetchButFetchFailed) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); InitializeWithDefaultConfig("1.0.0.0"); hints_manager()->SetHintsFetcherFactoryForTesting( @@ -2529,27 +2370,25 @@ TEST_F(HintsManagerFetchingTest, // Set to online so fetch is activated. SetConnectionOnline(); - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(url_without_hints(), {proto::DEFER_ALL_SCRIPT}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::DEFER_ALL_SCRIPT, - /*optimization_metadata=*/nullptr); + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::DEFER_ALL_SCRIPT, + /*optimization_metadata=*/nullptr); EXPECT_EQ(optimization_type_decision, - optimization_guide::OptimizationTypeDecision::kNoHintAvailable); + OptimizationTypeDecision::kNoHintAvailable); } TEST_F(HintsManagerFetchingTest, CanApplyOptimizationWithURLKeyedHintApplicableForOptimizationType) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0"); hints_manager()->SetHintsFetcherFactoryForTesting( @@ -2558,22 +2397,21 @@ TEST_F(HintsManagerFetchingTest, // Set to online so fetch is activated. SetConnectionOnline(); - auto navigation_data = CreateTestNavigationData( - url_with_url_keyed_hint(), {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = CreateTestNavigationData(url_with_url_keyed_hint(), + {proto::DEFER_ALL_SCRIPT}); // Make sure URL-keyed hint is fetched and processed. CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - &optimization_metadata); + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::COMPRESS_PUBLIC_IMAGES, + &optimization_metadata); // Make sure decisions are logged correctly and metadata is populated off // a URL-keyed hint. - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint, + EXPECT_EQ(OptimizationTypeDecision::kAllowedByHint, optimization_type_decision); EXPECT_TRUE(optimization_metadata.public_image_metadata().has_value()); } @@ -2581,9 +2419,8 @@ TEST_F(HintsManagerFetchingTest, TEST_F(HintsManagerFetchingTest, CanApplyOptimizationNotAllowedByURLButAllowedByHostKeyedHint) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::NOSCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::NOSCRIPT}); InitializeWithDefaultConfig("1.0.0.0"); @@ -2594,27 +2431,26 @@ TEST_F(HintsManagerFetchingTest, hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithURLHints})); - auto navigation_data = CreateTestNavigationData( - url_with_url_keyed_hint(), {optimization_guide::proto::NOSCRIPT}); + auto navigation_data = + CreateTestNavigationData(url_with_url_keyed_hint(), {proto::NOSCRIPT}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), - optimization_guide::proto::NOSCRIPT, + proto::NOSCRIPT, &optimization_metadata); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kAllowedByHint, + EXPECT_EQ(OptimizationTypeDecision::kAllowedByHint, optimization_type_decision); } TEST_F(HintsManagerFetchingTest, CanApplyOptimizationNotAllowedByURLOrHostKeyedHint) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::RESOURCE_LOADING}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::RESOURCE_LOADING}); InitializeWithDefaultConfig("1.0.0.0"); @@ -2625,27 +2461,26 @@ TEST_F(HintsManagerFetchingTest, hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithURLHints})); - auto navigation_data = CreateTestNavigationData( - url_with_url_keyed_hint(), {optimization_guide::proto::RESOURCE_LOADING}); + auto navigation_data = CreateTestNavigationData(url_with_url_keyed_hint(), + {proto::RESOURCE_LOADING}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::RESOURCE_LOADING, &optimization_metadata); + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::RESOURCE_LOADING, + &optimization_metadata); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNotAllowedByHint, + EXPECT_EQ(OptimizationTypeDecision::kNotAllowedByHint, optimization_type_decision); } TEST_F(HintsManagerFetchingTest, CanApplyOptimizationNoURLKeyedHintOrHostKeyedHint) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); @@ -2656,29 +2491,27 @@ TEST_F(HintsManagerFetchingTest, BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithNoHints})); auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_without_hints(), {proto::COMPRESS_PUBLIC_IMAGES}); // Attempt to fetch a hint but ensure nothing comes back. CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - &optimization_metadata); + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::COMPRESS_PUBLIC_IMAGES, + &optimization_metadata); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNoHintAvailable, + EXPECT_EQ(OptimizationTypeDecision::kNoHintAvailable, optimization_type_decision); } TEST_F(HintsManagerFetchingTest, CanApplyOptimizationCalledMidFetchForURLKeyedOptimization) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); @@ -2688,29 +2521,26 @@ TEST_F(HintsManagerFetchingTest, // Attempt to fetch a hint but call CanApplyOptimization right away to // simulate being mid-fetch. auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_without_hints(), {proto::COMPRESS_PUBLIC_IMAGES}); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithHostHints})); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - &optimization_metadata); - - EXPECT_EQ(optimization_guide::OptimizationTypeDecision:: - kHintFetchStartedButNotAvailableInTime, + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::COMPRESS_PUBLIC_IMAGES, + &optimization_metadata); + + EXPECT_EQ(OptimizationTypeDecision::kHintFetchStartedButNotAvailableInTime, optimization_type_decision); } TEST_F(HintsManagerFetchingTest, OnNavigationStartOrRedirectWontInitiateFetchIfAlreadyStartedForTheURL) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::RESOURCE_LOADING}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::RESOURCE_LOADING}); InitializeWithDefaultConfig("1.0.0.0"); @@ -2719,8 +2549,8 @@ TEST_F(HintsManagerFetchingTest, // Attempt to fetch a hint but initiate the next navigation right away to // simulate being mid-fetch. - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::RESOURCE_LOADING}); + auto navigation_data = + CreateTestNavigationData(url_without_hints(), {proto::RESOURCE_LOADING}); { base::HistogramTester histogram_tester; hints_manager()->SetHintsFetcherFactoryForTesting( @@ -2729,9 +2559,7 @@ TEST_F(HintsManagerFetchingTest, CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHostAndURL, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHostAndURL, 1); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.ConcurrentPageNavigationFetches", 1, 1); } @@ -2744,8 +2572,7 @@ TEST_F(HintsManagerFetchingTest, CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchAlreadyInProgress, + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchAlreadyInProgress, 1); // Should not be recorded since we are not attempting a new fetch. histogram_tester.ExpectTotalCount( @@ -2755,7 +2582,7 @@ TEST_F(HintsManagerFetchingTest, navigation_data->set_hints_fetch_end(base::TimeTicks::Now()); EXPECT_TRUE(navigation_data->hints_fetch_latency().has_value()); EXPECT_EQ(navigation_data->hints_fetch_attempt_status(), - optimization_guide::RaceNavigationFetchAttemptStatus:: + RaceNavigationFetchAttemptStatus:: kRaceNavigationFetchAlreadyInProgress); } } @@ -2763,9 +2590,8 @@ TEST_F(HintsManagerFetchingTest, TEST_F(HintsManagerFetchingTest, PageNavigationHintsFetcherGetsCleanedUpOnceHintsAreStored) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::RESOURCE_LOADING}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::RESOURCE_LOADING}); InitializeWithDefaultConfig("1.0.0.0"); @@ -2777,16 +2603,14 @@ TEST_F(HintsManagerFetchingTest, // Attempt to fetch a hint but initiate the next navigation right away to // simulate being mid-fetch. - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::RESOURCE_LOADING}); + auto navigation_data = + CreateTestNavigationData(url_without_hints(), {proto::RESOURCE_LOADING}); { base::HistogramTester histogram_tester; CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHostAndURL, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHostAndURL, 1); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.ConcurrentPageNavigationFetches", 1, 1); @@ -2799,9 +2623,7 @@ TEST_F(HintsManagerFetchingTest, CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHost, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHost, 1); histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.ConcurrentPageNavigationFetches", 1, 1); } @@ -2810,9 +2632,8 @@ TEST_F(HintsManagerFetchingTest, TEST_F(HintsManagerFetchingTest, PageNavigationHintsFetcherCanFetchMultipleThingsConcurrently) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); @@ -2823,13 +2644,11 @@ TEST_F(HintsManagerFetchingTest, {HintsFetcherEndState::kFetchSuccessWithURLHints})); auto navigation_data_with_hints = CreateTestNavigationData( - url_with_url_keyed_hint(), - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_with_url_keyed_hint(), {proto::COMPRESS_PUBLIC_IMAGES}); auto navigation_data_without_hints = CreateTestNavigationData( - GURL("https://doesntmatter.com/"), - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + GURL("https://doesntmatter.com/"), {proto::COMPRESS_PUBLIC_IMAGES}); auto navigation_data_without_hints2 = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_without_hints(), {proto::COMPRESS_PUBLIC_IMAGES}); // Attempt to fetch a hint but initiate the next navigations right away to // simulate being mid-fetch. @@ -2855,9 +2674,8 @@ TEST_F(HintsManagerFetchingTest, base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); // Set to online so fetch is activated. @@ -2867,24 +2685,20 @@ TEST_F(HintsManagerFetchingTest, BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithURLHints})); auto navigation_data = CreateTestNavigationData( - url_with_url_keyed_hint(), - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_with_url_keyed_hint(), {proto::COMPRESS_PUBLIC_IMAGES}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); hints_manager()->CanApplyOptimizationAsync( - url_with_url_keyed_hint(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kTrue, - decision); - EXPECT_TRUE(metadata.public_image_metadata().has_value()); - })); + url_with_url_keyed_hint(), proto::COMPRESS_PUBLIC_IMAGES, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kTrue, decision); + EXPECT_TRUE(metadata.public_image_metadata().has_value()); + })); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.CompressPublicImages", - optimization_guide::OptimizationTypeDecision::kAllowedByHint, 1); + OptimizationTypeDecision::kAllowedByHint, 1); } TEST_F(HintsManagerFetchingTest, @@ -2892,9 +2706,8 @@ TEST_F(HintsManagerFetchingTest, base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); // Set to online so fetch is activated. @@ -2904,34 +2717,27 @@ TEST_F(HintsManagerFetchingTest, BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithURLHints})); auto navigation_data = CreateTestNavigationData( - url_with_url_keyed_hint(), - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_with_url_keyed_hint(), {proto::COMPRESS_PUBLIC_IMAGES}); hints_manager()->CanApplyOptimizationAsync( - url_with_url_keyed_hint(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kTrue, - decision); - EXPECT_TRUE(metadata.public_image_metadata().has_value()); - })); + url_with_url_keyed_hint(), proto::COMPRESS_PUBLIC_IMAGES, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kTrue, decision); + EXPECT_TRUE(metadata.public_image_metadata().has_value()); + })); hints_manager()->CanApplyOptimizationAsync( - url_with_url_keyed_hint(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kTrue, - decision); - EXPECT_TRUE(metadata.public_image_metadata().has_value()); - })); + url_with_url_keyed_hint(), proto::COMPRESS_PUBLIC_IMAGES, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kTrue, decision); + EXPECT_TRUE(metadata.public_image_metadata().has_value()); + })); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.CompressPublicImages", - optimization_guide::OptimizationTypeDecision::kAllowedByHint, 2); + OptimizationTypeDecision::kAllowedByHint, 2); } TEST_F( @@ -2940,9 +2746,8 @@ TEST_F( base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::RESOURCE_LOADING}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::RESOURCE_LOADING}); InitializeWithDefaultConfig("1.0.0.0"); // Set to online so fetch is activated. @@ -2951,22 +2756,20 @@ TEST_F( hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithURLHints})); - auto navigation_data = CreateTestNavigationData( - url_with_url_keyed_hint(), {optimization_guide::proto::RESOURCE_LOADING}); + auto navigation_data = CreateTestNavigationData(url_with_url_keyed_hint(), + {proto::RESOURCE_LOADING}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); hints_manager()->CanApplyOptimizationAsync( - url_with_url_keyed_hint(), optimization_guide::proto::RESOURCE_LOADING, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse, - decision); - })); + url_with_url_keyed_hint(), proto::RESOURCE_LOADING, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kFalse, decision); + })); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.ResourceLoading", - optimization_guide::OptimizationTypeDecision::kNotAllowedByHint, 1); + OptimizationTypeDecision::kNotAllowedByHint, 1); } TEST_F(HintsManagerFetchingTest, @@ -2974,9 +2777,8 @@ TEST_F(HintsManagerFetchingTest, base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); @@ -2986,23 +2788,19 @@ TEST_F(HintsManagerFetchingTest, hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory({HintsFetcherEndState::kFetchFailed})); auto navigation_data = CreateTestNavigationData( - url_with_url_keyed_hint(), - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_with_url_keyed_hint(), {proto::COMPRESS_PUBLIC_IMAGES}); hints_manager()->CanApplyOptimizationAsync( - url_with_url_keyed_hint(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse, - decision); - })); + url_with_url_keyed_hint(), proto::COMPRESS_PUBLIC_IMAGES, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kFalse, decision); + })); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.CompressPublicImages", - optimization_guide::OptimizationTypeDecision::kNotAllowedByHint, 1); + OptimizationTypeDecision::kNotAllowedByHint, 1); } TEST_F(HintsManagerFetchingTest, @@ -3010,9 +2808,8 @@ TEST_F(HintsManagerFetchingTest, base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); @@ -3023,26 +2820,22 @@ TEST_F(HintsManagerFetchingTest, BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithURLHints})); auto navigation_data = CreateTestNavigationData( - url_with_url_keyed_hint(), - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_with_url_keyed_hint(), {proto::COMPRESS_PUBLIC_IMAGES}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); hints_manager()->CanApplyOptimizationAsync( - url_with_url_keyed_hint(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kTrue, - decision); - EXPECT_TRUE(metadata.public_image_metadata().has_value()); - })); + url_with_url_keyed_hint(), proto::COMPRESS_PUBLIC_IMAGES, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kTrue, decision); + EXPECT_TRUE(metadata.public_image_metadata().has_value()); + })); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.CompressPublicImages", - optimization_guide::OptimizationTypeDecision::kAllowedByHint, 1); + OptimizationTypeDecision::kAllowedByHint, 1); } TEST_F(HintsManagerFetchingTest, @@ -3050,9 +2843,8 @@ TEST_F(HintsManagerFetchingTest, base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::PERFORMANCE_HINTS}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::PERFORMANCE_HINTS}); InitializeWithDefaultConfig("1.0.0.0"); @@ -3062,25 +2854,22 @@ TEST_F(HintsManagerFetchingTest, hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithURLHints})); - auto navigation_data = - CreateTestNavigationData(url_with_url_keyed_hint(), - {optimization_guide::proto::PERFORMANCE_HINTS}); + auto navigation_data = CreateTestNavigationData(url_with_url_keyed_hint(), + {proto::PERFORMANCE_HINTS}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); hints_manager()->CanApplyOptimizationAsync( - url_with_url_keyed_hint(), optimization_guide::proto::PERFORMANCE_HINTS, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse, - decision); - })); + url_with_url_keyed_hint(), proto::PERFORMANCE_HINTS, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kFalse, decision); + })); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.PerformanceHints", - optimization_guide::OptimizationTypeDecision::kNotAllowedByHint, 1); + OptimizationTypeDecision::kNotAllowedByHint, 1); } TEST_F(HintsManagerFetchingTest, @@ -3088,9 +2877,8 @@ TEST_F(HintsManagerFetchingTest, base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::PERFORMANCE_HINTS}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::PERFORMANCE_HINTS}); InitializeWithDefaultConfig("1.0.0.0"); @@ -3100,22 +2888,20 @@ TEST_F(HintsManagerFetchingTest, hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithNoHints})); - auto navigation_data = CreateTestNavigationData( - url_without_hints(), {optimization_guide::proto::PERFORMANCE_HINTS}); + auto navigation_data = + CreateTestNavigationData(url_without_hints(), {proto::PERFORMANCE_HINTS}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); hints_manager()->CanApplyOptimizationAsync( - url_without_hints(), optimization_guide::proto::PERFORMANCE_HINTS, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse, - decision); - })); + url_without_hints(), proto::PERFORMANCE_HINTS, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kFalse, decision); + })); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.PerformanceHints", - optimization_guide::OptimizationTypeDecision::kNoHintAvailable, 1); + OptimizationTypeDecision::kNoHintAvailable, 1); } TEST_F(HintsManagerFetchingTest, @@ -3123,9 +2909,8 @@ TEST_F(HintsManagerFetchingTest, base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); @@ -3134,22 +2919,20 @@ TEST_F(HintsManagerFetchingTest, GURL url_that_redirected("https://urlthatredirected.com"); auto navigation_data_redirect = CreateTestNavigationData( - url_that_redirected, {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_that_redirected, {proto::COMPRESS_PUBLIC_IMAGES}); hints_manager()->CanApplyOptimizationAsync( - url_that_redirected, optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse, - decision); - })); + url_that_redirected, proto::COMPRESS_PUBLIC_IMAGES, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kFalse, decision); + })); hints_manager()->OnNavigationFinish( {url_that_redirected, GURL("https://otherurl.com/")}); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.CompressPublicImages", - optimization_guide::OptimizationTypeDecision::kNoHintAvailable, 1); + OptimizationTypeDecision::kNoHintAvailable, 1); } TEST_F(HintsManagerFetchingTest, @@ -3157,9 +2940,8 @@ TEST_F(HintsManagerFetchingTest, base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); @@ -3170,100 +2952,82 @@ TEST_F(HintsManagerFetchingTest, BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithNoHints})); auto navigation_data = CreateTestNavigationData( - url_with_url_keyed_hint(), - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + url_with_url_keyed_hint(), {proto::COMPRESS_PUBLIC_IMAGES}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); hints_manager()->CanApplyOptimizationAsync( - url_with_url_keyed_hint(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse, - decision); - })); + url_with_url_keyed_hint(), proto::COMPRESS_PUBLIC_IMAGES, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kFalse, decision); + })); hints_manager()->OnNavigationFinish({url_with_url_keyed_hint()}); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.CompressPublicImages", - optimization_guide::OptimizationTypeDecision::kNotAllowedByHint, 1); + OptimizationTypeDecision::kNotAllowedByHint, 1); } TEST_F(HintsManagerFetchingTest, CanApplyOptimizationAsyncWithDecisionFromAllowlistReturnsRightAway) { base::HistogramTester histogram_tester; - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter allowlist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter allowlist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&allowlist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, allowlist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/true, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, allowlist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/true, &config); ProcessHints(config, "1.0.0.0"); - auto navigation_data = - CreateTestNavigationData(GURL("https://notallowed.com/123"), - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + auto navigation_data = CreateTestNavigationData( + GURL("https://notallowed.com/123"), {proto::LITE_PAGE_REDIRECT}); hints_manager()->CanApplyOptimizationAsync( - navigation_data->navigation_url(), - optimization_guide::proto::LITE_PAGE_REDIRECT, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse, - decision); - })); + navigation_data->navigation_url(), proto::LITE_PAGE_REDIRECT, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kFalse, decision); + })); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.LitePageRedirect", - optimization_guide::OptimizationTypeDecision:: - kNotAllowedByOptimizationFilter, - 1); + OptimizationTypeDecision::kNotAllowedByOptimizationFilter, 1); } TEST_F(HintsManagerFetchingTest, CanApplyOptimizationAsyncWithDecisionFromBlocklistReturnsRightAway) { base::HistogramTester histogram_tester; - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + hints_manager()->RegisterOptimizationTypes({proto::LITE_PAGE_REDIRECT}); - optimization_guide::proto::Configuration config; - optimization_guide::BloomFilter blocklist_bloom_filter( - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits); + proto::Configuration config; + BloomFilter blocklist_bloom_filter(kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits); PopulateBloomFilterWithDefaultHost(&blocklist_bloom_filter); - AddBloomFilterToConfig( - optimization_guide::proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, - kDefaultHostBloomFilterNumHashFunctions, kDefaultHostBloomFilterNumBits, - /*is_allowlist=*/false, &config); + AddBloomFilterToConfig(proto::LITE_PAGE_REDIRECT, blocklist_bloom_filter, + kDefaultHostBloomFilterNumHashFunctions, + kDefaultHostBloomFilterNumBits, + /*is_allowlist=*/false, &config); ProcessHints(config, "1.0.0.0"); - auto navigation_data = - CreateTestNavigationData(GURL("https://m.host.com/123"), - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + auto navigation_data = CreateTestNavigationData( + GURL("https://m.host.com/123"), {proto::LITE_PAGE_REDIRECT}); hints_manager()->CanApplyOptimizationAsync( - navigation_data->navigation_url(), - optimization_guide::proto::LITE_PAGE_REDIRECT, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kFalse, - decision); - })); + navigation_data->navigation_url(), proto::LITE_PAGE_REDIRECT, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kFalse, decision); + })); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.LitePageRedirect", - optimization_guide::OptimizationTypeDecision:: - kNotAllowedByOptimizationFilter, - 1); + OptimizationTypeDecision::kNotAllowedByOptimizationFilter, 1); } TEST_F(HintsManagerFetchingTest, @@ -3271,9 +3035,8 @@ TEST_F(HintsManagerFetchingTest, base::HistogramTester histogram_tester; base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); @@ -3283,34 +3046,29 @@ TEST_F(HintsManagerFetchingTest, hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithURLHints})); - auto navigation_data = - CreateTestNavigationData(url_with_url_keyed_hint(), - {optimization_guide::proto::LITE_PAGE_REDIRECT}); + auto navigation_data = CreateTestNavigationData(url_with_url_keyed_hint(), + {proto::LITE_PAGE_REDIRECT}); CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); hints_manager()->CanApplyOptimizationAsync( - url_with_url_keyed_hint(), - optimization_guide::proto::COMPRESS_PUBLIC_IMAGES, - base::BindOnce( - [](optimization_guide::OptimizationGuideDecision decision, - const optimization_guide::OptimizationMetadata& metadata) { - EXPECT_EQ(optimization_guide::OptimizationGuideDecision::kTrue, - decision); - EXPECT_TRUE(metadata.public_image_metadata().has_value()); - })); + url_with_url_keyed_hint(), proto::COMPRESS_PUBLIC_IMAGES, + base::BindOnce([](OptimizationGuideDecision decision, + const OptimizationMetadata& metadata) { + EXPECT_EQ(OptimizationGuideDecision::kTrue, decision); + EXPECT_TRUE(metadata.public_image_metadata().has_value()); + })); hints_manager()->OnNavigationFinish({url_with_url_keyed_hint()}); RunUntilIdle(); histogram_tester.ExpectUniqueSample( "OptimizationGuide.ApplyDecisionAsync.CompressPublicImages", - optimization_guide::OptimizationTypeDecision::kAllowedByHint, 1); + OptimizationTypeDecision::kAllowedByHint, 1); } TEST_F(HintsManagerFetchingTest, OnNavigationFinishDoesNotCrashWithoutAnyCallbacksRegistered) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); InitializeWithDefaultConfig("1.0.0.0"); @@ -3321,9 +3079,8 @@ TEST_F(HintsManagerFetchingTest, TEST_F(HintsManagerFetchingTest, NewOptTypeRegisteredClearsHintCache) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + switches::kDisableCheckingUserPermissionsForTesting); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); InitializeWithDefaultConfig("1.0.0.0"); @@ -3335,26 +3092,25 @@ TEST_F(HintsManagerFetchingTest, NewOptTypeRegisteredClearsHintCache) { hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithHostHints})); - auto navigation_data = CreateTestNavigationData( - url, {optimization_guide::proto::DEFER_ALL_SCRIPT}); + auto navigation_data = + CreateTestNavigationData(url, {proto::DEFER_ALL_SCRIPT}); // Attempt to fetch a hint but ensure nothing comes back. CallOnNavigationStartOrRedirect(navigation_data.get(), base::DoNothing()); RunUntilIdle(); - optimization_guide::OptimizationMetadata optimization_metadata; - optimization_guide::OptimizationTypeDecision optimization_type_decision = - hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::DEFER_ALL_SCRIPT, &optimization_metadata); + OptimizationMetadata optimization_metadata; + OptimizationTypeDecision optimization_type_decision = + hints_manager()->CanApplyOptimization(navigation_data->navigation_url(), + proto::DEFER_ALL_SCRIPT, + &optimization_metadata); - EXPECT_EQ(optimization_guide::OptimizationTypeDecision::kNotAllowedByHint, + EXPECT_EQ(OptimizationTypeDecision::kNotAllowedByHint, optimization_type_decision); // Register a new type that is unlaunched - this should clear the Fetched // hints. - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::COMPRESS_PUBLIC_IMAGES}); + hints_manager()->RegisterOptimizationTypes({proto::COMPRESS_PUBLIC_IMAGES}); RunUntilIdle(); @@ -3366,31 +3122,28 @@ TEST_F(HintsManagerFetchingTest, NewOptTypeRegisteredClearsHintCache) { base::HistogramTester histogram_tester; - navigation_data = CreateTestNavigationData( - url, {optimization_guide::proto::DEFER_ALL_SCRIPT}); + navigation_data = CreateTestNavigationData(url, {proto::DEFER_ALL_SCRIPT}); CallOnNavigationStartOrRedirect(navigation_data.get(), run_loop.QuitClosure()); run_loop.Run(); optimization_type_decision = hints_manager()->CanApplyOptimization( - navigation_data->navigation_url(), - optimization_guide::proto::DEFER_ALL_SCRIPT, &optimization_metadata); + navigation_data->navigation_url(), proto::DEFER_ALL_SCRIPT, + &optimization_metadata); // The previously fetched hints for the host should not be available after // registering a new optimization type. histogram_tester.ExpectUniqueSample( "OptimizationGuide.HintsManager.RaceNavigationFetchAttemptStatus", - optimization_guide::RaceNavigationFetchAttemptStatus:: - kRaceNavigationFetchHost, - 1); + RaceNavigationFetchAttemptStatus::kRaceNavigationFetchHost, 1); } class HintsManagerFetchingNoBatchUpdateTest : public HintsManagerTest { public: HintsManagerFetchingNoBatchUpdateTest() { scoped_list_.InitAndEnableFeatureWithParameters( - optimization_guide::features::kRemoteOptimizationGuideFetching, + features::kRemoteOptimizationGuideFetching, {{"batch_update_hints_for_top_hosts", "false"}}); } @@ -3401,15 +3154,14 @@ class HintsManagerFetchingNoBatchUpdateTest : public HintsManagerTest { TEST_F(HintsManagerFetchingNoBatchUpdateTest, BatchUpdateHintsFetchNotScheduledIfNotAllowed) { base::CommandLine::ForCurrentProcess()->AppendSwitch( - optimization_guide::switches::kDisableCheckingUserPermissionsForTesting); + switches::kDisableCheckingUserPermissionsForTesting); std::unique_ptr top_host_provider = std::make_unique( std::vector({"example1.com", "example2.com"})); // Force hints fetch scheduling. CreateHintsManager(top_host_provider.get()); - hints_manager()->RegisterOptimizationTypes( - {optimization_guide::proto::DEFER_ALL_SCRIPT}); + hints_manager()->RegisterOptimizationTypes({proto::DEFER_ALL_SCRIPT}); hints_manager()->SetHintsFetcherFactoryForTesting( BuildTestHintsFetcherFactory( {HintsFetcherEndState::kFetchSuccessWithHostHints}));