| // 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 "base/feature_list.h" |
| #include "base/metrics/histogram_base.h" |
| #include "base/metrics/statistics_recorder.h" |
| #include "base/strings/strcat.h" |
| #include "base/strings/string_split.h" |
| #include "base/task/thread_pool/thread_pool_instance.h" |
| #include "base/test/metrics/histogram_tester.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/ui/browser.h" |
| #include "chrome/test/base/chrome_test_utils.h" |
| #include "chrome/test/base/in_process_browser_test.h" |
| #include "chrome/test/base/ui_test_utils.h" |
| #include "components/language/core/browser/language_prefs.h" |
| #include "components/language/core/browser/pref_names.h" |
| #include "components/metrics/content/subprocess_metrics_provider.h" |
| #include "components/prefs/pref_service.h" |
| #include "content/public/test/browser_test.h" |
| #include "content/public/test/browser_test_utils.h" |
| #include "content/public/test/url_loader_interceptor.h" |
| #include "net/base/features.h" |
| #include "third_party/blink/public/common/metrics/accept_language_and_content_language_usage.h" |
| #include "ui/base/resource/resource_bundle.h" |
| #include "url/origin.h" |
| |
| namespace { |
| |
| using ::content::URLLoaderInterceptor; |
| using ::net::test_server::EmbeddedTestServer; |
| |
| struct RecordLanguageMetricTestOptions { |
| bool has_content_language_in_parent = true; |
| bool has_content_language_in_child = true; |
| std::string parent_content_language_value; |
| std::string child_content_language_value; |
| bool has_xml_lang = false; |
| bool has_html_lang = false; |
| std::string xml_lang_value; |
| std::string html_lang_value; |
| }; |
| |
| const char kLargeLanguages[] = |
| "zh,zh-CN,en-US,en,af,sq,am,ar,an,hy,ast,az,bn,bs,be,eu,br,bg,nl,da,cs,hr," |
| "co,en-AU,en-CA,en-IN,en-NZ,en-ZA,en-GB-oxendict,en-GB,eo,et,fo,fil,fi,fr," |
| "fr-FR,fr-CA,fr-CH,gl,ka,de,gu,gn,el,de-CH,de-LI,de-DE,ht,is,hu,hmn,hi,he," |
| "haw,ig,ja,it-CH,it-IT,it,ga,jv,kn,kk,km,rw,ko,ku,ky,lo,mk,lb,lt,ln,lv,mg," |
| "ms,no,ne,mn,mr,mi,mt,nb,or,oc,ny,nn,pl,fa,ps,om,pt,pt-BR,my,ca,ckb,chr," |
| "ceb,zh-HK,zh-TW,la,ia,id,ha,de-AT,ml,pt-PT,sd,sn,sh,sr,gd,sm,ru,rm,mo,ro," |
| "qu,pa,es-VE,es-UY,es-US,es-ES,es-419,es-MX,es-PE,es-HN,es-CR,es-AR,es,st," |
| "so,sl,sk,si,wa,vi,uz,ug,uk,ur,yi,xh,wo,fy,cy,yo,zu,es-CL,es-CO,su,ta,sv," |
| "sw,tg,tn,to,ti,th,te,tt,tr,tk,tw"; |
| |
| // As translate agent reports the metrics can be later than |
| // MergeHistogramDeltasForTesting, retries fetching |histogram_name| until it |
| // contains at least |count| samples. |
| int RetryForHistogramUntilCountReached( |
| const base::HistogramTester* histogram_tester, |
| const std::string& histogram_name, |
| int count) { |
| while (true) { |
| base::ThreadPoolInstance::Get()->FlushForTesting(); |
| base::RunLoop().RunUntilIdle(); |
| |
| std::vector<base::Bucket> buckets = |
| histogram_tester->GetAllSamples(histogram_name); |
| int total = 0; |
| for (const auto& bucket : buckets) |
| total += bucket.count; |
| |
| if (total >= count) |
| return total; |
| |
| content::FetchHistogramsFromChildProcesses(); |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| base::RunLoop().RunUntilIdle(); |
| } |
| } |
| |
| } // namespace |
| |
| // Browser tests to verify whether language metrics has been recorded correctly. |
| // Since render writes the metrics in DocumentLoader, it will only pick |
| // the top-most content language and set as the document content language. From |
| // navigate request, we will only see the top-most content language, but it's |
| // probably enough to check whether the parent frame has the same content |
| // language setting as child frame. |
| // https://httpwg.org/specs/rfc7231.html#header.content-language |
| class RecordLanguagesMetricsBrowserTest : public InProcessBrowserTest { |
| public: |
| RecordLanguagesMetricsBrowserTest() = default; |
| |
| static constexpr const char kOriginUrl[] = "https://127.0.0.1:44444"; |
| static constexpr const char kLanguageHistorgramName[] = |
| "LanguageUsage.AcceptLanguageAndContentLanguageUsage"; |
| |
| static constexpr const char kXmlHtmlLanguageHistorgramName[] = |
| "LanguageUsage.AcceptLanguageAndXmlHtmlLangUsage"; |
| |
| void SetUpOnMainThread() override { |
| // We use a URLLoaderInterceptor, we also can use the EmbeddedTestServer. |
| url_loader_interceptor_ = |
| std::make_unique<URLLoaderInterceptor>(base::BindRepeating( |
| &RecordLanguagesMetricsBrowserTest::InterceptRequest, |
| base::Unretained(this))); |
| |
| InProcessBrowserTest::SetUpOnMainThread(); |
| } |
| |
| void TearDownOnMainThread() override { |
| url_loader_interceptor_.reset(); |
| InProcessBrowserTest::TearDownOnMainThread(); |
| } |
| |
| void SetTestOptions(const RecordLanguageMetricTestOptions& test_options, |
| const std::set<GURL>& expected_request_urls) { |
| test_options_ = test_options; |
| expected_request_urls_ = expected_request_urls; |
| } |
| |
| GURL content_language_url() const { |
| return GURL(base::StrCat({kOriginUrl, "/content_language.html"})); |
| } |
| |
| GURL xml_html_language_url() const { |
| return GURL(base::StrCat({kOriginUrl, "/xml_html_language.html"})); |
| } |
| |
| GURL content_language_with_iframe_url() const { |
| return GURL( |
| base::StrCat({kOriginUrl, "/content_language_with_iframe.html"})); |
| } |
| |
| GURL simple_request_url() const { |
| return GURL(base::StrCat({kOriginUrl, "/simple.html"})); |
| } |
| |
| GURL last_request_url() const { |
| return url_loader_interceptor_->GetLastRequestURL(); |
| } |
| |
| void NavigateAndVerifyHistogramsMetric( |
| const GURL& url, |
| const blink::AcceptLanguageAndContentLanguageUsage expect_metric_type, |
| const int expect_metric_count) { |
| base::HistogramTester histograms; |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url)); |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| histograms.ExpectBucketCount(kLanguageHistorgramName, expect_metric_type, |
| expect_metric_count); |
| } |
| |
| void NavigateAndVerifyXmlHtmlHistogramsMetric( |
| const GURL& url, |
| const blink::AcceptLanguageAndXmlHtmlLangUsage expect_metric_type, |
| const int expect_metric_count) { |
| base::HistogramTester histograms; |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), url)); |
| |
| RetryForHistogramUntilCountReached(&histograms, |
| kXmlHtmlLanguageHistorgramName, 1); |
| histograms.ExpectBucketCount(kXmlHtmlLanguageHistorgramName, |
| expect_metric_type, expect_metric_count); |
| } |
| |
| void VerifyAcceptLanguage(const std::string& expected_accept_language) { |
| content::WebContents* web_contents = |
| browser()->tab_strip_model()->GetActiveWebContents(); |
| EXPECT_EQ( |
| content::EvalJs(web_contents, "navigator.language").ExtractString(), |
| expected_accept_language); |
| } |
| |
| void SetPerfsAcceptLanguage( |
| const std::vector<std::string>& accept_languages) { |
| std::unique_ptr<language::LanguagePrefs> language_prefs = |
| std::make_unique<language::LanguagePrefs>( |
| browser()->profile()->GetPrefs()); |
| language_prefs->SetUserSelectedLanguagesList(accept_languages); |
| } |
| |
| private: |
| // URLLoaderInterceptor callback |
| bool InterceptRequest(URLLoaderInterceptor::RequestParams* params) { |
| if (expected_request_urls_.find(params->url_request.url) == |
| expected_request_urls_.end()) |
| return false; |
| |
| std::string path = "chrome/test/data/content_language"; |
| path.append(static_cast<std::string>(params->url_request.url.path_piece())); |
| |
| // build response header and body for xml html lang tag value |
| if (params->url_request.url.path() == "/xml_html_language.html") { |
| URLLoaderInterceptor::WriteResponse( |
| BuildXmlHtmlHeader(), BuildXmlHtmlBody(), params->client.get()); |
| return true; |
| } |
| |
| std::string headers = "HTTP/1.1 200 OK\nContent-Type: text/html\n"; |
| if (params->url_request.url.path() == "/simple.html") { |
| base::StrAppend(&headers, {BuildIframeResponseHeader()}); |
| } else { |
| base::StrAppend(&headers, {BuildResponseHeader()}); |
| } |
| |
| URLLoaderInterceptor::WriteResponse(path, params->client.get(), &headers, |
| std::nullopt, |
| /*url=*/params->url_request.url); |
| return true; |
| } |
| |
| std::string BuildXmlHtmlBody() { |
| std::string body = "<html "; |
| if (test_options_.has_xml_lang) { |
| base::StrAppend(&body, |
| {" xmlns='http://www.w3.org/1999/xhtml' xml:lang='", |
| test_options_.xml_lang_value, "' "}); |
| } |
| if (test_options_.has_html_lang) { |
| base::StrAppend(&body, {" lang='", test_options_.html_lang_value, "' "}); |
| } |
| base::StrAppend(&body, {" ><head></head></html>"}); |
| return body; |
| } |
| |
| std::string BuildXmlHtmlHeader() { |
| std::string headers = "HTTP/1.1 200 OK\n"; |
| if (test_options_.has_xml_lang) { |
| base::StrAppend(&headers, {"Content-Type: application/xhtml+xml\n"}); |
| } else { |
| base::StrAppend(&headers, {"Content-Type: text/html\n"}); |
| } |
| |
| if (test_options_.has_content_language_in_parent) { |
| base::StrAppend(&headers, |
| {"Content-Language: ", |
| test_options_.parent_content_language_value, "\n"}); |
| } |
| |
| return headers; |
| } |
| |
| std::string BuildResponseHeader() { |
| std::string headers; |
| |
| if (!test_options_.has_content_language_in_parent) { |
| return headers; |
| } |
| base::StrAppend(&headers, |
| {"Content-Language: ", |
| test_options_.parent_content_language_value, "\n"}); |
| return headers; |
| } |
| |
| std::string BuildIframeResponseHeader() { |
| std::string headers; |
| |
| if (!test_options_.has_content_language_in_child) { |
| return headers; |
| } |
| |
| base::StrAppend(&headers, |
| {"Content-Language: ", |
| test_options_.child_content_language_value, "\n"}); |
| return headers; |
| } |
| |
| std::unique_ptr<URLLoaderInterceptor> url_loader_interceptor_; |
| std::set<GURL> expected_request_urls_; |
| RecordLanguageMetricTestOptions test_options_; |
| std::unique_ptr<language::LanguagePrefs> language_prefs_; |
| }; |
| |
| constexpr const char RecordLanguagesMetricsBrowserTest::kOriginUrl[]; |
| constexpr const char |
| RecordLanguagesMetricsBrowserTest::kLanguageHistorgramName[]; |
| constexpr const char |
| RecordLanguagesMetricsBrowserTest::kXmlHtmlLanguageHistorgramName[]; |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| ContentLanguageEmpty) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/""}, |
| {content_language_url()}); |
| |
| NavigateAndVerifyHistogramsMetric( |
| content_language_url(), |
| blink::AcceptLanguageAndContentLanguageUsage::kContentLanguageEmpty, 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| ContentLanguageIsWildcard) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"*", |
| /*child_content_language_value=*/""}, |
| {content_language_url()}); |
| |
| NavigateAndVerifyHistogramsMetric( |
| content_language_url(), |
| blink::AcceptLanguageAndContentLanguageUsage::kContentLanguageWildcard, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| ContentLanguageMatchTopMostAcceptLanguage) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"en-US", |
| /*child_content_language_value=*/""}, |
| {content_language_url()}); |
| |
| // The default Accept-Language is (en-US). |
| VerifyAcceptLanguage("en-US"); |
| NavigateAndVerifyHistogramsMetric( |
| content_language_url(), |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageMatchesPrimaryAcceptLanguage, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| ContentLanguageMatchesAnyAcceptLanguage) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"en", |
| /*child_content_language_value=*/""}, |
| {content_language_url()}); |
| |
| // The default Accept-Language is (en-US). |
| VerifyAcceptLanguage("en-US"); |
| NavigateAndVerifyHistogramsMetric( |
| content_language_url(), |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageMatchesAnyAcceptLanguage, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| IframeContentLanguageChildDifferFromParent) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/true, |
| /*parent_content_language_value=*/"fr", |
| /*child_content_language_value=*/"zh-CN"}, |
| {content_language_with_iframe_url(), simple_request_url()}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), |
| content_language_with_iframe_url())); |
| EXPECT_EQ(last_request_url().path(), "/simple.html"); |
| |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| |
| // Child Content-Language vs Parent Content-Language |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageSubframeDiffers, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F( |
| RecordLanguagesMetricsBrowserTest, |
| IframeParentHasConentLanguageAndChildContentLanguageIsEmpty) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"en-US", |
| /*child_content_language_value=*/""}, |
| {content_language_with_iframe_url(), simple_request_url()}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), |
| content_language_with_iframe_url())); |
| EXPECT_EQ(last_request_url().path(), "/simple.html"); |
| |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| |
| // Accept-Language vs Parent Content-Language: en-US == en-US |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageMatchesPrimaryAcceptLanguage, |
| 1); |
| |
| // Accept-Language vs Child Content-Language: empty |
| histograms.ExpectBucketCount( |
| kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage::kContentLanguageEmpty, 1); |
| |
| // Child Content-Language vs Parent Content-Language |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageSubframeDiffers, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F( |
| RecordLanguagesMetricsBrowserTest, |
| IframeParentContentLanguageIsEmptyAndChildContentLanguageHasValue) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/true, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"en-US"}, |
| {content_language_with_iframe_url(), simple_request_url()}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), |
| content_language_with_iframe_url())); |
| EXPECT_EQ(last_request_url().path(), "/simple.html"); |
| |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| |
| // Accept-Language vs Parent Content-Language: empty |
| histograms.ExpectBucketCount( |
| kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage::kContentLanguageEmpty, 1); |
| |
| // Accept-Language vs Child Content-Language: en-US == en-US |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageMatchesPrimaryAcceptLanguage, |
| 1); |
| |
| // Child Content-Language vs Parent Content-Language |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageSubframeDiffers, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| IframeBothParentAndChildContentLanguageIsEmpty) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/""}, |
| {content_language_with_iframe_url(), simple_request_url()}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), |
| content_language_with_iframe_url())); |
| EXPECT_EQ(last_request_url().path(), "/simple.html"); |
| |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| |
| // Accept-Language vs Parent Content-Language: empty |
| // Accept-Language vs Child Content-Language: empty |
| histograms.ExpectBucketCount( |
| kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage::kContentLanguageEmpty, 2); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| IframeParentAndChildContentLanguageHasSameValue) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/true, |
| /*parent_content_language_value=*/"en-US", |
| /*child_content_language_value=*/"en-US"}, |
| {content_language_with_iframe_url(), simple_request_url()}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), |
| content_language_with_iframe_url())); |
| EXPECT_EQ(last_request_url().path(), "/simple.html"); |
| |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| |
| // The default Accept-Language is (en-US). |
| VerifyAcceptLanguage("en-US"); |
| |
| // Accept-Language vs Parent Content-Language: match top-most |
| // Accept-Language vs Child Content-Language: match top-most |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageMatchesPrimaryAcceptLanguage, |
| 2); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| IframeParentAndChildContentLanguageAreStar) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/true, |
| /*parent_content_language_value=*/"*", |
| /*child_content_language_value=*/"*"}, |
| {content_language_with_iframe_url(), simple_request_url()}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), |
| content_language_with_iframe_url())); |
| EXPECT_EQ(last_request_url().path(), "/simple.html"); |
| |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| |
| // The default Accept-Language is (en-US). |
| VerifyAcceptLanguage("en-US"); |
| |
| // Accept-Language vs Parent Content-Language: * |
| // Accept-Language vs Child Content-Language: * |
| histograms.ExpectBucketCount( |
| kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage::kContentLanguageWildcard, |
| 2); |
| } |
| |
| IN_PROC_BROWSER_TEST_F( |
| RecordLanguagesMetricsBrowserTest, |
| IframeParentHasConentLanguageAndChildContentLanguageIsStar) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/true, |
| /*parent_content_language_value=*/"en-US", |
| /*child_content_language_value=*/"*"}, |
| {content_language_with_iframe_url(), simple_request_url()}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), |
| content_language_with_iframe_url())); |
| EXPECT_EQ(last_request_url().path(), "/simple.html"); |
| |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| |
| // Accept-Language vs Parent Content-Language: en-US == en-US |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageMatchesPrimaryAcceptLanguage, |
| 1); |
| |
| // Accept-Language vs Child Content-Language: * |
| histograms.ExpectBucketCount( |
| kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage::kContentLanguageWildcard, |
| 1); |
| |
| // Child Content-Language vs Parent Content-Language |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageSubframeDiffers, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F( |
| RecordLanguagesMetricsBrowserTest, |
| IframeParentContentLanuageIsStarAndChildContentLanguageHasValue) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/true, |
| /*parent_content_language_value=*/"*", |
| /*child_content_language_value=*/"en-US"}, |
| {content_language_with_iframe_url(), simple_request_url()}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), |
| content_language_with_iframe_url())); |
| EXPECT_EQ(last_request_url().path(), "/simple.html"); |
| |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| |
| // Accept-Language vs Parent Content-Language: * |
| histograms.ExpectBucketCount( |
| kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage::kContentLanguageWildcard, |
| 1); |
| |
| // Accept-Language vs Child Content-Language: en-US == en-US |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageMatchesPrimaryAcceptLanguage, |
| 1); |
| |
| // Child Content-Language vs Parent Content-Language |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageSubframeDiffers, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| LargeAcceptLanguageList) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/true, |
| /*parent_content_language_value=*/kLargeLanguages, |
| /*child_content_language_value=*/kLargeLanguages}, |
| {content_language_with_iframe_url(), simple_request_url()}); |
| |
| SetPerfsAcceptLanguage(base::SplitString( |
| kLargeLanguages, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)); |
| VerifyAcceptLanguage("zh"); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), |
| content_language_with_iframe_url())); |
| EXPECT_EQ(last_request_url().path(), "/simple.html"); |
| |
| metrics::SubprocessMetricsProvider::MergeHistogramDeltasForTesting(); |
| // Accept-Language vs Parent Content-Language: match top-most |
| // Accept-Language vs Child Content-Language: match top-most |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageMatchesAnyAcceptLanguage, |
| 2); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, XmlLangEmpty) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/true, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"", |
| /*html_lang_value=*/"en-US"}, |
| {xml_html_language_url()}); |
| |
| NavigateAndVerifyXmlHtmlHistogramsMetric( |
| xml_html_language_url(), |
| blink::AcceptLanguageAndXmlHtmlLangUsage::kXmlLangEmpty, 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, XmlLangIsDash) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/true, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"-", |
| /*html_lang_value=*/"en-US"}, |
| {xml_html_language_url()}); |
| // Make sure no crash and no metric reports. |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), xml_html_language_url())); |
| RetryForHistogramUntilCountReached(&histograms, |
| kXmlHtmlLanguageHistorgramName, 0); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, HtmlLangIsDash) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/true, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"", |
| /*html_lang_value=*/"-"}, |
| {xml_html_language_url()}); |
| // Make sure no crash and no metric reports. |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), xml_html_language_url())); |
| RetryForHistogramUntilCountReached(&histograms, |
| kXmlHtmlLanguageHistorgramName, 0); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, XmlLangWildcard) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/true, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"*", |
| /*html_lang_value=*/"en-US"}, |
| {xml_html_language_url()}); |
| |
| NavigateAndVerifyXmlHtmlHistogramsMetric( |
| xml_html_language_url(), |
| blink::AcceptLanguageAndXmlHtmlLangUsage::kXmlLangWildcard, 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| XmlLangMatchesAnyNonPrimayAcceptLanguage) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/true, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"zh-CN", |
| /*html_lang_value=*/"zh-CN"}, |
| {xml_html_language_url()}); |
| |
| SetPerfsAcceptLanguage({"en-US", "en-GB", "zh", "zh-CN"}); |
| NavigateAndVerifyXmlHtmlHistogramsMetric( |
| xml_html_language_url(), |
| blink::AcceptLanguageAndXmlHtmlLangUsage:: |
| kXmlLangMatchesAnyNonPrimayAcceptLanguage, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| XmlLangMatchesPrimaryAcceptLanguage) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/true, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"en-US", |
| /*html_lang_value=*/"en-US"}, |
| {xml_html_language_url()}); |
| |
| SetPerfsAcceptLanguage({"en-US", "en-GB", "zh", "zh-CN"}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), xml_html_language_url())); |
| |
| RetryForHistogramUntilCountReached(&histograms, |
| kXmlHtmlLanguageHistorgramName, 1); |
| // xml lang matches primary accept language |
| histograms.ExpectBucketCount(kXmlHtmlLanguageHistorgramName, |
| blink::AcceptLanguageAndXmlHtmlLangUsage:: |
| kXmlLangMatchesPrimaryAcceptLanguage, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| XmlLangMatchesPrimaryAcceptLanguageWithoutLocale) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/true, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"en-GB", |
| /*html_lang_value=*/"en-GB"}, |
| {xml_html_language_url()}); |
| |
| SetPerfsAcceptLanguage({"en-US", "en-GB", "zh", "zh-CN"}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), xml_html_language_url())); |
| |
| RetryForHistogramUntilCountReached(&histograms, |
| kXmlHtmlLanguageHistorgramName, 1); |
| |
| // xml lang matches primary accept language |
| histograms.ExpectBucketCount(kXmlHtmlLanguageHistorgramName, |
| blink::AcceptLanguageAndXmlHtmlLangUsage:: |
| kXmlLangMatchesPrimaryAcceptLanguage, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, HtmlLangEmpty) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/false, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"", |
| /*html_lang_value=*/""}, |
| {xml_html_language_url()}); |
| |
| NavigateAndVerifyXmlHtmlHistogramsMetric( |
| xml_html_language_url(), |
| blink::AcceptLanguageAndXmlHtmlLangUsage::kHtmlLangEmpty, 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, HtmlLangWildCard) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/false, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"", |
| /*html_lang_value=*/"*"}, |
| {xml_html_language_url()}); |
| |
| NavigateAndVerifyXmlHtmlHistogramsMetric( |
| xml_html_language_url(), |
| blink::AcceptLanguageAndXmlHtmlLangUsage::kHtmlLangWildcard, 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| HtmlLangMatchesAnyNonPrimayAcceptLanguage) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/false, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"", |
| /*html_lang_value=*/"zh-CN"}, |
| {xml_html_language_url()}); |
| |
| SetPerfsAcceptLanguage({"en-US", "en-GB", "zh", "zh-CN"}); |
| NavigateAndVerifyXmlHtmlHistogramsMetric( |
| xml_html_language_url(), |
| blink::AcceptLanguageAndXmlHtmlLangUsage:: |
| kHtmlLangMatchesAnyNonPrimayAcceptLanguage, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| HtmlLangMatchesPrimaryAcceptLanguage) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/false, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"", |
| /*html_lang_value=*/"en-US"}, |
| {xml_html_language_url()}); |
| |
| SetPerfsAcceptLanguage({"en-US", "en-GB", "zh", "zh-CN"}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), xml_html_language_url())); |
| |
| RetryForHistogramUntilCountReached(&histograms, |
| kXmlHtmlLanguageHistorgramName, 1); |
| |
| // html lang matches primary accept language |
| histograms.ExpectBucketCount(kXmlHtmlLanguageHistorgramName, |
| blink::AcceptLanguageAndXmlHtmlLangUsage:: |
| kHtmlLangMatchesPrimaryAcceptLanguage, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| HtmlLangMatchesPrimaryAcceptLanguageWithoutLocale) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/false, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"", |
| /*html_lang_value=*/"en-GB"}, |
| {xml_html_language_url()}); |
| |
| SetPerfsAcceptLanguage({"en-US", "en-GB", "zh", "zh-CN"}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), xml_html_language_url())); |
| |
| RetryForHistogramUntilCountReached(&histograms, |
| kXmlHtmlLanguageHistorgramName, 1); |
| |
| // html lang matches primary accept language |
| histograms.ExpectBucketCount(kXmlHtmlLanguageHistorgramName, |
| blink::AcceptLanguageAndXmlHtmlLangUsage:: |
| kHtmlLangMatchesPrimaryAcceptLanguage, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| HtmlLangMatchesMatchNonPrimaryAcceptLanguageZh) { |
| SetTestOptions({/*has_content_language_in_parent=*/false, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/false, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"", |
| /*html_lang_value=*/"zh-HK"}, |
| {xml_html_language_url()}); |
| |
| SetPerfsAcceptLanguage({"zh-CN", "zh-TW", "zh-HK"}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), xml_html_language_url())); |
| |
| RetryForHistogramUntilCountReached(&histograms, |
| kXmlHtmlLanguageHistorgramName, 1); |
| |
| // zh family, html lang matches non-primary accept language instead of primary |
| histograms.ExpectBucketCount(kXmlHtmlLanguageHistorgramName, |
| blink::AcceptLanguageAndXmlHtmlLangUsage:: |
| kHtmlLangMatchesAnyNonPrimayAcceptLanguage, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| XmlLanguageContentLanguageIntegrationTest) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"zh", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/true, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"zh-CN", |
| /*html_lang_value=*/"zh-CN"}, |
| {xml_html_language_url()}); |
| |
| SetPerfsAcceptLanguage({"en-US", "en-GB", "zh", "zh-CN", "en"}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), xml_html_language_url())); |
| |
| RetryForHistogramUntilCountReached(&histograms, |
| kXmlHtmlLanguageHistorgramName, 1); |
| |
| // Accept-Language vs xml:lang: match any |
| histograms.ExpectBucketCount(kXmlHtmlLanguageHistorgramName, |
| blink::AcceptLanguageAndXmlHtmlLangUsage:: |
| kXmlLangMatchesAnyNonPrimayAcceptLanguage, |
| 1); |
| |
| // Accept-Language vs Content-Language: match any |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageMatchesAnyAcceptLanguage, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(RecordLanguagesMetricsBrowserTest, |
| HtmlLanguageContentLanguageIntegrationTest) { |
| SetTestOptions({/*has_content_language_in_parent=*/true, |
| /*has_content_language_in_child=*/false, |
| /*parent_content_language_value=*/"zh", |
| /*child_content_language_value=*/"", |
| /*has_xml_lang=*/false, |
| /*has_html_lang=*/true, |
| /*xml_lang_value=*/"", |
| /*html_lang_value=*/"en-US"}, |
| {xml_html_language_url()}); |
| |
| SetPerfsAcceptLanguage({"en-US", "en-GB", "zh", "zh-CN", "en"}); |
| |
| base::HistogramTester histograms; |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), xml_html_language_url())); |
| |
| RetryForHistogramUntilCountReached(&histograms, |
| kXmlHtmlLanguageHistorgramName, 1); |
| |
| // Accept-Language vs html lang: match primary |
| histograms.ExpectBucketCount(kXmlHtmlLanguageHistorgramName, |
| blink::AcceptLanguageAndXmlHtmlLangUsage:: |
| kHtmlLangMatchesPrimaryAcceptLanguage, |
| 1); |
| |
| // Accept-Language vs Content-Language: match any |
| histograms.ExpectBucketCount(kLanguageHistorgramName, |
| blink::AcceptLanguageAndContentLanguageUsage:: |
| kContentLanguageMatchesAnyAcceptLanguage, |
| 1); |
| } |