| // Copyright 2023 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <stddef.h> |
| |
| #include "base/run_loop.h" |
| #include "base/scoped_observation.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/test/simple_test_tick_clock.h" |
| #include "base/test/task_environment.h" |
| #include "base/test/test_future.h" |
| #include "chrome/browser/extensions/api/permissions/permissions_api.h" |
| #include "chrome/browser/extensions/extension_apitest.h" |
| #include "chrome/browser/extensions/extension_management_test_util.h" |
| #include "chrome/browser/extensions/extension_service.h" |
| #include "chrome/browser/extensions/extension_tab_util.h" |
| #include "chrome/browser/ui/browser_window.h" |
| #include "chrome/browser/ui/test/test_browser_closed_waiter.h" |
| #include "chrome/common/chrome_features.h" |
| #include "chrome/test/base/profile_destruction_waiter.h" |
| #include "content/public/browser/service_worker_context.h" |
| #include "content/public/browser/service_worker_context_observer.h" |
| #include "content/public/test/browser_test.h" |
| #include "content/public/test/service_worker_test_helpers.h" |
| #include "extensions/browser/api/test/test_api.h" |
| #include "extensions/browser/background_script_executor.h" |
| #include "extensions/browser/browsertest_util.h" |
| #include "extensions/browser/extension_prefs.h" |
| #include "extensions/browser/extensions_browser_client.h" |
| #include "extensions/browser/service_worker/service_worker_keepalive.h" |
| #include "extensions/browser/service_worker/service_worker_test_utils.h" |
| #include "extensions/common/extension.h" |
| #include "extensions/test/extension_test_message_listener.h" |
| #include "extensions/test/result_catcher.h" |
| #include "extensions/test/test_extension_dir.h" |
| #include "net/dns/mock_host_resolver.h" |
| #include "url/gurl.h" |
| |
| namespace extensions { |
| |
| namespace { |
| |
| constexpr char kTestOpenerExtensionId[] = "adpghjkjicpfhcjicmiifjpbalaildpo"; |
| constexpr char kTestOpenerExtensionUrl[] = |
| "chrome-extension://adpghjkjicpfhcjicmiifjpbalaildpo/"; |
| constexpr char kTestOpenerExtensionRelativePath[] = |
| "service_worker/policy/opener_extension"; |
| |
| constexpr char kTestReceiverExtensionId[] = "eagjmgdicfmccfhiiihnaehbfheheidk"; |
| constexpr char kTestReceiverExtensionUrl[] = |
| "chrome-extension://eagjmgdicfmccfhiiihnaehbfheheidk/"; |
| constexpr char kTestReceiverExtensionRelativePath[] = |
| "service_worker/policy/receiver_extension"; |
| |
| constexpr char kPersistentPortConnectedMessage[] = "Persistent port connected"; |
| constexpr char kPersistentPortDisconnectedMessage[] = |
| "Persistent port disconnected"; |
| |
| // Gets a keepalive matcher that enforces the extra data field. |
| testing::Matcher<ProcessManager::ServiceWorkerKeepaliveData> |
| GetKeepaliveMatcher(const WorkerId& worker_id, |
| Activity::Type type, |
| const std::string& activity_extra_data) { |
| return testing::AllOf( |
| testing::Field("worker_id", |
| &ProcessManager::ServiceWorkerKeepaliveData::worker_id, |
| worker_id), |
| testing::Field("activity_type", |
| &ProcessManager::ServiceWorkerKeepaliveData::activity_type, |
| type), |
| testing::Field("extra_data", |
| &ProcessManager::ServiceWorkerKeepaliveData::extra_data, |
| activity_extra_data)); |
| } |
| |
| // Gets a keepalive matcher enforcing only the worker ID and activity type. |
| testing::Matcher<ProcessManager::ServiceWorkerKeepaliveData> |
| GetKeepaliveMatcher(const WorkerId& worker_id, Activity::Type type) { |
| return testing::AllOf( |
| testing::Field("worker_id", |
| &ProcessManager::ServiceWorkerKeepaliveData::worker_id, |
| worker_id), |
| testing::Field("activity_type", |
| &ProcessManager::ServiceWorkerKeepaliveData::activity_type, |
| type)); |
| } |
| |
| // Returns the number of active external requests to the service worker of |
| // the specified `extension` in the given `context`. |
| size_t GetExternalRequestCountForWorker(content::BrowserContext& context, |
| const Extension& extension) { |
| const blink::StorageKey extension_key = |
| blink::StorageKey::CreateFirstParty(extension.origin()); |
| return service_worker_test_utils::GetServiceWorkerContext(&context) |
| ->CountExternalRequestsForTest(extension_key); |
| } |
| |
| } // namespace |
| |
| using service_worker_test_utils::TestServiceWorkerContextObserver; |
| |
| class ServiceWorkerLifetimeKeepaliveBrowsertest : public ExtensionApiTest { |
| public: |
| ServiceWorkerLifetimeKeepaliveBrowsertest() { |
| // TODO(crbug.com/40937027): Convert test to use HTTPS and then re-enable. |
| feature_list_.InitAndDisableFeature(features::kHttpsFirstModeIncognito); |
| } |
| |
| ServiceWorkerLifetimeKeepaliveBrowsertest( |
| const ServiceWorkerLifetimeKeepaliveBrowsertest&) = delete; |
| ServiceWorkerLifetimeKeepaliveBrowsertest& operator=( |
| const ServiceWorkerLifetimeKeepaliveBrowsertest&) = delete; |
| |
| ~ServiceWorkerLifetimeKeepaliveBrowsertest() override = default; |
| |
| void SetUpOnMainThread() override { |
| ExtensionApiTest::SetUpOnMainThread(); |
| host_resolver()->AddRule("*", "127.0.0.1"); |
| ASSERT_TRUE(StartEmbeddedTestServer()); |
| } |
| |
| void TearDownOnMainThread() override { |
| ExtensionApiTest::TearDownOnMainThread(); |
| // Some tests use SetTickClockForTesting() with `tick_clock_opener_` or |
| // `tick_clock_receiver_`. Restore the TickClock to the default now. |
| // This is required because the TickClock must outlive ServiceWorkerVersion, |
| // otherwise ServiceWorkerVersion will hold a dangling pointer. |
| content::ResetTickClockToDefaultForAllLiveServiceWorkerVersions( |
| GetServiceWorkerContext()); |
| } |
| |
| void TriggerTimeoutAndCheckActive(content::ServiceWorkerContext* context, |
| int64_t version_id) { |
| EXPECT_TRUE( |
| content::TriggerTimeoutAndCheckRunningState(context, version_id)); |
| } |
| |
| void TriggerTimeoutAndCheckStopped(content::ServiceWorkerContext* context, |
| int64_t version_id) { |
| EXPECT_FALSE( |
| content::TriggerTimeoutAndCheckRunningState(context, version_id)); |
| } |
| |
| base::SimpleTestTickClock tick_clock_opener_; |
| base::SimpleTestTickClock tick_clock_receiver_; |
| |
| private: |
| base::test::ScopedFeatureList feature_list_; |
| }; |
| |
| // Loads two extensions that open a persistent port connection between each |
| // other and tests that their service worker will stop after kRequestTimeout (5 |
| // minutes). |
| IN_PROC_BROWSER_TEST_F(ServiceWorkerLifetimeKeepaliveBrowsertest, |
| ServiceWorkersTimeOutWithoutPolicy) { |
| content::ServiceWorkerContext* context = GetServiceWorkerContext(); |
| |
| TestServiceWorkerContextObserver sw_observer_receiver_extension( |
| context, kTestReceiverExtensionId); |
| LoadExtension(test_data_dir_.AppendASCII(kTestReceiverExtensionRelativePath)); |
| const int64_t service_worker_receiver_id = |
| sw_observer_receiver_extension.WaitForWorkerStarted(); |
| |
| ExtensionTestMessageListener connect_listener( |
| kPersistentPortConnectedMessage); |
| connect_listener.set_extension_id(kTestReceiverExtensionId); |
| |
| TestServiceWorkerContextObserver sw_observer_opener_extension( |
| context, kTestOpenerExtensionId); |
| LoadExtension(test_data_dir_.AppendASCII(kTestOpenerExtensionRelativePath)); |
| const int64_t service_worker_opener_id = |
| sw_observer_opener_extension.WaitForWorkerStarted(); |
| |
| ASSERT_TRUE(connect_listener.WaitUntilSatisfied()); |
| |
| // Advance clock and check that the receiver service worker stopped. |
| content::AdvanceClockAfterRequestTimeout(context, service_worker_receiver_id, |
| &tick_clock_receiver_); |
| TriggerTimeoutAndCheckStopped(context, service_worker_receiver_id); |
| sw_observer_receiver_extension.WaitForWorkerStopped(); |
| |
| // Advance clock and check that the opener service worker stopped. |
| content::AdvanceClockAfterRequestTimeout(context, service_worker_opener_id, |
| &tick_clock_opener_); |
| TriggerTimeoutAndCheckStopped(context, service_worker_opener_id); |
| sw_observer_opener_extension.WaitForWorkerStopped(); |
| } |
| |
| // Tests that the service workers will not stop if both extensions are |
| // allowlisted via policy and the port is not closed. |
| IN_PROC_BROWSER_TEST_F(ServiceWorkerLifetimeKeepaliveBrowsertest, |
| ServiceWorkersDoNotTimeOutWithPolicy) { |
| base::Value::List urls; |
| // Both extensions receive extended lifetime. |
| urls.Append(kTestOpenerExtensionUrl); |
| urls.Append(kTestReceiverExtensionUrl); |
| profile()->GetPrefs()->SetList( |
| pref_names::kExtendedBackgroundLifetimeForPortConnectionsToUrls, |
| std::move(urls)); |
| |
| content::ServiceWorkerContext* context = GetServiceWorkerContext(); |
| |
| // Load the extensions and wait for the service workers to be activated. This |
| // test advances the worker's clock. If the activation request is in-flight |
| // when the clock is advanced, the request will expire and the worker will be |
| // terminated (because activation requests have KILL_ON_TIMEOUT behavior). |
| // Thus, we ensure that there are no in-flight activation requests before |
| // advancing the clock. |
| TestServiceWorkerContextObserver sw_observer_receiver_extension( |
| context, kTestReceiverExtensionId); |
| LoadExtension(test_data_dir_.AppendASCII(kTestReceiverExtensionRelativePath)); |
| const int64_t service_worker_receiver_id = |
| sw_observer_receiver_extension.WaitForWorkerActivated(); |
| |
| ExtensionTestMessageListener connect_listener( |
| kPersistentPortConnectedMessage); |
| connect_listener.set_extension_id(kTestReceiverExtensionId); |
| |
| TestServiceWorkerContextObserver sw_observer_opener_extension( |
| context, kTestOpenerExtensionId); |
| LoadExtension(test_data_dir_.AppendASCII(kTestOpenerExtensionRelativePath)); |
| const int64_t service_worker_opener_id = |
| sw_observer_opener_extension.WaitForWorkerActivated(); |
| |
| ASSERT_TRUE(connect_listener.WaitUntilSatisfied()); |
| |
| // Advance clock and check that the receiver service worker did not stop. |
| content::AdvanceClockAfterRequestTimeout(context, service_worker_receiver_id, |
| &tick_clock_receiver_); |
| TriggerTimeoutAndCheckActive(context, service_worker_receiver_id); |
| |
| // Advance clock and check that the opener service worker did not stop. |
| content::AdvanceClockAfterRequestTimeout(context, service_worker_opener_id, |
| &tick_clock_opener_); |
| TriggerTimeoutAndCheckActive(context, service_worker_opener_id); |
| } |
| |
| // Tests that the extended lifetime only lasts as long as there is a persistent |
| // port connection. If the port is closed (by one of the service workers |
| // stopping), the other service worker will also stop, even if it received an |
| // extended lifetime. |
| IN_PROC_BROWSER_TEST_F(ServiceWorkerLifetimeKeepaliveBrowsertest, |
| ServiceWorkersTimeOutWhenOnlyOneHasExtendedLifetime) { |
| base::Value::List urls; |
| // Opener extension will receive extended lifetime because it connects to a |
| // policy allowlisted extension. |
| urls.Append(kTestReceiverExtensionUrl); |
| profile()->GetPrefs()->SetList( |
| pref_names::kExtendedBackgroundLifetimeForPortConnectionsToUrls, |
| std::move(urls)); |
| |
| content::ServiceWorkerContext* context = GetServiceWorkerContext(); |
| |
| TestServiceWorkerContextObserver sw_observer_receiver_extension( |
| context, kTestReceiverExtensionId); |
| LoadExtension(test_data_dir_.AppendASCII(kTestReceiverExtensionRelativePath)); |
| const int64_t service_worker_receiver_id = |
| sw_observer_receiver_extension.WaitForWorkerStarted(); |
| |
| ExtensionTestMessageListener connect_listener( |
| kPersistentPortConnectedMessage); |
| connect_listener.set_extension_id(kTestReceiverExtensionId); |
| |
| TestServiceWorkerContextObserver sw_observer_opener_extension( |
| context, kTestOpenerExtensionId); |
| LoadExtension(test_data_dir_.AppendASCII(kTestOpenerExtensionRelativePath)); |
| const int64_t service_worker_opener_id = |
| sw_observer_opener_extension.WaitForWorkerStarted(); |
| |
| ASSERT_TRUE(connect_listener.WaitUntilSatisfied()); |
| |
| ExtensionTestMessageListener disconnect_listener( |
| kPersistentPortDisconnectedMessage); |
| disconnect_listener.set_extension_id(kTestOpenerExtensionId); |
| |
| // Advance clock and check that the receiver service worker stopped. |
| content::AdvanceClockAfterRequestTimeout(context, service_worker_receiver_id, |
| &tick_clock_receiver_); |
| TriggerTimeoutAndCheckStopped(context, service_worker_receiver_id); |
| |
| // Wait for the receiver SW to be closed in order for the port to be |
| // disconnected and the opener SW losing extended lifetime. |
| sw_observer_receiver_extension.WaitForWorkerStopped(); |
| |
| // Wait for port to close in the opener extension. |
| ASSERT_TRUE(disconnect_listener.WaitUntilSatisfied()); |
| |
| // Advance clock and check that the opener service worker stopped. |
| content::AdvanceClockAfterRequestTimeout(context, service_worker_opener_id, |
| &tick_clock_opener_); |
| TriggerTimeoutAndCheckStopped(context, service_worker_opener_id); |
| sw_observer_opener_extension.WaitForWorkerStopped(); |
| } |
| |
| // Tests that the service workers will stop if both extensions are allowlisted |
| // via policy and the port is disconnected. |
| IN_PROC_BROWSER_TEST_F(ServiceWorkerLifetimeKeepaliveBrowsertest, |
| ServiceWorkersTimeOutWhenPortIsDisconnected) { |
| base::Value::List urls; |
| // Both extensions receive extended lifetime. |
| urls.Append(kTestReceiverExtensionUrl); |
| urls.Append(kTestOpenerExtensionUrl); |
| profile()->GetPrefs()->SetList( |
| pref_names::kExtendedBackgroundLifetimeForPortConnectionsToUrls, |
| std::move(urls)); |
| |
| content::ServiceWorkerContext* context = GetServiceWorkerContext(); |
| |
| TestServiceWorkerContextObserver sw_observer_receiver_extension( |
| context, kTestReceiverExtensionId); |
| LoadExtension(test_data_dir_.AppendASCII(kTestReceiverExtensionRelativePath)); |
| const int64_t service_worker_receiver_id = |
| sw_observer_receiver_extension.WaitForWorkerStarted(); |
| |
| ExtensionTestMessageListener connect_listener( |
| kPersistentPortConnectedMessage); |
| connect_listener.set_extension_id(kTestReceiverExtensionId); |
| |
| TestServiceWorkerContextObserver sw_observer_opener_extension( |
| context, kTestOpenerExtensionId); |
| LoadExtension(test_data_dir_.AppendASCII(kTestOpenerExtensionRelativePath)); |
| const int64_t service_worker_opener_id = |
| sw_observer_opener_extension.WaitForWorkerStarted(); |
| |
| ASSERT_TRUE(connect_listener.WaitUntilSatisfied()); |
| |
| ExtensionTestMessageListener disconnect_listener( |
| kPersistentPortDisconnectedMessage); |
| disconnect_listener.set_extension_id(kTestOpenerExtensionId); |
| |
| // Disconnect the port from the receiver extension. |
| constexpr char kDisconnectScript[] = R"(port.disconnect();)"; |
| BackgroundScriptExecutor script_executor(profile()); |
| script_executor.ExecuteScriptAsync( |
| kTestReceiverExtensionId, kDisconnectScript, |
| BackgroundScriptExecutor::ResultCapture::kNone, |
| browsertest_util::ScriptUserActivation::kDontActivate); |
| |
| // Wait for port to close in the opener extension. |
| ASSERT_TRUE(disconnect_listener.WaitUntilSatisfied()); |
| |
| // Advance clock and check that the receiver service worker stopped. |
| content::AdvanceClockAfterRequestTimeout(context, service_worker_receiver_id, |
| &tick_clock_receiver_); |
| TriggerTimeoutAndCheckStopped(context, service_worker_receiver_id); |
| |
| // Wait for the receiver SW to be closed. |
| sw_observer_receiver_extension.WaitForWorkerStopped(); |
| |
| // Advance clock and check that the opener service worker stopped. |
| content::AdvanceClockAfterRequestTimeout(context, service_worker_opener_id, |
| &tick_clock_opener_); |
| TriggerTimeoutAndCheckStopped(context, service_worker_opener_id); |
| sw_observer_opener_extension.WaitForWorkerStopped(); |
| } |
| |
| // Tests that certain API functions can keep the service worker alive |
| // indefinitely. |
| IN_PROC_BROWSER_TEST_F(ServiceWorkerLifetimeKeepaliveBrowsertest, |
| KeepalivesForCertainExtensionFunctions) { |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "test extension", |
| "manifest_version": 3, |
| "background": {"service_worker": "background.js"}, |
| "version": "0.1", |
| "optional_permissions": ["tabs"] |
| })"; |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), "// blank"); |
| |
| // Load up the extension and wait for the worker to start. |
| TestServiceWorkerContextObserver registration_observer(profile()); |
| const Extension* extension = LoadExtension(test_dir.UnpackedPath()); |
| // We explicitly wait for the worker to be activated. Otherwise, the |
| // activation event might still be running when we advance the timer, causing |
| // the worker to be killed for the activation event timing out. |
| int64_t version_id = registration_observer.WaitForWorkerActivated(); |
| |
| // Inject a script that will trigger chrome.permissions.request() and then |
| // return. When permissions.request() resolves, it will send a message. |
| static constexpr char kTriggerPrompt[] = |
| R"(chrome.test.runWithUserGesture(() => { |
| chrome.permissions.request({permissions: ['tabs']}).then(() => { |
| chrome.test.sendMessage('resolved'); |
| }); |
| chrome.test.sendScriptResult('success'); |
| });)"; |
| |
| // Programmatically control the permissions request result. This allows us |
| // to control when it is resolved. |
| auto dialog_action_reset = |
| PermissionsRequestFunction::SetDialogActionForTests( |
| PermissionsRequestFunction::DialogAction::kProgrammatic); |
| |
| base::Value result = BackgroundScriptExecutor::ExecuteScript( |
| profile(), extension->id(), kTriggerPrompt, |
| BackgroundScriptExecutor::ResultCapture::kSendScriptResult); |
| EXPECT_EQ("success", result); |
| |
| content::ServiceWorkerContext* context = GetServiceWorkerContext(); |
| |
| // Right now, the permissions request should be pending. Since |
| // `permissions.request()` is specified as a function that can keep the |
| // extension worker alive indefinitely, advancing the clock and triggering the |
| // timeout should not result in a worker kill. |
| content::AdvanceClockAfterRequestTimeout(context, version_id, |
| &tick_clock_opener_); |
| TriggerTimeoutAndCheckActive(context, version_id); |
| |
| { |
| ExtensionTestMessageListener listener("resolved"); |
| // Resolve the pending dialog and wait for the resulting message. |
| PermissionsRequestFunction::ResolvePendingDialogForTests(false); |
| ASSERT_TRUE(listener.WaitUntilSatisfied()); |
| // We also run a run loop here so that the keepalive from the |
| // test.sendMessage() call is resolved. |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| // Advance the timer again. This should result in the worker being stopped, |
| // since the permissions.request() function call is now completed. |
| content::AdvanceClockAfterRequestTimeout(context, version_id, |
| &tick_clock_opener_); |
| TriggerTimeoutAndCheckStopped(context, version_id); |
| } |
| |
| // Test the flow of an extension function resolving after an extension service |
| // worker has timed out and been terminated. |
| // Regression test for https://crbug.com/1453534. |
| IN_PROC_BROWSER_TEST_F(ServiceWorkerLifetimeKeepaliveBrowsertest, |
| ExtensionFunctionGetsResolvedAfterWorkerTermination) { |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "test extension", |
| "manifest_version": 3, |
| "background": {"service_worker": "background.js"}, |
| "version": "0.1" |
| })"; |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), "// blank"); |
| |
| // Load up the extension and wait for the worker to start. |
| TestServiceWorkerContextObserver registration_observer(profile()); |
| const Extension* extension = LoadExtension(test_dir.UnpackedPath()); |
| // We explicitly wait for the worker to be activated. Otherwise, the |
| // activation event might still be running when we advance the timer, causing |
| // the worker to be killed for the activation event timing out. |
| int64_t version_id = registration_observer.WaitForWorkerActivated(); |
| |
| // Inject a trivial script that will call test.sendMessage(). This is a handy |
| // API because, by indicating the test will reply, we control when the |
| // function is resolved. |
| static constexpr char kScript[] = |
| "chrome.test.sendMessage('hello', () => {});"; |
| ExtensionTestMessageListener message_listener("hello", |
| ReplyBehavior::kWillReply); |
| BackgroundScriptExecutor::ExecuteScriptAsync(profile(), extension->id(), |
| kScript); |
| |
| ASSERT_TRUE(message_listener.WaitUntilSatisfied()); |
| |
| content::ServiceWorkerContext* context = GetServiceWorkerContext(); |
| TestServiceWorkerContextObserver context_observer(context, extension->id()); |
| context_observer.SetRunningId(version_id); |
| |
| // Advance the request past the timeout. Since test.sendMessage() doesn't |
| // keep a worker alive indefinitely, the service worker should be terminated. |
| content::AdvanceClockAfterRequestTimeout(context, version_id, |
| &tick_clock_opener_); |
| TriggerTimeoutAndCheckStopped(context, version_id); |
| // Wait for the worker to fully stop. |
| context_observer.WaitForWorkerStopped(); |
| |
| // Reply to the extension (even though the worker is gone). This triggers |
| // the completion of the extension function, which would otherwise try to |
| // decrement the keepalive count of the worker. The worker was already |
| // terminated; it should gracefully handle this case (as opposed to crash). |
| message_listener.Reply("foo"); |
| } |
| |
| // Tests that an active debugger session will keep an extension service worker |
| // alive past its typical timeout. |
| IN_PROC_BROWSER_TEST_F(ServiceWorkerLifetimeKeepaliveBrowsertest, |
| DebuggerAttachKeepsServiceWorkerAlive) { |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "Debugger attach", |
| "manifest_version": 3, |
| "version": "0.1", |
| "permissions": ["debugger"], |
| "background": { |
| "service_worker": "background.js" |
| } |
| })"; |
| // A simple background script that knows how to attach and detach a debugging |
| // session from a target (active) tab. |
| static constexpr char kBackgroundJs[] = |
| R"(let attachedTab; |
| async function attachToActiveTab() { |
| let tabs = |
| await chrome.tabs.query({active: true, currentWindow: true}); |
| let tab = tabs[0]; |
| await chrome.debugger.attach({tabId: tab.id}, '1.3'); |
| attachedTab = tab; |
| chrome.test.sendScriptResult('attached'); |
| } |
| |
| async function detach() { |
| await chrome.debugger.detach({tabId: attachedTab.id}); |
| chrome.test.sendScriptResult('detached'); |
| })"; |
| |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundJs); |
| |
| // Load up the extension and wait for the worker to start. |
| TestServiceWorkerContextObserver registration_observer(profile()); |
| const Extension* extension = LoadExtension(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| // We explicitly wait for the worker to be activated. Otherwise, the |
| // activation event might still be running when we advance the timer, causing |
| // the worker to be killed for the activation event timing out. |
| int64_t version_id = registration_observer.WaitForWorkerActivated(); |
| |
| // Open a new tab for the extension to attach a debugger to. |
| const GURL example_com = |
| embedded_test_server()->GetURL("example.com", "/simple.html"); |
| auto* web_contents = GetActiveWebContents(); |
| ASSERT_TRUE(NavigateToURL(web_contents, example_com)); |
| EXPECT_EQ(example_com, web_contents->GetLastCommittedURL()); |
| |
| // Attach the extension debugger. |
| EXPECT_EQ("attached", |
| BackgroundScriptExecutor::ExecuteScript( |
| profile(), extension->id(), "attachToActiveTab();", |
| BackgroundScriptExecutor::ResultCapture::kSendScriptResult)); |
| // Ensure the keepalive associated with sendScriptResult() has resolved. |
| base::RunLoop().RunUntilIdle(); |
| |
| content::ServiceWorkerContext* context = GetServiceWorkerContext(); |
| |
| // Since the extension has an active debugger session, it should not be |
| // terminated, even for going past the typical time limit. |
| content::AdvanceClockAfterRequestTimeout(context, version_id, |
| &tick_clock_opener_); |
| TriggerTimeoutAndCheckActive(context, version_id); |
| |
| // Have the extension detach its debugging session. |
| EXPECT_EQ("detached", |
| BackgroundScriptExecutor::ExecuteScript( |
| profile(), extension->id(), "detach();", |
| BackgroundScriptExecutor::ResultCapture::kSendScriptResult)); |
| // Ensure the keepalive associated with sendScriptResult() has resolved. |
| base::RunLoop().RunUntilIdle(); |
| |
| // The extension service worker should now be terminated, since it no longer |
| // has an active debug session. |
| content::AdvanceClockAfterRequestTimeout(context, version_id, |
| &tick_clock_opener_); |
| TriggerTimeoutAndCheckStopped(context, version_id); |
| } |
| |
| // Tests the behavior of the ServiceWorkerKeepalive struct, ensuring it properly |
| // keeps the service worker alive. |
| IN_PROC_BROWSER_TEST_F(ServiceWorkerLifetimeKeepaliveBrowsertest, |
| ServiceWorkerKeepaliveUtility) { |
| // Load up a simple extension and grab its service worker data. |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "Test", |
| "version": "0.1", |
| "manifest_version": 3, |
| "background": {"service_worker": "background.js"} |
| })"; |
| static constexpr char kBackground[] = R"(chrome.test.sendMessage('ready');)"; |
| |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), kBackground); |
| |
| ExtensionTestMessageListener ready_listener("ready"); |
| const Extension* extension = LoadExtension(test_dir.UnpackedPath()); |
| ASSERT_TRUE(extension); |
| ASSERT_TRUE(ready_listener.WaitUntilSatisfied()); |
| // Note: We RunUntilIdle() to ensure the implementation handling of the |
| // test.sendMessage() API call has finished; otherwise, that affects our |
| // keepalives. |
| base::RunLoop().RunUntilIdle(); |
| |
| ProcessManager* process_manager = ProcessManager::Get(profile()); |
| |
| std::vector<WorkerId> worker_ids = |
| process_manager->GetServiceWorkersForExtension(extension->id()); |
| ASSERT_EQ(1u, worker_ids.size()); |
| WorkerId worker_id = worker_ids[0]; |
| |
| // To begin, there should be no associated keepalives for the extension. |
| EXPECT_EQ(0u, process_manager |
| ->GetServiceWorkerKeepaliveDataForRecords(extension->id()) |
| .size()); |
| |
| // Create a single keepalive. |
| std::optional<ServiceWorkerKeepalive> function_keepalive( |
| ServiceWorkerKeepalive( |
| profile(), worker_id, |
| content::ServiceWorkerExternalRequestTimeoutType::kDefault, |
| Activity::API_FUNCTION, "alarms.create")); |
| |
| // There should be one keepalive for the extension. |
| EXPECT_THAT( |
| process_manager->GetServiceWorkerKeepaliveDataForRecords(extension->id()), |
| testing::UnorderedElementsAre(GetKeepaliveMatcher( |
| worker_id, Activity::API_FUNCTION, "alarms.create"))); |
| |
| // Create a second keepalive (an event-related one). |
| std::optional<ServiceWorkerKeepalive> event_keepalive(ServiceWorkerKeepalive( |
| profile(), worker_id, |
| content::ServiceWorkerExternalRequestTimeoutType::kDefault, |
| Activity::EVENT, "alarms.onAlarm")); |
| |
| // Now, there should be two keepalives. |
| EXPECT_THAT( |
| process_manager->GetServiceWorkerKeepaliveDataForRecords(extension->id()), |
| testing::UnorderedElementsAre( |
| GetKeepaliveMatcher(worker_id, Activity::API_FUNCTION, |
| "alarms.create"), |
| GetKeepaliveMatcher(worker_id, Activity::EVENT, "alarms.onAlarm"))); |
| |
| // Reset the first. There should now be only the second keepalive. |
| function_keepalive.reset(); |
| EXPECT_THAT( |
| process_manager->GetServiceWorkerKeepaliveDataForRecords(extension->id()), |
| testing::UnorderedElementsAre( |
| GetKeepaliveMatcher(worker_id, Activity::EVENT, "alarms.onAlarm"))); |
| |
| // Reset the second, and the keepalive count should go to zero. |
| event_keepalive.reset(); |
| EXPECT_EQ(0u, process_manager |
| ->GetServiceWorkerKeepaliveDataForRecords(extension->id()) |
| .size()); |
| } |
| |
| // Tests shutting down the associated browser context while the extension has |
| // an active keepalive from a message pipe behaves appropriately. |
| IN_PROC_BROWSER_TEST_F(ServiceWorkerLifetimeKeepaliveBrowsertest, |
| ShutdownWithActiveMessagePipe) { |
| // Load an extension with incognito split mode and a content script that |
| // runs on example.com. |
| // The split mode incognito is important so that we can fully shut down a |
| // browser context with separately-tracked keepalives. |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "Test", |
| "manifest_version": 3, |
| "version": "0.1", |
| "incognito": "split", |
| "background": {"service_worker": "background.js"}, |
| "content_scripts": [ |
| { |
| "js": ["content_script.js"], |
| "matches": ["*://example.com/*"], |
| "run_at": "document_end" |
| } |
| ] |
| })"; |
| static constexpr char kBackgroundJs[] = R"(// Intentionally blank.)"; |
| // The content script adds a listener for a new message and then |
| // (asynchronously) signals success. |
| // See keepalive comments below for why this is async. |
| // NOTE: We're careful not to have the port be garbage collected by storing |
| // it on `self`; otherwise this could close the message pipe. |
| static constexpr char kContentScriptJs[] = |
| R"(chrome.runtime.onMessage.addListener((msg, sender, reply) => { |
| self.reply = reply; |
| setTimeout(() => { chrome.test.sendScriptResult('success'); }, 0); |
| // Indicates async response, keeping the message pipe open. |
| return true; |
| }); |
| chrome.test.sendMessage('content script ready');)"; |
| |
| TestExtensionDir test_dir; |
| test_dir.WriteManifest(kManifest); |
| test_dir.WriteFile(FILE_PATH_LITERAL("background.js"), kBackgroundJs); |
| test_dir.WriteFile(FILE_PATH_LITERAL("content_script.js"), kContentScriptJs); |
| |
| const Extension* extension = |
| LoadExtension(test_dir.UnpackedPath(), {.allow_in_incognito = true}); |
| ASSERT_TRUE(extension); |
| |
| Profile* incognito_profile = |
| profile()->GetPrimaryOTRProfile(/*create_if_needed=*/true); |
| TestServiceWorkerContextObserver registration_observer(incognito_profile); |
| // Open example.com/simple.html in an incognito window. The content script |
| // will inject. |
| ExtensionTestMessageListener content_script_listener("content script ready"); |
| Browser* incognito_browser = OpenURLOffTheRecord( |
| profile(), embedded_test_server()->GetURL("example.com", "/simple.html")); |
| ASSERT_TRUE(content_script_listener.WaitUntilSatisfied()); |
| registration_observer.WaitForWorkerActivated(); |
| content::WebContents* incognito_tab = |
| incognito_browser->tab_strip_model()->GetActiveWebContents(); |
| int tab_id = ExtensionTabUtil::GetTabId(incognito_tab); |
| |
| // Send a message to the incognito tab from the incognito service worker. |
| // This will open a message pipe. Since the content script never responds, |
| // the message pipe will remain open. |
| static constexpr char kOpenMessagePipe[] = |
| R"((async () => { |
| // Note: Pass a callback to signal a reply is expected. |
| chrome.tabs.sendMessage(%d, 'hello', () => {}); |
| })();)"; |
| |
| base::Value script_result = BackgroundScriptExecutor::ExecuteScript( |
| incognito_profile, extension->id(), |
| base::StringPrintf(kOpenMessagePipe, tab_id), |
| BackgroundScriptExecutor::ResultCapture::kSendScriptResult); |
| EXPECT_EQ("success", script_result); |
| |
| ProcessManager* incognito_process_manager = |
| ProcessManager::Get(incognito_profile); |
| |
| // Grab the active worker for the incognito context. |
| std::vector<WorkerId> worker_ids = |
| incognito_process_manager->GetServiceWorkersForExtension(extension->id()); |
| ASSERT_EQ(1u, worker_ids.size()); |
| WorkerId worker_id = worker_ids[0]; |
| |
| // Verify the service worker currently has a keepalive for the message |
| // port. |
| // The keepalive flow is as follows: |
| // * Service worker opens a message pipe. New Activity::MESSAGE_PORT |
| // keepalive from the worker context. |
| // * Message pipe is opened in the tab. New Activity::MESSAGE_PORT |
| // keepalive from the tab context. |
| // * Message is sent to the tab. New Activity::MESSAGE keepalive from |
| // the tab context. |
| // * The message is ack'd from the tab. Activity::MESSAGE keepalive |
| // from the tab context is removed. Since we signal success in the |
| // tab asynchronously, the keepalive is guaranteed to have resolved. |
| // (Otherwise, it could potentially be racy). |
| // Thus, at the end, we have two remaining keepalives. |
| // TODO(crbug.com/41487026): Ideally, there would only be one -- we shouldn't |
| // add keepalives for the service worker due to a tab's message port. |
| |
| EXPECT_THAT( |
| incognito_process_manager->GetServiceWorkerKeepaliveDataForRecords( |
| extension->id()), |
| testing::UnorderedElementsAre( |
| GetKeepaliveMatcher(worker_id, Activity::MESSAGE_PORT), |
| GetKeepaliveMatcher(worker_id, Activity::MESSAGE_PORT))); |
| |
| // Close the incognito browser while the message channel is still open. Since |
| // this is the only browser window for the incognito context, this also |
| // results in the browser context being invalidated. |
| ProfileDestructionWaiter profile_destruction_waiter(incognito_profile); |
| TestBrowserClosedWaiter browser_closed_waiter(incognito_browser); |
| incognito_browser->window()->Close(); |
| ASSERT_TRUE(browser_closed_waiter.WaitUntilClosed()); |
| profile_destruction_waiter.Wait(); |
| // Note: `ProfileDestructionWaiter` only waits for the profile to signal it |
| // *will* be destroyed. Spin once to finish the job. |
| base::RunLoop().RunUntilIdle(); |
| // Verify the profile is destroyed. |
| EXPECT_FALSE( |
| ExtensionsBrowserClient::Get()->IsValidContext(incognito_profile)); |
| // The test succeeds if there are no crashes. There's nothing left to verify |
| // for keepalives, since the profile is gone. |
| } |
| |
| // Tests that we can safely shut down a BrowserContext when an extension has |
| // an active message port to another extension, where each are running in |
| // split incognito mode. |
| // Regression test for https://crbug.com/1476316. |
| IN_PROC_BROWSER_TEST_F(ServiceWorkerLifetimeKeepaliveBrowsertest, |
| ShutdownWithActiveMessagePipe_SplitModeExtension) { |
| // A split-mode extension. This will have a separate process for the on- and |
| // off-the-record profiles. |
| static constexpr char kManifest[] = |
| R"({ |
| "name": "Test", |
| "manifest_version": 3, |
| "version": "0.1", |
| "incognito": "split", |
| "background": {"service_worker": "background.js"} |
| })"; |
| // A background page that knows how to open a message pipe to another |
| // extension. |
| static constexpr char kOpenerBackgroundJs[] = |
| R"(async function openMessagePipe(listenerId) { |
| // Note: Pass a callback to signal a reply is expected. |
| chrome.runtime.sendMessage(listenerId, 'hello', () => {}); |
| })"; |
| // The listener extension will listen for an external message (from the |
| // opener mode extension). We save the `sendReply` callback so it's not |
| // garbage collected and keeps the message pipe open, and then asynchronously |
| // respond that the message was received. The asynchronous response is |
| // important in order to ensure the message being received from this |
| // extension is properly ack'd. |
| static constexpr char kListenerBackgroundJs[] = |
| R"(chrome.runtime.onMessageExternal.addListener( |
| (msg, sender, sendReply) => { |
| self.sendReply = sendReply; |
| setTimeout(() => { chrome.test.sendScriptResult('success'); }); |
| return true; |
| });)"; |
| |
| TestExtensionDir opener_extension_dir; |
| opener_extension_dir.WriteManifest(kManifest); |
| opener_extension_dir.WriteFile(FILE_PATH_LITERAL("background.js"), |
| kOpenerBackgroundJs); |
| |
| TestExtensionDir listener_extension_dir; |
| listener_extension_dir.WriteManifest(kManifest); |
| listener_extension_dir.WriteFile(FILE_PATH_LITERAL("background.js"), |
| kListenerBackgroundJs); |
| |
| const Extension* opener_extension = LoadExtension( |
| opener_extension_dir.UnpackedPath(), {.allow_in_incognito = true}); |
| ASSERT_TRUE(opener_extension); |
| const Extension* listener_extension = LoadExtension( |
| listener_extension_dir.UnpackedPath(), {.allow_in_incognito = true}); |
| ASSERT_TRUE(listener_extension); |
| |
| Profile* incognito_profile = |
| profile()->GetPrimaryOTRProfile(/*create_if_needed=*/true); |
| // TODO(crbug.com/335829868): Refactor to use |
| // ServiceWorkerTaskQueue::TestObserver::DidStartWorker() to ensure worker is |
| // ready to receive event in BackgroundScriptExecutor::ExecuteScript(). |
| TestServiceWorkerContextObserver sw_observer_opener_extension( |
| incognito_profile, opener_extension->id()); |
| TestServiceWorkerContextObserver sw_observer_listener_extension( |
| incognito_profile, listener_extension->id()); |
| // Open a new tab in incognito. This spawns the new process for the split mode |
| // extensions. |
| Browser* incognito_browser = OpenURLOffTheRecord( |
| profile(), embedded_test_server()->GetURL("example.com", "/simple.html")); |
| sw_observer_listener_extension.WaitForWorkerStarted(); |
| sw_observer_opener_extension.WaitForWorkerStarted(); |
| |
| // Send a message from one extension to the other, opening a message pipe. |
| // Since the listener extension never responds, the message pipe will |
| // remain open. The listener then sends the script result 'success' when it |
| // receives the message. |
| static constexpr char kOpenMessagePipe[] = R"(openMessagePipe('%s');)"; |
| base::Value script_result = BackgroundScriptExecutor::ExecuteScript( |
| incognito_profile, opener_extension->id(), |
| base::StringPrintf(kOpenMessagePipe, listener_extension->id().c_str()), |
| BackgroundScriptExecutor::ResultCapture::kSendScriptResult); |
| EXPECT_EQ("success", script_result); |
| |
| ProcessManager* incognito_process_manager = |
| ProcessManager::Get(incognito_profile); |
| |
| // Grab each extension's active worker. |
| std::vector<WorkerId> opener_worker_ids = |
| incognito_process_manager->GetServiceWorkersForExtension( |
| opener_extension->id()); |
| ASSERT_EQ(1u, opener_worker_ids.size()); |
| WorkerId opener_worker_id = opener_worker_ids[0]; |
| |
| std::vector<WorkerId> listener_worker_ids = |
| incognito_process_manager->GetServiceWorkersForExtension( |
| listener_extension->id()); |
| ASSERT_EQ(1u, listener_worker_ids.size()); |
| WorkerId listener_worker_id = listener_worker_ids[0]; |
| |
| // Verify the service workers currently have a keepalive for the message |
| // port. |
| // The keepalive flow is as follows: |
| // * Open a new message port. Add keepalives for both extensions with |
| // Activity::MESSAGE_PORT. |
| // * Message is sent to the listener extension. New Activity::MESSAGE |
| // keepalive is added for the sender extension. |
| // * The message is ack'd from the listener extension's process. |
| // Activity::MESSAGE keepalive is removed for the sender extension. |
| // Since we signal success in the listener asynchronously, the keepalive is |
| // guaranteed to have resolved. (Otherwise, it could potentially be racy). |
| // * Send chrome.test.sendScriptResult() from the listener extension. |
| // Add and remove Activity::API_FUNCTION keepalives. |
| // Thus, at the end, the remaining keepalives are one MESSAGE_PORT keepalive |
| // for each extension. |
| EXPECT_THAT( |
| incognito_process_manager->GetServiceWorkerKeepaliveDataForRecords( |
| opener_extension->id()), |
| testing::UnorderedElementsAre( |
| GetKeepaliveMatcher(opener_worker_id, Activity::MESSAGE_PORT))); |
| EXPECT_THAT( |
| incognito_process_manager->GetServiceWorkerKeepaliveDataForRecords( |
| listener_extension->id()), |
| testing::UnorderedElementsAre( |
| GetKeepaliveMatcher(listener_worker_id, Activity::MESSAGE_PORT))); |
| |
| // Close the incognito browser while the message channel is still open. Since |
| // this is the only browser window for the incognito context, this also |
| // results in the browser context being invalidated. |
| // As part of this, the keepalives are removed for the extensions, which |
| // can trigger an attempted removal of an external request from the |
| // service worker layer. Since the context is being shut down, this can |
| // fail with `content::ServiceWorkerExternalRequestResult::kNullContext`. This |
| // is fine, since the whole context is going away. |
| // See https://crbug.com/1476316. |
| ProfileDestructionWaiter profile_destruction_waiter(incognito_profile); |
| TestBrowserClosedWaiter browser_closed_waiter(incognito_browser); |
| incognito_browser->window()->Close(); |
| ASSERT_TRUE(browser_closed_waiter.WaitUntilClosed()); |
| profile_destruction_waiter.Wait(); |
| // Note: `ProfileDestructionWaiter` only waits for the profile to signal it |
| // *will* be destroyed. Spin once to finish the job. |
| base::RunLoop().RunUntilIdle(); |
| // Verify the profile is destroyed. |
| EXPECT_FALSE( |
| ExtensionsBrowserClient::Get()->IsValidContext(incognito_profile)); |
| // The test succeeds if there are no crashes. There's nothing left to verify |
| // for keepalives, since the profile is gone. |
| } |
| |
| // Tests that we can safely shut down a BrowserContext when an extension has an |
| // active keepalive for a service worker that spans between the on- and off- |
| // the-record profiles between two different extensions. |
| IN_PROC_BROWSER_TEST_F( |
| ServiceWorkerLifetimeKeepaliveBrowsertest, |
| ShutdownWithActiveMessagePipe_BetweenExtensionsInDifferentContexts) { |
| // A split-mode extension. This will have a separate process for the on- and |
| // off-the-record profiles. |
| static constexpr char kSplitModeManifest[] = |
| R"({ |
| "name": "Test", |
| "manifest_version": 3, |
| "version": "0.1", |
| "incognito": "split", |
| "background": {"service_worker": "background.js"} |
| })"; |
| static constexpr char kSplitBackgroundJs[] = R"(// Intentionally blank.)"; |
| |
| // A spanning mode extension. This will share a process between the on- and |
| // off-the-record profiles. |
| static constexpr char kSpanningManifest[] = |
| R"({ |
| "name": "Test", |
| "manifest_version": 3, |
| "version": "0.1", |
| "incognito": "spanning", |
| "background": {"service_worker": "background.js"} |
| })"; |
| |
| // The spanning mode extension listens for an external message (from the |
| // split mode extension). We save the `sendReply` callback so it's not garbage |
| // collected and keeps the message pipe open, and then asynchronously respond |
| // that the message was received. |
| // The asynchronous response is important in order to ensure the message being |
| // received from this extension is properly ack'd in the renderer before the |
| // script result is received. |
| static constexpr char kSpanningModeBackgroundJs[] = |
| R"(chrome.runtime.onMessageExternal.addListener( |
| (msg, sender, sendReply) => { |
| self.sendReply = sendReply; |
| setTimeout( |
| () => { chrome.test.sendScriptResult('success'); }, 0); |
| return true; |
| });)"; |
| |
| TestExtensionDir split_mode_dir; |
| split_mode_dir.WriteManifest(kSplitModeManifest); |
| split_mode_dir.WriteFile(FILE_PATH_LITERAL("background.js"), |
| kSplitBackgroundJs); |
| |
| TestExtensionDir spanning_mode_dir; |
| spanning_mode_dir.WriteManifest(kSpanningManifest); |
| spanning_mode_dir.WriteFile(FILE_PATH_LITERAL("background.js"), |
| kSpanningModeBackgroundJs); |
| |
| const Extension* split_mode_extension = LoadExtension( |
| split_mode_dir.UnpackedPath(), {.allow_in_incognito = true}); |
| ASSERT_TRUE(split_mode_extension); |
| const Extension* spanning_mode_extension = LoadExtension( |
| spanning_mode_dir.UnpackedPath(), {.allow_in_incognito = true}); |
| ASSERT_TRUE(spanning_mode_extension); |
| |
| Profile* incognito_profile = |
| profile()->GetPrimaryOTRProfile(/*create_if_needed=*/true); |
| // Wait for the single worker from split_mode_extension. |
| // TODO(crbug.com/335829868): Refactor to use |
| // ServiceWorkerTaskQueue::TestObserver::DidStartWorker() to ensure worker is |
| // ready to receive event in BackgroundScriptExecutor::ExecuteScript(). |
| TestServiceWorkerContextObserver sw_observer(incognito_profile); |
| // Open a new tab in incognito. This spawns the new process for the split mode |
| // extension. |
| Browser* incognito_browser = OpenURLOffTheRecord( |
| profile(), embedded_test_server()->GetURL("example.com", "/simple.html")); |
| sw_observer.WaitForWorkerStarted(); |
| |
| // Send a message to the spanning mode extension from the incognito context of |
| // the split mode extension. |
| // This will open a message pipe. Since the spanning mode extension never |
| // responds, the message pipe will remain open. |
| // The spanning mode extension will then send the script result "success" when |
| // it receives the message. |
| static constexpr char kOpenMessagePipe[] = |
| R"((async () => { |
| // Note: Pass a callback to signal a reply is expected. |
| chrome.runtime.sendMessage('%s', 'hello', () => {}); |
| })();)"; |
| base::Value script_result = BackgroundScriptExecutor::ExecuteScript( |
| incognito_profile, split_mode_extension->id(), |
| base::StringPrintf(kOpenMessagePipe, |
| spanning_mode_extension->id().c_str()), |
| BackgroundScriptExecutor::ResultCapture::kSendScriptResult); |
| EXPECT_EQ("success", script_result); |
| |
| ProcessManager* process_manager = ProcessManager::Get(profile()); |
| ProcessManager* incognito_process_manager = |
| ProcessManager::Get(incognito_profile); |
| |
| std::vector<WorkerId> worker_ids = |
| process_manager->GetServiceWorkersForExtension( |
| spanning_mode_extension->id()); |
| ASSERT_EQ(1u, worker_ids.size()); |
| WorkerId spanning_worker_id = worker_ids[0]; |
| |
| worker_ids = incognito_process_manager->GetServiceWorkersForExtension( |
| split_mode_extension->id()); |
| ASSERT_EQ(1u, worker_ids.size()); |
| WorkerId split_incognito_worker_id = worker_ids[0]; |
| |
| // Verify the current keepalives for the extensions. |
| // Each extension should have exactly one keepalive (the active message |
| // port). However, the context in which the keepalive is present is |
| // different: |
| // - The spanning mode extension should have a keepalive in the on-the-record |
| // context, and not in the incognito context (where it's not running). |
| // - The split mode extension should have a keepalive in the incognito |
| // context, but not the on-the-record context (since the message pipe is |
| // with the incognito version). |
| |
| EXPECT_THAT(process_manager->GetServiceWorkerKeepaliveDataForRecords( |
| spanning_mode_extension->id()), |
| testing::UnorderedElementsAre(GetKeepaliveMatcher( |
| spanning_worker_id, Activity::MESSAGE_PORT))); |
| EXPECT_THAT( |
| incognito_process_manager->GetServiceWorkerKeepaliveDataForRecords( |
| spanning_mode_extension->id()), |
| testing::IsEmpty()); |
| |
| EXPECT_THAT(process_manager->GetServiceWorkerKeepaliveDataForRecords( |
| split_mode_extension->id()), |
| testing::IsEmpty()); |
| EXPECT_THAT( |
| incognito_process_manager->GetServiceWorkerKeepaliveDataForRecords( |
| split_mode_extension->id()), |
| testing::UnorderedElementsAre(GetKeepaliveMatcher( |
| split_incognito_worker_id, Activity::MESSAGE_PORT))); |
| |
| // Verify the active external request count to validate the above. |
| EXPECT_EQ(1u, GetExternalRequestCountForWorker(*profile(), |
| *spanning_mode_extension)); |
| EXPECT_EQ(0u, GetExternalRequestCountForWorker(*incognito_profile, |
| *spanning_mode_extension)); |
| EXPECT_EQ( |
| 0u, GetExternalRequestCountForWorker(*profile(), *split_mode_extension)); |
| EXPECT_EQ(1u, GetExternalRequestCountForWorker(*incognito_profile, |
| *split_mode_extension)); |
| |
| // Close the incognito browser while the message channel is still open. Since |
| // this is the only browser window for the incognito context, this also |
| // results in the browser context being invalidated. |
| ProfileDestructionWaiter profile_destruction_waiter(incognito_profile); |
| TestBrowserClosedWaiter browser_closed_waiter(incognito_browser); |
| incognito_browser->window()->Close(); |
| ASSERT_TRUE(browser_closed_waiter.WaitUntilClosed()); |
| profile_destruction_waiter.Wait(); |
| // Note: `ProfileDestructionWaiter` only waits for the profile to signal it |
| // *will* be destroyed. Spin once to finish the job. |
| base::RunLoop().RunUntilIdle(); |
| |
| // Verify the profile is destroyed. |
| EXPECT_FALSE( |
| ExtensionsBrowserClient::Get()->IsValidContext(incognito_profile)); |
| |
| // Verify that all keepalives have been removed, since the message port was |
| // closed as part of the incognito profile shutdown. (We can't verify |
| // the incognito values since the incognito profile is destroyed.) |
| EXPECT_THAT(process_manager->GetServiceWorkerKeepaliveDataForRecords( |
| spanning_mode_extension->id()), |
| testing::IsEmpty()); |
| EXPECT_THAT(process_manager->GetServiceWorkerKeepaliveDataForRecords( |
| split_mode_extension->id()), |
| testing::IsEmpty()); |
| EXPECT_EQ(0u, GetExternalRequestCountForWorker(*profile(), |
| *spanning_mode_extension)); |
| EXPECT_EQ( |
| 0u, GetExternalRequestCountForWorker(*profile(), *split_mode_extension)); |
| } |
| |
| } // namespace extensions |
