// 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 <algorithm> #include <memory> #include <vector> #include "base/memory/raw_ptr.h" #include "base/strings/strcat.h" #include "base/test/bind.h" #include "base/test/metrics/histogram_tester.h" #include "base/test/simple_test_clock.h" #include "build/build_config.h" #include "chrome/browser/captive_portal/captive_portal_service_factory.h" #include "chrome/browser/content_settings/host_content_settings_map_factory.h" #include "chrome/browser/extensions/api/settings_private/generated_prefs.h" #include "chrome/browser/interstitials/security_interstitial_page_test_utils.h" #include "chrome/browser/profiles/profile.h" #include "chrome/browser/ssl/generated_https_first_mode_pref.h" #include "chrome/browser/ssl/https_first_mode_settings_tracker.h" #include "chrome/browser/ssl/https_upgrades_interceptor.h" #include "chrome/browser/ssl/https_upgrades_navigation_throttle.h" #include "chrome/browser/ui/browser.h" #include "chrome/browser/ui/browser_tabstrip.h" #include "chrome/browser/ui/browser_window.h" #include "chrome/browser/ui/location_bar/location_bar.h" #include "chrome/common/chrome_features.h" #include "chrome/common/pref_names.h" #include "chrome/test/base/in_process_browser_test.h" #include "chrome/test/base/ui_test_utils.h" #include "components/captive_portal/content/captive_portal_service.h" #include "components/content_settings/core/browser/host_content_settings_map.h" #include "components/embedder_support/pref_names.h" #include "components/omnibox/browser/omnibox_client.h" #include "components/omnibox/browser/omnibox_controller.h" #include "components/omnibox/browser/omnibox_view.h" #include "components/prefs/pref_service.h" #include "components/security_interstitials/content/stateful_ssl_host_state_delegate.h" #include "components/security_interstitials/core/https_only_mode_metrics.h" #include "components/security_interstitials/core/metrics_helper.h" #include "components/security_state/content/security_state_tab_helper.h" #include "components/site_engagement/content/site_engagement_service.h" #include "components/strings/grit/components_strings.h" #include "components/variations/active_field_trials.h" #include "components/variations/hashing.h" #include "content/public/browser/storage_partition.h" #include "content/public/test/browser_test.h" #include "content/public/test/browser_test_utils.h" #include "content/public/test/content_browser_test_utils.h" #include "content/public/test/content_mock_cert_verifier.h" #include "content/public/test/test_navigation_observer.h" #include "content/public/test/url_loader_interceptor.h" #include "net/dns/mock_host_resolver.h" #include "net/http/http_util.h" #include "net/test/cert_test_util.h" #include "net/test/embedded_test_server/embedded_test_server.h" #include "net/test/embedded_test_server/http_request.h" #include "net/test/embedded_test_server/request_handler_util.h" #include "net/test/test_data_directory.h" #include "services/network/public/cpp/url_loader_completion_status.h" #include "services/network/public/mojom/network_context.mojom.h" #include "ui/base/l10n/l10n_util.h" #include "url/url_constants.h" HFMInterstitialType; Event; InterstitialReason; kEventHistogram; kEventHistogramWithEngagementHeuristic; kInterstitialReasonHistogram; kNavigationRequestSecurityLevelHistogram; kSiteEngagementHeuristicAccumulatedHostCountHistogram; kSiteEngagementHeuristicEnforcementDurationHistogram; kSiteEngagementHeuristicHostCountHistogram; kSiteEngagementHeuristicStateHistogram; NavigationRequestSecurityLevel; SiteEngagementHeuristicState; // Many of the following tests have only minor variations for HTTPS-First Mode // vs. HTTPS-Upgrades. These get parameterized so the tests run under both // versions on their own as well as when both HTTPS Upgrades and HTTPS-First // Mode are enabled (to test any interactions between the two upgrade modes). // HTTPS-Upgrades is now enabled by default, so all of these variations build // on top of that baseline. // // Quick summary of all features tested here: // * HTTPS-Upgrades: // Automatically upgrades main frame navigations to HTTPS. Silently falls // back to HTTP on failure. // * HTTPS First Mode: // Automatically upgrades main frame navigations to HTTPS. Shows an // interstitial on failure. // * HTTPS First Mode With Site Engagement: // Automatically enables HTTPS First Mode for sites that are visited mainly // over HTTPS. // * HTTPS First Mode for Typically Secure Users // Automatically enables HTTPS First Mode for users that mainly visit HTTPS // sites. // * HTTPS First Mode in Incognito: // Automatically enables HTTPS First Mode in Incognito windows. // * HTTPS First Balanced Mode: // Enables HTTPS First Mode like full HFM, but exempt navigations that are // likely to fail. // enum class HttpsUpgradesTestType { … }; // Stores the number of times the HTTPS-First Mode interstitial is shown for the // given reason. struct ExpectedInterstitialReasons { … }; // A very low site engagement score. constexpr int kLowSiteEngagementScore = …; // A very high site engagement score. constexpr int kHighSiteEnagementScore = …; // Tests for HTTPS-Upgrades and the v2 implementation of HTTPS-First Mode. class HttpsUpgradesBrowserTest : public testing::WithParamInterface<HttpsUpgradesTestType>, public InProcessBrowserTest { … }; INSTANTIATE_TEST_SUITE_P(…); // If the user navigates to an HTTP URL for a site that supports HTTPS, the // navigation should end up on the HTTPS version of the URL if upgrading is // enabled. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, UrlWithHttpScheme_ShouldUpgrade) { … } // If the user navigates to an HTTPS URL for a site that supports HTTPS, the // navigation should end up on that exact URL. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, UrlWithHttpsScheme_ShouldLoad) { … } // If the user navigates to a localhost URL, the navigation should end up on // that exact URL. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, Localhost_ShouldNotUpgrade) { … } // Test that HTTPS Upgrades are skipped for non-unique hostnames, such as // non-publicly routable (RFC1918/4193) IP addresses, but HTTPS-First Mode // should still apply. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, NonRoutableIPAddress_ShouldNotUpgrade) { … } // Test that unique single-label hostnames (e.g. gTLDs) are upgraded in all // modes, but warnings are only shown in strict and incognito modes. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, UniqueSingleLabel_NoWarnInBalancedMode) { … } // If the user navigates to a non-unique hostname, the navigation should be // upgraded, but record insecure metrics. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, NonUniqueHost_RecordsMetrics) { … } // Test that non-default ports (e.g. not HTTP80) are upgraded in all // modes, but warnings are only shown in strict and incognito modes. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, NonDefaultPorts_NoWarnInBalancedMode) { … } // If the user navigates to an HTTPS URL, the navigation should end up on that // exact URL, even if the site has an SSL error. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, UrlWithHttpsScheme_BrokenSSL_ShouldNotFallback) { … } // If the user navigates to an HTTP URL for a site with broken HTTPS, the // navigation should end up on the HTTPS URL and show the HTTPS-Only Mode // interstitial. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, UrlWithHttpScheme_BrokenSSL_ShouldInterstitial) { … } // HTTPS-First Mode in Incognito should customize the interstitial. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, IncognitoInterstitialVariation) { … } void MaybeEnableHttpsFirstModeForEngagedSitesAndWait( HttpsFirstModeService* hfm_service) { … } // Returns a URL loader interceptor that responds to HTTPS URLs with a cert // error and to HTTP URLs with a good response. std::unique_ptr<content::URLLoaderInterceptor> MakeInterceptorForSiteEngagementHeuristic() { … } // TODO(crbug.com/40904694): Fails on the linux-wayland-rel bot. #if defined(OZONE_PLATFORM_WAYLAND) #define MAYBE_UrlWithHttpScheme_BrokenSSL_SiteEngagementHeuristic_ShouldInterstitial … #else #define MAYBE_UrlWithHttpScheme_BrokenSSL_SiteEngagementHeuristic_ShouldInterstitial … #endif // Test for Site Engagement Heuristic, a feature that enables HFM on specific // sites based on their site engagement scores. // If the user navigates to an HTTP URL for a site with broken HTTPS, the // navigation should end up on the HTTPS URL and show the HTTPS-Only Mode // interstitial. It should also record a separate histogram for Site Engagement // Heuristic if the interstitial isn't enabled. IN_PROC_BROWSER_TEST_P( HttpsUpgradesBrowserTest, MAYBE_UrlWithHttpScheme_BrokenSSL_SiteEngagementHeuristic_ShouldInterstitial) { … } // Test that Site Engagement Heuristic doesn't enforce HTTPS on URLs with // non-default ports. IN_PROC_BROWSER_TEST_P( HttpsUpgradesBrowserTest, UrlWithHttpScheme_BrokenSSL_SiteEngagementHeuristic_ShouldIgnoreUrlsWithNonDefaultPorts) { … } IN_PROC_BROWSER_TEST_P( HttpsUpgradesBrowserTest, PRE_UrlWithHttpScheme_BrokenSSL_ShouldInterstitial_TypicallySecureUser) { … } // TODO(crbug.com/40925331): Fails on the linux-wayland-rel bot. #if defined(OZONE_PLATFORM_WAYLAND) #define MAYBE_UrlWithHttpScheme_BrokenSSL_ShouldInterstitial_TypicallySecureUser … #else #define MAYBE_UrlWithHttpScheme_BrokenSSL_ShouldInterstitial_TypicallySecureUser … #endif IN_PROC_BROWSER_TEST_P( HttpsUpgradesBrowserTest, MAYBE_UrlWithHttpScheme_BrokenSSL_ShouldInterstitial_TypicallySecureUser) { … } // Checks that navigation to a non-unique hostname counts as a fallback event // for the Typically Secure User heuristic and does not auto-enable HFM even if // all other conditions are satisfied. IN_PROC_BROWSER_TEST_P( HttpsUpgradesBrowserTest, UrlWithHttpScheme_NonUniqueHostname_ShouldNotInterstitial_TypicallySecureUser) { … } // Regression test for crbug.com/1441276. Sequence of events: // 1. Loads http://example.com. This gets upgraded to https://example.com. // 2. https://example.com has an iframe for https://nonexistentsite.com. It // navigates away immediately to http://example.com. // 3. This causes a crash in // HttpsUpgradesInterceptor::MaybeCreateLoaderForResponse() for // nonexistentsite.com. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, LoadIFrameAndNavigateAway_ShouldNotCrash) { … } // If the user triggers an HTTPS-Only Mode interstitial for a host and then // clicks through the interstitial, they should end up on the HTTP URL. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, InterstitialBypassed_HttpFallbackLoaded) { … } // If the upgraded HTTPS URL is not available due to a net error, it should // trigger the HTTPS-Only Mode interstitial and offer fallback. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, NetErrorOnUpgrade_ShouldInterstitial) { … } // If the upgraded HTTPS URL is not available due to a potentially-transient // exempted net error (here a DNS resolution error), show the regular net error // page instead of the HTTPS-First Mode interstitial. If the network conditions // change such that the network error no longer triggers, reloading the tab // should continue the upgraded navigation, which will fail and trigger fallback // to HTTP. (Regression test for crbug.com/1277211.) IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, ExemptNetErrorOnUpgrade_ShouldNotFallback) { … } // Test that if one site redirects to a non-existent site, that we show the // regular net error page instead of the HTTPS-First Mode interstitial. // (Regression test for crbug.com/1277211.) IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, RedirectToNonexistentSite_ShouldNotInterstitial) { … } // If the upgraded HTTPS URL is not available due to a potentially-transient // exempted net error but the hostname is non-unique, don't show the net error // page and instead just fallback to HTTP and the HTTPS-First Mode interstitial. // Otherwise, the user can be stuck on the net error page when the HTTP version // of the host would have resolved, such as for corp single-label hostnames. // (Regression test for crbug.com/1451040.) IN_PROC_BROWSER_TEST_P( HttpsUpgradesBrowserTest, ExemptNetErrorOnUpgrade_NonUniqueHostname_ShouldFallback) { … } // If the upgraded HTTPS URL is not available due to an exempted net error but // is to a single-label unique hostname (i.e. a TLD) don't show the net error // page. This is the same as // ExemptNetErrorOnUpgrade_NonUniqueHostname_ShouldFallback except with a unique // one-label hostname. // (Partial regression test for impact of crrev.com/c/5507613 on b/348330182.) IN_PROC_BROWSER_TEST_P( HttpsUpgradesBrowserTest, ExemptNetErrorOnUpgrade_UniqueSingleLabelHostname_ShouldFallback) { … } // Navigations in subframes should not get upgraded by HTTPS-Only Mode. They // should be blocked as mixed content. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, HttpsParentHttpSubframeNavigation_Blocked) { … } // Navigating to an HTTP URL in a subframe of an HTTP page should not upgrade // the subframe navigation to HTTPS (even if the subframe navigation is to a // different host than the parent frame). IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, HttpParentHttpSubframeNavigation_NotUpgraded) { … } // Tests that a navigation to the HTTP version of a site with an HTTPS version // that is slow to respond gets upgraded to HTTPS but times out and shows the // HTTPS-Only Mode interstitial. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, SlowHttps_ShouldInterstitial) { … } // Tests that an HTTP POST form navigation to "bar.com" from an HTTP page on // "foo.com" is not upgraded to HTTPS. (HTTP form navigations from HTTPS are // blocked by the Mixed Forms warning.) IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, HttpPageHttpPost_NotUpgraded) { … } // Tests that if an HTTPS navigation redirects to HTTP on a different host, it // should upgrade to HTTPS on that new host. (A downgrade redirect on the same // host would imply a redirect loop.) IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, HttpsToHttpRedirect_ShouldUpgrade) { … } // Tests that navigating to an HTTPS page that downgrades to HTTP on the same // host will fail and trigger the HTTPS-Only Mode interstitial (due to // interceptor detecting a redirect loop and triggering fallback). IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, RedirectLoop_ShouldInterstitial) { … } // Tests that the security level is WARNING when the HTTPS-Only Mode // interstitial is shown for a net error on HTTPS. (Without HTTPS-Only Mode, a // net error would be a security level of NONE.) IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, NetErrorOnUpgrade_SecurityLevelWarning) { … } // Tests that the security level is WARNING when the HTTPS-Only Mode // interstitial is shown for a cert error on HTTPS. (Without HTTPS-Only Mode, a // a cert error would be a security level of DANGEROUS.) After clicking through // the interstitial, the security level should still be WARNING. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, BrokenSSLOnUpgrade_SecurityLevelWarning) { … } // Regression test for crbug.com/1233207. // Tests the case where the HTTP version of a site redirects to HTTPS, but the // HTTPS version of the site has a cert error. If the user initially navigates // to the HTTP URL, then HTTPS-First Mode should upgrade the navigation to HTTPS // and trigger the HTTPS-First Mode interstitial when that fails, but if the // user clicks through the HTTPS-First Mode interstitial and falls back into the // HTTP->HTTPS redirect back to the cert error, then the SSL interstitial should // be shown and the user should be able to click through the SSL interstitial to // visit the HTTPS version of the site (but in a DANGEROUS security level // state). IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, HttpsUpgradeWithBrokenSSL_ShouldTriggerSSLInterstitial) { … } // Tests that clicking the "Learn More" link in the HTTPS-First Mode // interstitial opens a new tab for the help center article. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, InterstitialLearnMoreLink) { … } // Tests that if the user bypasses the HTTPS-First Mode interstitial, and then // later the server fixes their HTTPS support and the user successfully connects // over HTTPS, the allowlist entry is cleared (so HFM will kick in again for // that site). IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, BadHttpsFollowedByGoodHttps) { … } // Tests that clicking the "Go back" button in the HTTPS-First Mode interstitial // navigates back to the previous page (about:blank in this case). IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, InterstitialGoBack) { … } // Tests that closing the tab of the HTTPS-First Mode interstitial counts as // not proceeding through the interstitial for metrics. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, CloseInterstitialTab) { … } // Tests that if a user allowlists a host and then does not visit it again for // seven days (the expiration period), then the interstitial will be shown again // the next time they visit the host. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, AllowlistEntryExpires) { … } // Tests that re-visiting an allowlisted host bumps the expiration time to a new // seven days in the future from now. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, RevisitingBumpsExpiration) { … } // Tests that if a hostname has an HSTS entry registered, then HTTPS-First Mode // should not try to upgrade it (instead allowing HSTS to handle the upgrade as // it is more strict). IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, PreferHstsOverHttpsFirstMode) { … } // Regression test for crbug.com/1272781. Previously, performing back/forward // navigations around the HTTPS-First Mode interstitial could cause history // entries to dropped. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, InterstitialFallbackMaintainsHistory) { … } // Tests that if the HttpAllowlist enterprise policy is set, then HTTPS upgrades // are skipped for hosts in the allowlist. Includes simple hostname, wildcard // hostname pattern, and bare IP address cases. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, EnterpriseAllowlistDisablesUpgrades) { … } // Tests that if the HttpAllowlist enterprise policy is set, then HTTPS upgrades // and HTTPS-First Mode For Site Engagement checks are skipped for hosts in the // allowlist. IN_PROC_BROWSER_TEST_P( HttpsUpgradesBrowserTest, EnterpriseAllowlistDisablesHttpsFirstModeForSiteEngagament) { … } IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, EnterprisePolicyDisablesUpgrades) { … } // Test that HTTPS Upgrades are skipped if the "Insecure content" site setting // is set to "allow". // MIXED_SCRIPT isn't enabled as a content setting on Android. #if BUILDFLAG(IS_ANDROID) #define MAYBE_InsecureContentSettingDisablesUpgrades … #else #define MAYBE_InsecureContentSettingDisablesUpgrades … #endif IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, MAYBE_InsecureContentSettingDisablesUpgrades) { … } // Test that HTTPS Upgrades are skipped if the "Insecure content" site setting // is set to "allow". // MIXED_SCRIPT isn't enabled as a content setting on Android. // This test is identical to InsecureContentSettingDisablesUpgrades except it // sets a high site engagement score for the https URL and checks an additional // histogram. #if BUILDFLAG(IS_ANDROID) #define MAYBE_InsecureContentSettingDisablesHFMForEngagedSites … #else #define MAYBE_InsecureContentSettingDisablesHFMForEngagedSites … #endif IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, MAYBE_InsecureContentSettingDisablesHFMForEngagedSites) { … } // Regression test for crbug.com/1431026. Triggers a navigation where HTTPS // upgrades applied multiple times across redirects to different sites. // Should not crash when DCHECKS are enabled. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, crbug1431026) { … } // Tests that when the HTTPS-First Mode setting is toggled on or off, the // HTTP allowlist is cleared. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, TogglingSettingClearsAllowlist) { … } // Main window HTTP allowlist should not apply to Incognito window. // Regression test for crbug.com/40949400. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, IncognitoHasSeparateAllowlist) { … } // Tests that URLs typed with an explicit http:// scheme are opted out from // upgrades. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, URLsTypedWithHttpSchemeNoUpgrades) { … } // Tests that URLs with an explicit http:// scheme are upgraded if they were // autocompleted. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, URLsAutocompletedWithHttpSchemeAreUpgraded) { … } // Tests that URLs typed with an explicit http:// scheme that result in an // opt-out cause the url to be added to the allowlist. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBrowserTest, URLsTypedWithHttpSchemeNoUpgradesAllowlist) { … } // Url used to detect the presence of a captive portal. constexpr char kCaptivePortalPingUrl[] = …; // HTTPS version of the same URL. constexpr char kCaptivePortalPingUrlHttps[] = …; // Returns a URL loader interceptor that responds to HTTPS URLs with a cert // error and to HTTP URLs with a good response. std::unique_ptr<content::URLLoaderInterceptor> MakeCaptivePortalInterceptor( bool login_page_has_valid_https) { … } void HttpsUpgradesBrowserTest::EnableCaptivePortalDetection(Browser* browser) { … } // Checks that an automatically opened captive portal login page is not upgraded // to HTTPS unless the interstitial is enabled. The captive portal's login // page supports https. IN_PROC_BROWSER_TEST_P( HttpsUpgradesBrowserTest, CaptivePortal_LoginPageWithValidSSL_ShouldNotUpgradeUnlessInterstitialEnabled) { … } // Same as // CaptivePortal_LoginPageWithValidSSL_ShouldNotUpgradeUnlessInterstitialEnabled // but the captive portal's login page serves bad SSL. IN_PROC_BROWSER_TEST_P( HttpsUpgradesBrowserTest, CaptivePortal_LoginPageWithoutValidSSL_ShouldNotUpgradeUnlessInterstitialEnabled) { … } // A simple test fixture that constructs a HistogramTester (so that it gets // initialized before browser startup). Used for testing pref tracking logic. class HttpsUpgradesPrefsBrowserTest : public InProcessBrowserTest { … }; // Tests that the HTTPS-First Mode state is recorded at startup and when // changed. This test requires restarting the browser to test the "at startup" // metric in order for the preference state to be set up before the // HttpsFirstModeService is created. IN_PROC_BROWSER_TEST_F(HttpsUpgradesPrefsBrowserTest, PRE_PrefStatesRecorded) { … } IN_PROC_BROWSER_TEST_F(HttpsUpgradesPrefsBrowserTest, PrefStatesRecorded) { … } enum class BalancedModeParam { … }; // A simple test fixture that constructs a HistogramTester (so that it gets // initialized before browser startup). Used for testing pref tracking logic. // Variant of HttpsUpgradesPrefsBrowserTest but with the // HttpsFirstBalancedMode feature enabled. class HttpsUpgradesBalancedModePrefsBrowserTest : public testing::WithParamInterface<BalancedModeParam>, public InProcessBrowserTest { … }; INSTANTIATE_TEST_SUITE_P(…); // Tests that the HTTPS-First Mode setting is recorded at startup and when // changed, when the HFM-Balanced-Mode feature flag is enabled. This test // requires restarting the browser to test the "at startup" metric in order // for the preference state to be set up before the HttpsFirstModeService is // created. IN_PROC_BROWSER_TEST_P(HttpsUpgradesBalancedModePrefsBrowserTest, PRE_PrefStatesRecorded) { … } IN_PROC_BROWSER_TEST_P(HttpsUpgradesBalancedModePrefsBrowserTest, PrefStatesRecorded) { … } TypicallySecureUserBrowserTest; IN_PROC_BROWSER_TEST_F(TypicallySecureUserBrowserTest, PRE_RestoreCountsOnStartup_OneNavigation) { … } IN_PROC_BROWSER_TEST_F(TypicallySecureUserBrowserTest, RestoreCountsOnStartup_OneNavigation) { … } IN_PROC_BROWSER_TEST_F(TypicallySecureUserBrowserTest, PRE_RestoreCountsOnStartup_TenNavigations) { … } IN_PROC_BROWSER_TEST_F(TypicallySecureUserBrowserTest, RestoreCountsOnStartup_TenNavigations) { … }
Codebase Browser
chromium