| // Copyright 2022 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "content/browser/preloading/preloading_attempt_impl.h" |
| |
| #include "base/containers/span.h" |
| #include "base/metrics/crc32.h" |
| #include "base/metrics/histogram_functions.h" |
| #include "base/state_transitions.h" |
| #include "base/strings/strcat.h" |
| #include "content/browser/preloading/preloading.h" |
| #include "content/browser/preloading/preloading_config.h" |
| #include "content/public/browser/preloading.h" |
| #include "services/metrics/public/cpp/metrics_utils.h" |
| #include "services/metrics/public/cpp/ukm_builders.h" |
| #include "services/metrics/public/cpp/ukm_recorder.h" |
| #include "services/metrics/public/cpp/ukm_source_id.h" |
| #include "third_party/blink/public/common/features.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| void DCHECKTriggeringOutcomeTransitions(PreloadingTriggeringOutcome old_state, |
| PreloadingTriggeringOutcome new_state) { |
| #if DCHECK_IS_ON() |
| static const base::NoDestructor< |
| base::StateTransitions<PreloadingTriggeringOutcome>> |
| allowed_transitions(base::StateTransitions<PreloadingTriggeringOutcome>({ |
| {PreloadingTriggeringOutcome::kUnspecified, |
| {PreloadingTriggeringOutcome::kDuplicate, |
| PreloadingTriggeringOutcome::kRunning, |
| PreloadingTriggeringOutcome::kReady, |
| PreloadingTriggeringOutcome::kSuccess, |
| PreloadingTriggeringOutcome::kFailure, |
| PreloadingTriggeringOutcome::kTriggeredButOutcomeUnknown, |
| PreloadingTriggeringOutcome::kTriggeredButUpgradedToPrerender, |
| PreloadingTriggeringOutcome::kTriggeredButPending, |
| PreloadingTriggeringOutcome::kNoOp}}, |
| |
| {PreloadingTriggeringOutcome::kDuplicate, {}}, |
| |
| {PreloadingTriggeringOutcome::kRunning, |
| {PreloadingTriggeringOutcome::kReady, |
| PreloadingTriggeringOutcome::kFailure, |
| PreloadingTriggeringOutcome::kTriggeredButUpgradedToPrerender}}, |
| |
| // It can be possible that the preloading attempt may end up failing |
| // after being ready to use, for cases where we have to cancel the |
| // attempt for performance and security reasons. |
| // The transition of kReady to kReady occurs when the main frame |
| // navigation is completed in a preloaded page. |
| {PreloadingTriggeringOutcome::kReady, |
| {PreloadingTriggeringOutcome::kReady, |
| PreloadingTriggeringOutcome::kSuccess, |
| PreloadingTriggeringOutcome::kFailure, |
| PreloadingTriggeringOutcome::kTriggeredButUpgradedToPrerender}}, |
| |
| {PreloadingTriggeringOutcome::kSuccess, {}}, |
| |
| {PreloadingTriggeringOutcome::kFailure, {}}, |
| |
| {PreloadingTriggeringOutcome::kTriggeredButOutcomeUnknown, {}}, |
| |
| {PreloadingTriggeringOutcome::kTriggeredButUpgradedToPrerender, |
| {PreloadingTriggeringOutcome::kFailure}}, |
| |
| {PreloadingTriggeringOutcome::kTriggeredButPending, |
| {PreloadingTriggeringOutcome::kRunning, |
| PreloadingTriggeringOutcome::kFailure}}, |
| |
| {PreloadingTriggeringOutcome::kNoOp, {}}, |
| })); |
| DCHECK_STATE_TRANSITION(allowed_transitions, |
| /*old_state=*/old_state, |
| /*new_state=*/new_state); |
| #endif // DCHECK_IS_ON() |
| } |
| |
| void CheckReadyOutcomePreloadingType(PreloadingType type) { |
| switch (type) { |
| case PreloadingType::kPrefetch: |
| case PreloadingType::kPrerender: |
| case PreloadingType::kNoStatePrefetch: |
| case PreloadingType::kLinkPreview: |
| case PreloadingType::kPrerenderUntilScript: |
| return; |
| default: |
| NOTREACHED() << "Unexpected preloading type: " << static_cast<int>(type); |
| } |
| } |
| |
| } // namespace |
| |
| void PreloadingAttemptImpl::SetEligibility(PreloadingEligibility eligibility) { |
| // Ensure that eligiblity is only set once and that it's set before the |
| // holdback status and the triggering outcome. |
| CHECK_EQ(eligibility_, PreloadingEligibility::kUnspecified); |
| CHECK_EQ(holdback_status_, PreloadingHoldbackStatus::kUnspecified); |
| CHECK_EQ(triggering_outcome_, PreloadingTriggeringOutcome::kUnspecified); |
| CHECK_NE(eligibility, PreloadingEligibility::kUnspecified); |
| eligibility_ = eligibility; |
| } |
| |
| // TODO(crbug.com/40275772): most call sites of this should be removed, as |
| // PreloadingConfig should subsume most feature-specific holdbacks that exist |
| // today. Some cases can remain as specific overrides of the PreloadingConfig |
| // logic, e.g. if DevTools is open, or for features that are still launching and |
| // thus have their own separate holdback feature while they ramp up. |
| void PreloadingAttemptImpl::SetHoldbackStatus( |
| PreloadingHoldbackStatus holdback_status) { |
| // Ensure that the holdback status is only set once and that it's set for |
| // eligible attempts and before the triggering outcome. |
| CHECK_EQ(eligibility_, PreloadingEligibility::kEligible); |
| CHECK_EQ(holdback_status_, PreloadingHoldbackStatus::kUnspecified); |
| CHECK_EQ(triggering_outcome_, PreloadingTriggeringOutcome::kUnspecified); |
| CHECK_NE(holdback_status, PreloadingHoldbackStatus::kUnspecified); |
| holdback_status_ = holdback_status; |
| } |
| |
| bool PreloadingAttemptImpl::ShouldHoldback() { |
| CHECK_EQ(eligibility_, PreloadingEligibility::kEligible); |
| if (holdback_status_ != PreloadingHoldbackStatus::kUnspecified) { |
| // The holdback status has already been determined, just use that value. |
| return holdback_status_ == PreloadingHoldbackStatus::kHoldback; |
| } |
| |
| bool should_holdback_due_to_preloading_config = |
| PreloadingConfig::GetInstance().ShouldHoldback(preloading_type_, |
| creating_predictor_); |
| bool should_holdback_due_to_autosr_holdback = |
| creating_predictor_ == content_preloading_predictor:: |
| kSpeculationRulesFromAutoSpeculationRules && |
| blink::features::kAutoSpeculationRulesHoldback.Get(); |
| bool should_holdback = should_holdback_due_to_preloading_config || |
| should_holdback_due_to_autosr_holdback; |
| if (should_holdback) { |
| holdback_status_ = PreloadingHoldbackStatus::kHoldback; |
| } else { |
| holdback_status_ = PreloadingHoldbackStatus::kAllowed; |
| } |
| return should_holdback; |
| } |
| |
| void PreloadingAttemptImpl::SetTriggeringOutcome( |
| PreloadingTriggeringOutcome triggering_outcome) { |
| // Ensure that the triggering outcome is only set for eligible and |
| // non-holdback attempts. |
| CHECK_EQ(eligibility_, PreloadingEligibility::kEligible); |
| CHECK_EQ(holdback_status_, PreloadingHoldbackStatus::kAllowed); |
| // Check that we do the correct transition before setting |
| // `triggering_outcome_`. |
| DCHECKTriggeringOutcomeTransitions(/*old_state=*/triggering_outcome_, |
| /*new_state=*/triggering_outcome); |
| triggering_outcome_ = triggering_outcome; |
| |
| // Set the ready time, if this attempt was not already ready. |
| switch (triggering_outcome_) { |
| // Currently only Prefetch, Prerender and NoStatePrefetch have a ready |
| // state. Other preloading features do not track the entire progress of the |
| // preloading attempt, where |
| // `PreloadingTriggeringOutcome::kTriggeredButOutcomeUnknown` is set for |
| // those other features. |
| case PreloadingTriggeringOutcome::kReady: |
| CheckReadyOutcomePreloadingType(preloading_type_); |
| if (!ready_time_) { |
| ready_time_ = elapsed_timer_.Elapsed(); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| |
| void PreloadingAttemptImpl::SetFailureReason(PreloadingFailureReason reason) { |
| // Ensure that the failure reason is only set once and is only set for |
| // eligible and non-holdback attempts. |
| CHECK_EQ(eligibility_, PreloadingEligibility::kEligible); |
| CHECK_EQ(holdback_status_, PreloadingHoldbackStatus::kAllowed); |
| CHECK_EQ(failure_reason_, PreloadingFailureReason::kUnspecified); |
| CHECK_NE(reason, PreloadingFailureReason::kUnspecified); |
| |
| // It could be possible that the TriggeringOutcome is already kFailure, when |
| // we try to set FailureReason after setting TriggeringOutcome to kFailure. |
| if (triggering_outcome_ != PreloadingTriggeringOutcome::kFailure) |
| SetTriggeringOutcome(PreloadingTriggeringOutcome::kFailure); |
| failure_reason_ = reason; |
| } |
| |
| base::WeakPtr<PreloadingAttempt> PreloadingAttemptImpl::GetWeakPtr() { |
| return weak_factory_.GetWeakPtr(); |
| } |
| |
| PreloadingAttemptImpl::PreloadingAttemptImpl( |
| const PreloadingPredictor& creating_predictor, |
| const PreloadingPredictor& enacting_predictor, |
| PreloadingType preloading_type, |
| ukm::SourceId triggered_primary_page_source_id, |
| PreloadingURLMatchCallback url_match_predicate, |
| uint32_t sampling_seed) |
| : creating_predictor_(creating_predictor), |
| enacting_predictor_(enacting_predictor), |
| preloading_type_(preloading_type), |
| triggered_primary_page_source_id_(triggered_primary_page_source_id), |
| url_match_predicate_(std::move(url_match_predicate)), |
| sampling_seed_(sampling_seed) {} |
| |
| PreloadingAttemptImpl::~PreloadingAttemptImpl() = default; |
| |
| std::vector<PreloadingPredictor> PreloadingAttemptImpl::GetPredictors() const { |
| if (creating_predictor_ == enacting_predictor_) { |
| return {creating_predictor_}; |
| } |
| return {creating_predictor_, enacting_predictor_}; |
| } |
| |
| void PreloadingAttemptImpl::RecordPreloadingAttemptMetrics( |
| ukm::SourceId navigated_page_source_id) { |
| ukm::UkmRecorder* ukm_recorder = ukm::UkmRecorder::Get(); |
| |
| // Ensure that when the `triggering_outcome_` is kSuccess, then the |
| // accurate_triggering should be true. |
| if (triggering_outcome_ == PreloadingTriggeringOutcome::kSuccess) { |
| // TODO(crbug.com/40263357): Fix PreloadingAttempt for Prefetching in |
| // a different WebContents. It is allowed to activate a prefetched result in |
| // another WebContents instance, and the WebContents that stores `this` |
| // instance does not have the opportunity to set the |
| // `is_accurate_triggering_` flag to true in this case. |
| if (preloading_type_ != PreloadingType::kPrefetch) { |
| CHECK(is_accurate_triggering_) |
| << "TriggeringOutcome set to kSuccess without correct prediction\n"; |
| } |
| } |
| |
| // Always record UMA, regardless of sampling. |
| RecordPreloadingAttemptUMA(); |
| |
| // Check if the preloading attempt is sampled in. |
| // We prefer to use the UKM source ID of the triggering page for determining |
| // sampling, so that all preloading attempts from a given (preloading_type, |
| // predictor) for the same page are included (or not) together. If there is |
| // no source for the triggering page, fallback to the navigated-to page. |
| ukm::SourceId sampling_source = triggered_primary_page_source_id_; |
| if (sampling_source == ukm::kInvalidSourceId) { |
| sampling_source = navigated_page_source_id; |
| } |
| if (sampling_source == ukm::kInvalidSourceId) { |
| // There is no valid UKM source, so there is nothing to log. |
| return; |
| } |
| |
| PreloadingConfig& config = PreloadingConfig::GetInstance(); |
| |
| for (const auto& predictor : GetPredictors()) { |
| uint32_t sampled_num = sampling_seed_; |
| sampled_num = |
| base::Crc32(sampled_num, base::byte_span_from_ref(sampling_source)); |
| |
| double sampling_likelihood = |
| config.SamplingLikelihood(preloading_type_, predictor); |
| if (sampled_num > |
| sampling_likelihood * std::numeric_limits<uint32_t>::max()) { |
| // PreloadingAttempt is sampled out. |
| continue; |
| } |
| |
| // Turn sampling_likelihood into an int64_t for UKM logging. Multiply by one |
| // million to preserve accuracy. |
| int64_t sampling_likelihood_per_million = |
| static_cast<int64_t>(1'000'000 * sampling_likelihood); |
| |
| if (navigated_page_source_id != ukm::kInvalidSourceId) { |
| ukm::builders::Preloading_Attempt builder(navigated_page_source_id); |
| builder.SetPreloadingType(static_cast<int64_t>(preloading_type_)) |
| .SetPreloadingPredictor(predictor.ukm_value()) |
| .SetEligibility(static_cast<int64_t>(eligibility_)) |
| .SetHoldbackStatus(static_cast<int64_t>(holdback_status_)) |
| .SetTriggeringOutcome(static_cast<int64_t>(triggering_outcome_)) |
| .SetFailureReason(static_cast<int64_t>(failure_reason_)) |
| .SetAccurateTriggering(is_accurate_triggering_) |
| .SetSamplingLikelihood(sampling_likelihood_per_million); |
| if (time_to_next_navigation_) { |
| builder.SetTimeToNextNavigation( |
| ukm::GetExponentialBucketMinForCounts1000( |
| time_to_next_navigation_->InMilliseconds())); |
| } |
| if (ready_time_) { |
| builder.SetReadyTime(ukm::GetExponentialBucketMinForCounts1000( |
| ready_time_->InMilliseconds())); |
| } |
| if (eagerness_) { |
| builder.SetSpeculationEagerness( |
| static_cast<int64_t>(eagerness_.value())); |
| } |
| if (service_worker_registered_check_) { |
| builder.SetPrefetchServiceWorkerRegisteredCheck( |
| static_cast<int64_t>(service_worker_registered_check_.value())); |
| } |
| if (service_worker_registered_check_duration_) { |
| builder.SetPrefetchServiceWorkerRegisteredForURLCheckDuration( |
| ukm::GetExponentialBucketMin( |
| service_worker_registered_check_duration_.value() |
| .InMicroseconds(), |
| kServiceWorkerRegisteredCheckDurationBucketSpacing)); |
| } |
| builder.Record(ukm_recorder); |
| } |
| |
| if (triggered_primary_page_source_id_ != ukm::kInvalidSourceId) { |
| ukm::builders::Preloading_Attempt_PreviousPrimaryPage builder( |
| triggered_primary_page_source_id_); |
| builder.SetPreloadingType(static_cast<int64_t>(preloading_type_)) |
| .SetPreloadingPredictor(predictor.ukm_value()) |
| .SetEligibility(static_cast<int64_t>(eligibility_)) |
| .SetHoldbackStatus(static_cast<int64_t>(holdback_status_)) |
| .SetTriggeringOutcome(static_cast<int64_t>(triggering_outcome_)) |
| .SetFailureReason(static_cast<int64_t>(failure_reason_)) |
| .SetAccurateTriggering(is_accurate_triggering_) |
| .SetSamplingLikelihood(sampling_likelihood_per_million); |
| if (time_to_next_navigation_) { |
| builder.SetTimeToNextNavigation( |
| ukm::GetExponentialBucketMinForCounts1000( |
| time_to_next_navigation_->InMilliseconds())); |
| } |
| if (ready_time_) { |
| builder.SetReadyTime(ukm::GetExponentialBucketMinForCounts1000( |
| ready_time_->InMilliseconds())); |
| } |
| if (eagerness_) { |
| builder.SetSpeculationEagerness( |
| static_cast<int64_t>(eagerness_.value())); |
| } |
| if (service_worker_registered_check_) { |
| builder.SetPrefetchServiceWorkerRegisteredCheck( |
| static_cast<int64_t>(service_worker_registered_check_.value())); |
| } |
| if (service_worker_registered_check_duration_) { |
| builder.SetPrefetchServiceWorkerRegisteredForURLCheckDuration( |
| ukm::GetExponentialBucketMin( |
| service_worker_registered_check_duration_.value() |
| .InMicroseconds(), |
| kServiceWorkerRegisteredCheckDurationBucketSpacing)); |
| } |
| builder.Record(ukm_recorder); |
| } |
| } |
| } |
| |
| void PreloadingAttemptImpl::RecordPreloadingAttemptUMA() { |
| // Records the triggering outcome enum. This can be used to: |
| // 1. Track the number of attempts; |
| // 2. Track the attempts' rates of various terminal status (i.e. success |
| // rate). |
| for (const auto& predictor : GetPredictors()) { |
| const auto uma_triggering_outcome_histogram = |
| base::StrCat({"Preloading.", PreloadingTypeToString(preloading_type_), |
| ".Attempt.", predictor.name(), ".TriggeringOutcome"}); |
| base::UmaHistogramEnumeration(std::move(uma_triggering_outcome_histogram), |
| triggering_outcome_); |
| } |
| } |
| |
| void PreloadingAttemptImpl::SetNoVarySearchMatchPredicate( |
| PreloadingURLMatchCallback no_vary_search_match_predicate) { |
| CHECK(!no_vary_search_match_predicate_); |
| no_vary_search_match_predicate_ = std::move(no_vary_search_match_predicate); |
| } |
| |
| void PreloadingAttemptImpl::SetIsAccurateTriggering(const GURL& navigated_url) { |
| CHECK(url_match_predicate_); |
| |
| // `PreloadingAttemptImpl::SetIsAccurateTriggering` is called during |
| // `WCO::DidStartNavigation`. |
| if (!time_to_next_navigation_) { |
| time_to_next_navigation_ = elapsed_timer_.Elapsed(); |
| } |
| |
| // Use the predicate to match the URLs as the matching logic varies for each |
| // predictor. |
| is_accurate_triggering_ |= url_match_predicate_.Run(navigated_url); |
| if (no_vary_search_match_predicate_) { |
| is_accurate_triggering_ |= |
| no_vary_search_match_predicate_.Run(navigated_url); |
| } |
| } |
| |
| void PreloadingAttemptImpl::SetSpeculationEagerness( |
| blink::mojom::SpeculationEagerness eagerness) { |
| CHECK(creating_predictor_ == |
| content_preloading_predictor::kSpeculationRules || |
| creating_predictor_ == |
| content_preloading_predictor::kSpeculationRulesFromIsolatedWorld || |
| creating_predictor_ == content_preloading_predictor:: |
| kSpeculationRulesFromAutoSpeculationRules) |
| << "predictor_type_: " << creating_predictor_.name() |
| << " (ukm_value = " << creating_predictor_.ukm_value() << ")"; |
| eagerness_ = eagerness; |
| } |
| |
| void PreloadingAttemptImpl::SetServiceWorkerRegisteredCheck( |
| ServiceWorkerRegisteredCheck check) { |
| service_worker_registered_check_ = check; |
| } |
| |
| void PreloadingAttemptImpl::SetServiceWorkerRegisteredCheckDuration( |
| base::TimeDelta duration) { |
| service_worker_registered_check_duration_ = duration; |
| } |
| |
| // Used for StateTransitions matching. |
| std::ostream& operator<<(std::ostream& os, |
| const PreloadingTriggeringOutcome& outcome) { |
| switch (outcome) { |
| case PreloadingTriggeringOutcome::kUnspecified: |
| os << "Unspecified"; |
| break; |
| case PreloadingTriggeringOutcome::kDuplicate: |
| os << "Duplicate"; |
| break; |
| case PreloadingTriggeringOutcome::kRunning: |
| os << "Running"; |
| break; |
| case PreloadingTriggeringOutcome::kReady: |
| os << "Ready"; |
| break; |
| case PreloadingTriggeringOutcome::kSuccess: |
| os << "Success"; |
| break; |
| case PreloadingTriggeringOutcome::kFailure: |
| os << "Failure"; |
| break; |
| case PreloadingTriggeringOutcome::kTriggeredButOutcomeUnknown: |
| os << "TriggeredButOutcomeUnknown"; |
| break; |
| case PreloadingTriggeringOutcome::kTriggeredButUpgradedToPrerender: |
| os << "TriggeredButUpgradedToPrerender"; |
| break; |
| case PreloadingTriggeringOutcome::kTriggeredButPending: |
| os << "TriggeredButPending"; |
| break; |
| case PreloadingTriggeringOutcome::kNoOp: |
| os << "NoOp"; |
| break; |
| } |
| return os; |
| } |
| |
| } // namespace content |
