| // Copyright 2026 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <memory> |
| #include <string> |
| #include <string_view> |
| #include <tuple> |
| #include <vector> |
| |
| #include "base/feature_list.h" |
| #include "base/metrics/field_trial_params.h" |
| #include "base/notimplemented.h" |
| #include "base/run_loop.h" |
| #include "base/strings/strcat.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/to_string.h" |
| #include "base/test/metrics/histogram_tester.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "build/build_config.h" |
| #include "content/browser/web_contents/web_contents_impl.h" |
| #include "content/common/renderer.mojom.h" |
| #include "content/public/test/browser_test.h" |
| #include "content/public/test/browser_test_utils.h" |
| #include "content/public/test/content_browser_test.h" |
| #include "content/public/test/content_browser_test_utils.h" |
| #include "content/shell/browser/shell.h" |
| #include "net/base/features.h" |
| #include "net/dns/mock_host_resolver.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/http_response.h" |
| #include "third_party/blink/public/common/features.h" |
| #include "url/gurl.h" |
| |
| #if !BUILDFLAG(IS_FUCHSIA) |
| namespace { |
| // See the definition of `v8::internal::ScriptCompileTimerScope::CacheBehaviour` |
| // in `v8/src/codegen/compiler.cc` for the correspondence. |
| int CacheBehaviourNameToInt(std::string_view name) { |
| if (name == "kProduceCodeCache") { |
| return 0; |
| } |
| if (name == "kHitIsolateCacheWhenNoCache") { |
| return 1; |
| } |
| if (name == "kConsumeCodeCache") { |
| return 2; |
| } |
| if (name == "kNoCacheBecauseScriptTooSmall") { |
| return 5; |
| } |
| if (name == "kNoCacheBecauseCacheTooCold") { |
| return 6; |
| } |
| if (name == "kHitIsolateCacheWhenProduceCodeCache") { |
| return 14; |
| } |
| if (name == "kHitIsolateCacheWhenConsumeCodeCache") { |
| return 15; |
| } |
| if (name == "kNoCacheBecauseInlineScriptCacheTooCold") { |
| return 22; |
| } |
| // TODO: Add other values if necessary. |
| NOTIMPLEMENTED(); |
| return -1; |
| } |
| |
| int GetProduceCacheCount(const base::HistogramTester& histogram_tester) { |
| return histogram_tester.GetBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kProduceCodeCache")) + |
| histogram_tester.GetBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kHitIsolateCacheWhenProduceCodeCache")); |
| } |
| |
| int GetConsumeCacheCount(const base::HistogramTester& histogram_tester) { |
| return histogram_tester.GetBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kConsumeCodeCache")) + |
| histogram_tester.GetBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kHitIsolateCacheWhenConsumeCodeCache")); |
| } |
| |
| } // namespace |
| |
| namespace content { |
| |
| class InlineScriptCodeCacheBrowserTestBase : public ContentBrowserTest { |
| public: |
| InlineScriptCodeCacheBrowserTestBase() = default; |
| |
| protected: |
| void InitFeatures(bool use_persistent_cache, |
| const base::FieldTrialParams& extra_params) { |
| base::FieldTrialParams params = extra_params; |
| base::FieldTrialParams default_params = {{"timeout", "1s"}}; |
| params.merge(default_params); |
| |
| std::vector<base::test::FeatureRefAndParams> enabled_features = { |
| {net::features::kSplitCacheByNetworkIsolationKey, {}}, |
| {net::features::kSplitCodeCacheByNetworkIsolationKey, {}}, |
| {blink::features::kInlineScriptCache, params}}; |
| std::vector<base::test::FeatureRef> disabled_features; |
| |
| if (use_persistent_cache) { |
| enabled_features.push_back( |
| {blink::features::kUsePersistentCacheForCodeCache, {}}); |
| } else { |
| disabled_features.push_back( |
| blink::features::kUsePersistentCacheForCodeCache); |
| } |
| |
| scoped_feature_list_.InitWithFeaturesAndParameters(enabled_features, |
| disabled_features); |
| } |
| |
| public: |
| void SetUpCommandLine(base::CommandLine* command_line) override { |
| IsolateAllSitesForTesting(command_line); |
| } |
| |
| void SetUpOnMainThread() override { |
| host_resolver()->AddRule("*", "127.0.0.1"); |
| embedded_test_server()->RegisterRequestHandler(base::BindRepeating( |
| &InlineScriptCodeCacheBrowserTestBase::RequestHandler, |
| base::Unretained(this))); |
| ASSERT_TRUE(embedded_test_server()->Start()); |
| } |
| |
| std::unique_ptr<net::test_server::HttpResponse> RequestHandler( |
| const net::test_server::HttpRequest& request) { |
| GURL absolute_url = embedded_test_server()->GetURL(request.relative_url); |
| |
| if (absolute_url.GetPath() == "/inline-script.html" || |
| absolute_url.GetPath() == "/same-inline-script.html") { |
| auto http_response = |
| std::make_unique<net::test_server::BasicHttpResponse>(); |
| http_response->set_code(net::HTTP_OK); |
| std::string title = absolute_url.GetPath() == "/inline-script.html" |
| ? "A Page" |
| : "A PageDifferent Page"; |
| // Run a short, heavy script before the test script to warmup connection |
| // to the inline script cache backend. |
| std::string content = |
| base::StrCat({"<html><head><title>", title, "</title></head>", |
| "<body><script type='text/javascript'>", |
| GenerateUniqueHeavyJavascriptSource(), |
| "</script><script type='text/javascript'>", |
| GetCacheableLongStaticJavascriptSource(), |
| "</script></body></html>"}); |
| |
| http_response->set_content(content); |
| http_response->set_content_type("text/html"); |
| return http_response; |
| } |
| if (absolute_url.GetPath() == "/default-cachehint.html" || |
| absolute_url.GetPath() == "/eager-cachehint.html" || |
| absolute_url.GetPath() == "/never-cachehint.html") { |
| auto http_response = |
| std::make_unique<net::test_server::BasicHttpResponse>(); |
| http_response->set_code(net::HTTP_OK); |
| std::string cachehint_value = "default"; |
| if (absolute_url.GetPath() == "/eager-cachehint.html") { |
| cachehint_value = "eager"; |
| } else if (absolute_url.GetPath() == "/never-cachehint.html") { |
| cachehint_value = "never"; |
| } |
| std::string content = base::StrCat( |
| {"<html><head><title>Title</title></head><body>", |
| "<script type='text/javascript'>", |
| GenerateUniqueHeavyJavascriptSource(), |
| "</script><script type='text/javascript' cachehint='", |
| cachehint_value, "'>", GetCacheableLongStaticJavascriptSource(), |
| "</script></body></html>\n"}); |
| http_response->set_content(content); |
| http_response->set_content_type("text/html"); |
| return http_response; |
| } |
| if (absolute_url.GetPath() == "/short-inline-script.html") { |
| auto http_response = |
| std::make_unique<net::test_server::BasicHttpResponse>(); |
| http_response->set_code(net::HTTP_OK); |
| |
| // HTML with a very short inline script. |
| std::string short_script = "/*short*/"; |
| EXPECT_LT(short_script.length(), |
| blink::features::kInlineScriptCacheMinScriptLength.Get()); |
| std::string content = |
| base::StrCat({"<html><head><title>Title</title></head><body>", |
| "<script type='text/javascript'>", short_script, |
| "</script></body></html>\n"}); |
| |
| http_response->set_content(content); |
| http_response->set_content_type("text/html"); |
| return http_response; |
| } |
| if (absolute_url.GetPath() == "/empty.html") { |
| auto http_response = |
| std::make_unique<net::test_server::BasicHttpResponse>(); |
| http_response->set_code(net::HTTP_OK); |
| http_response->set_content("<html><body></body></html>"); |
| http_response->set_content_type("text/html"); |
| return http_response; |
| } |
| |
| return nullptr; |
| } |
| |
| void PurgeResourceCacheFromTheMainFrame() { |
| base::RunLoop loop; |
| static_cast<WebContentsImpl*>(shell()->web_contents()) |
| ->GetPrimaryFrameTree() |
| .root() |
| ->current_frame_host() |
| ->GetProcess() |
| ->GetRendererInterface() |
| ->PurgeResourceCache(loop.QuitClosure()); |
| loop.Run(); |
| } |
| |
| void LoadIframe(const GURL& url) { |
| EXPECT_TRUE( |
| ExecJs(shell()->web_contents(), |
| JsReplace("const iframe = document.createElement('iframe');" |
| "iframe.src = $1;" |
| "document.body.appendChild(iframe);", |
| url))); |
| EXPECT_TRUE(WaitForLoadStop(shell()->web_contents())); |
| } |
| |
| void PurgeResourceCacheFromTheFirstSubFrame() { |
| FrameTreeNode* root = static_cast<WebContentsImpl*>(shell()->web_contents()) |
| ->GetPrimaryFrameTree() |
| .root(); |
| CHECK(root->child_count() != 0); |
| base::RunLoop loop; |
| root->child_at(root->child_count() - 1) |
| ->current_frame_host() |
| ->GetProcess() |
| ->GetRendererInterface() |
| ->PurgeResourceCache(loop.QuitClosure()); |
| loop.Run(); |
| } |
| |
| private: |
| std::string GenerateUniqueHeavyJavascriptSource() { |
| ++served_count_; |
| // A time-consuming script to run. |
| std::string source = |
| base::StrCat({"const a=[...Array(10000000).keys()];let s=", |
| base::NumberToString(served_count_), ";", |
| "for(let i=0;i<a.length;i++)s+=i*(i+1)-a[i];" |
| "console.log(s);"}); |
| EXPECT_LT(source.length(), |
| blink::features::kInlineScriptCacheMinScriptLength.Get()); |
| return source; |
| } |
| |
| // A script longer enough to be cached. |
| std::string GetCacheableLongStaticJavascriptSource() { |
| return base::StrCat( |
| {"function testFunction() {\n", |
| std::string(blink::features::kInlineScriptCacheMinScriptLength.Get(), |
| '/'), |
| "\nreturn 42;\n}"}); |
| } |
| |
| base::test::ScopedFeatureList scoped_feature_list_; |
| uint32_t served_count_ = 0; |
| }; |
| |
| class InlineScriptCodeCacheBrowserTest |
| : public InlineScriptCodeCacheBrowserTestBase, |
| public testing::WithParamInterface<bool> { |
| public: |
| InlineScriptCodeCacheBrowserTest() { InitFeatures(GetParam(), {}); } |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(All, |
| InlineScriptCodeCacheBrowserTest, |
| testing::Bool()); |
| |
| class InlineScriptCacheHintBrowserTest |
| : public InlineScriptCodeCacheBrowserTestBase, |
| public testing::WithParamInterface<std::tuple<bool, bool>> { |
| public: |
| InlineScriptCacheHintBrowserTest() { |
| bool use_persistent_cache = std::get<0>(GetParam()); |
| bool enable_for_default_hint = std::get<1>(GetParam()); |
| InitFeatures(use_persistent_cache, |
| {{"enable_for_default_hint", |
| enable_for_default_hint ? "true" : "false"}}); |
| } |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(All, |
| InlineScriptCacheHintBrowserTest, |
| testing::Combine(testing::Bool(), testing::Bool())); |
| |
| // TODO(crbug.com/498265776): Test is expected to time out on some slow |
| // builders. |
| #if defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \ |
| ((BUILDFLAG(IS_WIN) || BUILDFLAG(IS_LINUX)) && !defined(NDEBUG)) |
| #define MAYBE_DefaultCacheHint DISABLED_DefaultCacheHint |
| #else |
| #define MAYBE_DefaultCacheHint DefaultCacheHint |
| #endif |
| IN_PROC_BROWSER_TEST_P(InlineScriptCacheHintBrowserTest, |
| MAYBE_DefaultCacheHint) { |
| GURL url = |
| embedded_test_server()->GetURL("example.com", "/default-cachehint.html"); |
| |
| // Step 1: Load the page first time. |
| { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| FetchHistogramsFromChildProcesses(); |
| if (std::get<1>(GetParam())) { |
| histogram_tester.ExpectBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kNoCacheBecauseInlineScriptCacheTooCold"), |
| 1); |
| } |
| } |
| |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| |
| // Step 2: Reload to produce cache. |
| { |
| bool produced = false; |
| for (int i = 0; i < 5; i++) { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| FetchHistogramsFromChildProcesses(); |
| if (GetProduceCacheCount(histogram_tester) == 1) { |
| produced = true; |
| break; |
| } |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| if (std::get<1>(GetParam())) { |
| EXPECT_TRUE(produced) << "Failed to produce cache"; |
| } else { |
| EXPECT_FALSE(produced) << "Cache should not be produced"; |
| } |
| } |
| } |
| |
| // TODO(crbug.com/498265776): Test is expected to time out on some slow |
| // builders. |
| #if defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \ |
| (BUILDFLAG(IS_WIN) && !defined(NDEBUG)) |
| #define MAYBE_EagerCacheHint DISABLED_EagerCacheHint |
| #else |
| #define MAYBE_EagerCacheHint EagerCacheHint |
| #endif |
| IN_PROC_BROWSER_TEST_P(InlineScriptCacheHintBrowserTest, MAYBE_EagerCacheHint) { |
| GURL url = |
| embedded_test_server()->GetURL("example.com", "/eager-cachehint.html"); |
| |
| // Step 1: Load the page first time. |
| { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| FetchHistogramsFromChildProcesses(); |
| histogram_tester.ExpectBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kNoCacheBecauseInlineScriptCacheTooCold"), 1); |
| } |
| |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| |
| // Step 2: Reload to produce cache. |
| { |
| bool produced = false; |
| for (int i = 0; i < 5; i++) { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| FetchHistogramsFromChildProcesses(); |
| if (GetProduceCacheCount(histogram_tester) == 1) { |
| produced = true; |
| break; |
| } |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| EXPECT_TRUE(produced) << "Failed to produce cache"; |
| } |
| } |
| |
| // TODO(crbug.com/498265776): Test is expected to time out on some slow |
| // builders. |
| #if defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \ |
| ((BUILDFLAG(IS_WIN) || BUILDFLAG(IS_LINUX)) && !defined(NDEBUG)) |
| #define MAYBE_NeverCacheHint DISABLED_NeverCacheHint |
| #else |
| #define MAYBE_NeverCacheHint NeverCacheHint |
| #endif |
| IN_PROC_BROWSER_TEST_P(InlineScriptCacheHintBrowserTest, MAYBE_NeverCacheHint) { |
| GURL url = |
| embedded_test_server()->GetURL("example.com", "/never-cachehint.html"); |
| |
| // Load multiple times, expect NO cache produced. |
| const int num_tries = 3; |
| base::HistogramTester histogram_tester; |
| for (int i = 0; i < num_tries; i++) { |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| FetchHistogramsFromChildProcesses(); |
| EXPECT_EQ(GetProduceCacheCount(histogram_tester), 0); |
| EXPECT_EQ(GetConsumeCacheCount(histogram_tester), 0); |
| } |
| |
| // TODO(crbug.com/498265776): Test is failing on ChromeOS and Linux MSan. |
| // TODO(crbug.com/499507137): Disabled everywhere due to flakiness. |
| IN_PROC_BROWSER_TEST_P(InlineScriptCodeCacheBrowserTest, |
| DISABLED_CacheProducedOnSecondAttempt) { |
| GURL url = |
| embedded_test_server()->GetURL("example.com", "/inline-script.html"); |
| |
| // Step 1: Load the page first time. No cache is used. |
| { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| FetchHistogramsFromChildProcesses(); |
| histogram_tester.ExpectBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kNoCacheBecauseInlineScriptCacheTooCold"), 1); |
| } |
| |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| |
| // Step 2: Reload the page. The script will be compiled from source and then |
| // producing the cache to store it on persistent storage. |
| { |
| bool produced = false; |
| for (int i = 0; i < 5; i++) { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| FetchHistogramsFromChildProcesses(); |
| if (GetProduceCacheCount(histogram_tester) == 1) { |
| produced = true; |
| break; |
| } |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| EXPECT_TRUE(produced) << "Failed to produce cache"; |
| } |
| |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| |
| // Step 3: Reload the page again. The script will be compiled from code cache. |
| |
| { |
| bool consumed = false; |
| for (int i = 0; i < 5; i++) { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| FetchHistogramsFromChildProcesses(); |
| if (GetConsumeCacheCount(histogram_tester) == 1) { |
| consumed = true; |
| break; |
| } |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| EXPECT_TRUE(consumed) << "Failed to consume cache"; |
| } |
| } |
| |
| // TODO(crbug.com/498265776): Test is failing on ChromeOS and Linux MSan. |
| // TODO(crbug.com/499208353): Disabled everywhere for flakiness. |
| IN_PROC_BROWSER_TEST_P(InlineScriptCodeCacheBrowserTest, |
| DISABLED_CacheSharedOnDifferentPage) { |
| GURL url_1 = |
| embedded_test_server()->GetURL("example.com", "/inline-script.html"); |
| GURL url_2 = |
| embedded_test_server()->GetURL("example.com", "/same-inline-script.html"); |
| |
| // Step 1: Load the page first time. No cache is used. |
| { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url_1)); |
| FetchHistogramsFromChildProcesses(); |
| histogram_tester.ExpectBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kNoCacheBecauseInlineScriptCacheTooCold"), 1); |
| } |
| |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| |
| // Step 2: Reload the page. The script will be compiled from source and then |
| // producing the cache to store it on persistent storage. |
| { |
| bool produced = false; |
| for (int i = 0; i < 5; i++) { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url_1)); |
| FetchHistogramsFromChildProcesses(); |
| if (GetProduceCacheCount(histogram_tester) == 1) { |
| produced = true; |
| break; |
| } |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| EXPECT_TRUE(produced) << "Failed to produce cache"; |
| } |
| |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| |
| // Step 3: Load the different URL with the same NIK and the same inline |
| // script. The script will be compiled from code cache. |
| { |
| bool consumed = false; |
| for (int i = 0; i < 5; i++) { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url_2)); |
| FetchHistogramsFromChildProcesses(); |
| if (GetConsumeCacheCount(histogram_tester) == 1) { |
| consumed = true; |
| break; |
| } |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| EXPECT_TRUE(consumed) << "Failed to consume cache"; |
| } |
| } |
| |
| #if BUILDFLAG(IS_LINUX) && defined(MEMORY_SANITIZER) |
| // TODO(https://crbug.com/498800334): Flaky. |
| #define MAYBE_NotProducedForShortScript DISABLED_NotProducedForShortScript |
| #else |
| #define MAYBE_NotProducedForShortScript NotProducedForShortScript |
| #endif |
| IN_PROC_BROWSER_TEST_P(InlineScriptCodeCacheBrowserTest, |
| MAYBE_NotProducedForShortScript) { |
| // Even after multiple page loads, the code cache should not be produced for |
| // short scripts. |
| const int num_tries = 3; |
| base::HistogramTester histogram_tester; |
| for (int i = 0; i < num_tries; i++) { |
| // Use different query parameters so that BFCache would not work. |
| GURL url = embedded_test_server()->GetURL( |
| "example.com", base::StrCat({"/short-inline-script.html?i=", |
| base::NumberToString(i)})); |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| FetchHistogramsFromChildProcesses(); |
| histogram_tester.ExpectBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kNoCacheBecauseScriptTooSmall"), num_tries); |
| } |
| |
| // TODO(crbug.com/498265776): Test is failing on ChromeOS and Linux MSan. |
| // TODO(crbug.com/499371224): Disabled everywhere for flakiness. |
| IN_PROC_BROWSER_TEST_P(InlineScriptCodeCacheBrowserTest, |
| DISABLED_IsolatedByNik) { |
| GURL top_domain_a = |
| embedded_test_server()->GetURL("a.example", "/empty.html"); |
| GURL iframe_domain_b = |
| embedded_test_server()->GetURL("b.example", "/inline-script.html"); |
| GURL top_domain_c = |
| embedded_test_server()->GetURL("c.example", "/empty.html"); |
| |
| // Step 1: Load top_domain_a and embed iframe_domain_b. Cache is cold. |
| { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), top_domain_a)); |
| LoadIframe(iframe_domain_b); |
| FetchHistogramsFromChildProcesses(); |
| histogram_tester.ExpectBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kNoCacheBecauseInlineScriptCacheTooCold"), 1); |
| } |
| |
| PurgeResourceCacheFromTheMainFrame(); |
| PurgeResourceCacheFromTheFirstSubFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| |
| // Step 2: Reload the same setup (top A, iframe B). Cache should be produced |
| // or it could hit the Isolate cache if the process is reused. |
| { |
| bool produced = false; |
| for (int i = 0; i < 5; i++) { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), top_domain_a)); |
| LoadIframe(iframe_domain_b); |
| FetchHistogramsFromChildProcesses(); |
| if (GetProduceCacheCount(histogram_tester) == 1) { |
| produced = true; |
| break; |
| } |
| PurgeResourceCacheFromTheMainFrame(); |
| PurgeResourceCacheFromTheFirstSubFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| EXPECT_TRUE(produced) << "Failed to produce cache"; |
| } |
| |
| PurgeResourceCacheFromTheMainFrame(); |
| PurgeResourceCacheFromTheFirstSubFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| |
| // Step 3: Load top_domain_c and embed iframe_domain_b. |
| // Since NIK splits cache, there should be no inline script cache created by |
| // domain A while it could hit the Isolate cache if the process is reused. |
| { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), top_domain_c)); |
| LoadIframe(iframe_domain_b); |
| FetchHistogramsFromChildProcesses(); |
| |
| int no_cache_count = |
| histogram_tester.GetBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt( |
| "kNoCacheBecauseInlineScriptCacheTooCold")) + |
| histogram_tester.GetBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kHitIsolateCacheWhenNoCache")); |
| EXPECT_EQ(no_cache_count, 1); |
| } |
| } |
| |
| // TODO(crbug.com/498265776): Test timed out on some slow builders like MSan, |
| // TSan, and Win 10 (dbg). |
| #if defined(MEMORY_SANITIZER) || defined(THREAD_SANITIZER) || \ |
| (BUILDFLAG(IS_WIN) && !defined(NDEBUG)) |
| #define MAYBE_ProducedCacheHitsOnAnotherProcess \ |
| DISABLED_ProducedCacheHitsOnAnotherProcess |
| #else |
| #define MAYBE_ProducedCacheHitsOnAnotherProcess \ |
| ProducedCacheHitsOnAnotherProcess |
| #endif |
| IN_PROC_BROWSER_TEST_P(InlineScriptCodeCacheBrowserTest, |
| MAYBE_ProducedCacheHitsOnAnotherProcess) { |
| GURL url = embedded_test_server()->GetURL("a.example", "/inline-script.html"); |
| |
| // Step 1: Load the page first time. |
| { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| FetchHistogramsFromChildProcesses(); |
| histogram_tester.ExpectBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kNoCacheBecauseInlineScriptCacheTooCold"), 1); |
| } |
| |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| |
| // Step 2: Reload the page to produce the cache. |
| { |
| bool produced = false; |
| for (int i = 0; i < 5; i++) { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| FetchHistogramsFromChildProcesses(); |
| if (GetProduceCacheCount(histogram_tester) == 1) { |
| produced = true; |
| break; |
| } |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| EXPECT_TRUE(produced) << "Failed to produce cache"; |
| } |
| |
| // Step 3: Try recreating the window to ensure the next load happens in a |
| // new renderer process. If fail, skip the step 4. |
| // TODO(crbug.com/512201557): Make sure to use another process or to clear |
| // every in-memory cache of the process for test reliability. |
| const ChildProcessId process_id_before_recreate = |
| shell()->web_contents()->GetPrimaryMainFrame()->GetProcess()->GetID(); |
| RecreateWindow(); |
| const ChildProcessId process_id_after_recreate = |
| shell()->web_contents()->GetPrimaryMainFrame()->GetProcess()->GetID(); |
| |
| if (process_id_before_recreate != process_id_after_recreate) { |
| // Step 4: Load the page again. Since it's a new process, it cannot hit the |
| // in-memory Isolate cache. It must strictly hit the persistent code cache. |
| bool consumed = false; |
| for (int i = 0; i < 5; i++) { |
| base::HistogramTester histogram_tester; |
| ASSERT_TRUE(NavigateToURL(shell(), url)); |
| FetchHistogramsFromChildProcesses(); |
| const int persistent_consume_count = histogram_tester.GetBucketCount( |
| "V8.CompileScript.CacheBehaviour", |
| CacheBehaviourNameToInt("kConsumeCodeCache")); |
| if (persistent_consume_count == 1) { |
| consumed = true; |
| break; |
| } |
| PurgeResourceCacheFromTheMainFrame(); |
| ASSERT_TRUE(NavigateToURL(shell(), GURL("about:blank"))); |
| } |
| EXPECT_TRUE(consumed) << "Failed to consume persistent code cache " |
| "(kConsumeCodeCache) in the new process."; |
| } |
| } |
| |
| } // namespace content |
| #endif // !BUILDFLAG(IS_FUCHSIA) |
