annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 1 | // Copyright 2015 The Chromium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
avi | a2f4804a | 2015-12-24 23:11:13 | [diff] [blame] | 5 | #include <stdint.h> |
| 6 | |
Sylvain Defresne | 4fdc727fd | 2018-10-04 11:09:46 | [diff] [blame] | 7 | #include "base/bind.h" |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 8 | #include "base/bind_helpers.h" |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 9 | #include "base/json/json_reader.h" |
avi | a2f4804a | 2015-12-24 23:11:13 | [diff] [blame] | 10 | #include "base/macros.h" |
Gabriel Charette | 078e366 | 2017-08-28 22:59:04 | [diff] [blame] | 11 | #include "base/run_loop.h" |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 12 | #include "base/strings/stringprintf.h" |
horo | 1eeddde | 2015-11-19 05:59:25 | [diff] [blame] | 13 | #include "base/strings/utf_string_conversions.h" |
jam | 3f2d393 | 2017-04-26 20:28:51 | [diff] [blame] | 14 | #include "base/threading/thread_restrictions.h" |
Olga Sharonova | 3e13cd9 | 2018-02-08 16:43:56 | [diff] [blame] | 15 | #include "build/build_config.h" |
annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 16 | #include "chrome/browser/extensions/extension_apitest.h" |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 17 | #include "chrome/browser/extensions/extension_service.h" |
Istiaque Ahmed | 805f6a83b | 2017-10-05 01:23:26 | [diff] [blame] | 18 | #include "chrome/browser/extensions/lazy_background_page_test_util.h" |
peter | 9f4490a | 2017-01-27 00:58:36 | [diff] [blame] | 19 | #include "chrome/browser/gcm/gcm_profile_service_factory.h" |
miguelg | 9b50286 | 2017-04-24 18:13:53 | [diff] [blame] | 20 | #include "chrome/browser/notifications/notification_display_service_factory.h" |
Peter Beverloo | dd4ef1e | 2018-06-21 15:41:04 | [diff] [blame] | 21 | #include "chrome/browser/notifications/notification_permission_context.h" |
miguelg | 9b50286 | 2017-04-24 18:13:53 | [diff] [blame] | 22 | #include "chrome/browser/notifications/stub_notification_display_service.h" |
lshang | 106c177 | 2016-06-06 01:43:23 | [diff] [blame] | 23 | #include "chrome/browser/permissions/permission_manager.h" |
timloh | c691180 | 2017-03-01 05:37:03 | [diff] [blame] | 24 | #include "chrome/browser/permissions/permission_result.h" |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 25 | #include "chrome/browser/push_messaging/push_messaging_app_identifier.h" |
| 26 | #include "chrome/browser/push_messaging/push_messaging_service_factory.h" |
| 27 | #include "chrome/browser/push_messaging/push_messaging_service_impl.h" |
annekao | 1db36fd | 2015-07-29 17:09:16 | [diff] [blame] | 28 | #include "chrome/browser/ui/tabs/tab_strip_model.h" |
Trent Apted | 4267b94 | 2017-10-27 03:25:36 | [diff] [blame] | 29 | #include "chrome/common/chrome_switches.h" |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 30 | #include "chrome/common/extensions/api/web_navigation.h" |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 31 | #include "chrome/test/base/ui_test_utils.h" |
timloh | 9a180ad | 2017-02-20 07:15:23 | [diff] [blame] | 32 | #include "components/content_settings/core/common/content_settings_types.h" |
Peter Beverloo | 3413946 | 2018-04-10 14:18:06 | [diff] [blame] | 33 | #include "components/gcm_driver/fake_gcm_profile_service.h" |
johnme | a504573 | 2016-09-08 17:23:29 | [diff] [blame] | 34 | #include "components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.h" |
sdefresne | 9fb6769 | 2015-08-03 18:48:22 | [diff] [blame] | 35 | #include "components/version_info/version_info.h" |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 36 | #include "content/public/browser/navigation_controller.h" |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 37 | #include "content/public/browser/navigation_entry.h" |
lazyboy | 4c82177a | 2016-10-18 00:04:09 | [diff] [blame] | 38 | #include "content/public/browser/service_worker_context.h" |
| 39 | #include "content/public/browser/storage_partition.h" |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 40 | #include "content/public/browser/web_contents.h" |
lazyboy | bd325ae | 2015-11-18 21:35:26 | [diff] [blame] | 41 | #include "content/public/common/content_switches.h" |
falken | ad18509 | 2016-06-16 06:10:02 | [diff] [blame] | 42 | #include "content/public/common/origin_util.h" |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 43 | #include "content/public/common/page_type.h" |
lazyboy | bd325ae | 2015-11-18 21:35:26 | [diff] [blame] | 44 | #include "content/public/test/background_sync_test_util.h" |
annekao | 1db36fd | 2015-07-29 17:09:16 | [diff] [blame] | 45 | #include "content/public/test/browser_test_utils.h" |
lazyboy | 63b994a | 2017-06-30 21:20:23 | [diff] [blame] | 46 | #include "content/public/test/service_worker_test_helpers.h" |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 47 | #include "extensions/browser/event_router.h" |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 48 | #include "extensions/browser/extension_host.h" |
lazyboy | c3e763a | 2015-12-09 23:09:58 | [diff] [blame] | 49 | #include "extensions/browser/extension_registry.h" |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 50 | #include "extensions/browser/process_manager.h" |
Istiaque Ahmed | 70f76ac | 2018-11-02 02:59:55 | [diff] [blame] | 51 | #include "extensions/browser/service_worker_task_queue.h" |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 52 | #include "extensions/common/api/test.h" |
Devlin Cronin | a3fe3d60 | 2017-11-22 04:47:43 | [diff] [blame] | 53 | #include "extensions/common/extension_features.h" |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 54 | #include "extensions/common/value_builder.h" |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 55 | #include "extensions/test/background_page_watcher.h" |
annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 56 | #include "extensions/test/extension_test_message_listener.h" |
Istiaque Ahmed | 805f6a83b | 2017-10-05 01:23:26 | [diff] [blame] | 57 | #include "extensions/test/result_catcher.h" |
falken | ad18509 | 2016-06-16 06:10:02 | [diff] [blame] | 58 | #include "net/dns/mock_host_resolver.h" |
horo | 1eeddde | 2015-11-19 05:59:25 | [diff] [blame] | 59 | #include "net/test/embedded_test_server/embedded_test_server.h" |
lazyboy | 63b994a | 2017-06-30 21:20:23 | [diff] [blame] | 60 | #include "url/url_constants.h" |
annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 61 | |
| 62 | namespace extensions { |
| 63 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 64 | namespace { |
| 65 | |
lazyboy | 22eddc71 | 2015-12-10 21:16:26 | [diff] [blame] | 66 | // Returns the newly added WebContents. |
| 67 | content::WebContents* AddTab(Browser* browser, const GURL& url) { |
| 68 | int starting_tab_count = browser->tab_strip_model()->count(); |
| 69 | ui_test_utils::NavigateToURLWithDisposition( |
nick | 3b04f32 | 2016-08-31 19:29:19 | [diff] [blame] | 70 | browser, url, WindowOpenDisposition::NEW_FOREGROUND_TAB, |
lazyboy | 22eddc71 | 2015-12-10 21:16:26 | [diff] [blame] | 71 | ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); |
| 72 | int tab_count = browser->tab_strip_model()->count(); |
| 73 | EXPECT_EQ(starting_tab_count + 1, tab_count); |
| 74 | return browser->tab_strip_model()->GetActiveWebContents(); |
| 75 | } |
| 76 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 77 | enum BindingsType { NATIVE_BINDINGS, JAVASCRIPT_BINDINGS }; |
| 78 | |
lazyboy | 22eddc71 | 2015-12-10 21:16:26 | [diff] [blame] | 79 | class WebContentsLoadStopObserver : content::WebContentsObserver { |
| 80 | public: |
| 81 | explicit WebContentsLoadStopObserver(content::WebContents* web_contents) |
| 82 | : content::WebContentsObserver(web_contents), |
| 83 | load_stop_observed_(false) {} |
| 84 | |
| 85 | void WaitForLoadStop() { |
| 86 | if (load_stop_observed_) |
| 87 | return; |
| 88 | message_loop_runner_ = new content::MessageLoopRunner; |
| 89 | message_loop_runner_->Run(); |
| 90 | } |
| 91 | |
| 92 | private: |
| 93 | void DidStopLoading() override { |
| 94 | load_stop_observed_ = true; |
| 95 | if (message_loop_runner_) |
| 96 | message_loop_runner_->Quit(); |
| 97 | } |
| 98 | |
| 99 | bool load_stop_observed_; |
| 100 | scoped_refptr<content::MessageLoopRunner> message_loop_runner_; |
| 101 | |
| 102 | DISALLOW_COPY_AND_ASSIGN(WebContentsLoadStopObserver); |
| 103 | }; |
| 104 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 105 | } // namespace |
| 106 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 107 | class ServiceWorkerTest : public ExtensionApiTest, |
| 108 | public ::testing::WithParamInterface<BindingsType> { |
annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 109 | public: |
lazyboy | 20167c2 | 2016-05-18 00:59:30 | [diff] [blame] | 110 | ServiceWorkerTest() : current_channel_(version_info::Channel::STABLE) {} |
Istiaque Ahmed | 7105f2a | 2017-10-07 01:11:59 | [diff] [blame] | 111 | explicit ServiceWorkerTest(version_info::Channel channel) |
| 112 | : current_channel_(channel) {} |
annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 113 | |
| 114 | ~ServiceWorkerTest() override {} |
| 115 | |
Devlin Cronin | a3fe3d60 | 2017-11-22 04:47:43 | [diff] [blame] | 116 | void SetUp() override { |
| 117 | if (GetParam() == NATIVE_BINDINGS) { |
Mostyn Bramley-Moore | b6a37c6 | 2018-09-04 21:43:35 | [diff] [blame] | 118 | scoped_feature_list_.InitAndEnableFeature( |
| 119 | extensions_features::kNativeCrxBindings); |
Devlin Cronin | a3fe3d60 | 2017-11-22 04:47:43 | [diff] [blame] | 120 | } else { |
| 121 | DCHECK_EQ(JAVASCRIPT_BINDINGS, GetParam()); |
Mostyn Bramley-Moore | b6a37c6 | 2018-09-04 21:43:35 | [diff] [blame] | 122 | scoped_feature_list_.InitAndDisableFeature( |
| 123 | extensions_features::kNativeCrxBindings); |
Devlin Cronin | a3fe3d60 | 2017-11-22 04:47:43 | [diff] [blame] | 124 | } |
| 125 | ExtensionApiTest::SetUp(); |
| 126 | } |
| 127 | |
jam | 1a5b558 | 2017-05-01 16:50:10 | [diff] [blame] | 128 | void SetUpOnMainThread() override { |
| 129 | ExtensionApiTest::SetUpOnMainThread(); |
| 130 | host_resolver()->AddRule("a.com", "127.0.0.1"); |
| 131 | } |
| 132 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 133 | protected: |
| 134 | // Returns the ProcessManager for the test's profile. |
| 135 | ProcessManager* process_manager() { return ProcessManager::Get(profile()); } |
| 136 | |
| 137 | // Starts running a test from the background page test extension. |
| 138 | // |
| 139 | // This registers a service worker with |script_name|, and fetches the |
| 140 | // registration result. |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 141 | const Extension* StartTestFromBackgroundPage(const char* script_name) { |
Istiaque Ahmed | 6475f54 | 2018-08-28 04:20:21 | [diff] [blame] | 142 | ExtensionTestMessageListener ready_listener("ready", false); |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 143 | const Extension* extension = |
| 144 | LoadExtension(test_data_dir_.AppendASCII("service_worker/background")); |
| 145 | CHECK(extension); |
Istiaque Ahmed | 6475f54 | 2018-08-28 04:20:21 | [diff] [blame] | 146 | CHECK(ready_listener.WaitUntilSatisfied()); |
| 147 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 148 | ExtensionHost* background_host = |
| 149 | process_manager()->GetBackgroundHostForExtension(extension->id()); |
| 150 | CHECK(background_host); |
Istiaque Ahmed | 6475f54 | 2018-08-28 04:20:21 | [diff] [blame] | 151 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 152 | std::string error; |
| 153 | CHECK(content::ExecuteScriptAndExtractString( |
| 154 | background_host->host_contents(), |
| 155 | base::StringPrintf("test.registerServiceWorker('%s')", script_name), |
| 156 | &error)); |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 157 | if (!error.empty()) |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 158 | ADD_FAILURE() << "Got unexpected error " << error; |
| 159 | return extension; |
| 160 | } |
| 161 | |
| 162 | // Navigates the browser to a new tab at |url|, waits for it to load, then |
| 163 | // returns it. |
| 164 | content::WebContents* Navigate(const GURL& url) { |
| 165 | ui_test_utils::NavigateToURLWithDisposition( |
nick | 3b04f32 | 2016-08-31 19:29:19 | [diff] [blame] | 166 | browser(), url, WindowOpenDisposition::NEW_FOREGROUND_TAB, |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 167 | ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); |
| 168 | content::WebContents* web_contents = |
| 169 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 170 | content::WaitForLoadStop(web_contents); |
| 171 | return web_contents; |
| 172 | } |
| 173 | |
| 174 | // Navigates the browser to |url| and returns the new tab's page type. |
| 175 | content::PageType NavigateAndGetPageType(const GURL& url) { |
clamy | 1d7a411 | 2018-06-15 15:47:16 | [diff] [blame] | 176 | return Navigate(url) |
| 177 | ->GetController() |
| 178 | .GetLastCommittedEntry() |
| 179 | ->GetPageType(); |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | // Extracts the innerText from |contents|. |
| 183 | std::string ExtractInnerText(content::WebContents* contents) { |
| 184 | std::string inner_text; |
| 185 | if (!content::ExecuteScriptAndExtractString( |
| 186 | contents, |
| 187 | "window.domAutomationController.send(document.body.innerText)", |
| 188 | &inner_text)) { |
| 189 | ADD_FAILURE() << "Failed to get inner text for " |
| 190 | << contents->GetVisibleURL(); |
| 191 | } |
| 192 | return inner_text; |
| 193 | } |
| 194 | |
| 195 | // Navigates the browser to |url|, then returns the innerText of the new |
| 196 | // tab's WebContents' main frame. |
| 197 | std::string NavigateAndExtractInnerText(const GURL& url) { |
| 198 | return ExtractInnerText(Navigate(url)); |
| 199 | } |
| 200 | |
lazyboy | 4c82177a | 2016-10-18 00:04:09 | [diff] [blame] | 201 | size_t GetWorkerRefCount(const GURL& origin) { |
| 202 | content::ServiceWorkerContext* sw_context = |
| 203 | content::BrowserContext::GetDefaultStoragePartition( |
| 204 | browser()->profile()) |
| 205 | ->GetServiceWorkerContext(); |
| 206 | base::RunLoop run_loop; |
| 207 | size_t ref_count = 0; |
| 208 | auto set_ref_count = [](size_t* ref_count, base::RunLoop* run_loop, |
| 209 | size_t external_request_count) { |
| 210 | *ref_count = external_request_count; |
| 211 | run_loop->Quit(); |
| 212 | }; |
| 213 | sw_context->CountExternalRequestsForTest( |
Matt Falkenhagen | c5cb428 | 2017-09-07 08:43:42 | [diff] [blame] | 214 | origin, base::BindOnce(set_ref_count, &ref_count, &run_loop)); |
lazyboy | 4c82177a | 2016-10-18 00:04:09 | [diff] [blame] | 215 | run_loop.Run(); |
| 216 | return ref_count; |
| 217 | } |
| 218 | |
annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 219 | private: |
lazyboy | 20167c2 | 2016-05-18 00:59:30 | [diff] [blame] | 220 | // Sets the channel to "stable". |
| 221 | // Not useful after we've opened extension Service Workers to stable |
| 222 | // channel. |
| 223 | // TODO(lazyboy): Remove this when ExtensionServiceWorkersEnabled() is |
| 224 | // removed. |
annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 225 | ScopedCurrentChannel current_channel_; |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 226 | |
Devlin Cronin | a3fe3d60 | 2017-11-22 04:47:43 | [diff] [blame] | 227 | base::test::ScopedFeatureList scoped_feature_list_; |
| 228 | |
annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 229 | DISALLOW_COPY_AND_ASSIGN(ServiceWorkerTest); |
| 230 | }; |
| 231 | |
Istiaque Ahmed | ccb44402 | 2018-06-19 02:11:12 | [diff] [blame] | 232 | class ServiceWorkerBasedBackgroundTest : public ServiceWorkerTest { |
| 233 | public: |
| 234 | ServiceWorkerBasedBackgroundTest() |
| 235 | : ServiceWorkerTest( |
| 236 | // Extensions APIs from SW are only enabled on trunk. |
| 237 | // It is important to set the channel early so that this change is |
| 238 | // visible in renderers running with service workers (and no |
| 239 | // extension). |
| 240 | version_info::Channel::UNKNOWN) {} |
| 241 | ~ServiceWorkerBasedBackgroundTest() override {} |
| 242 | |
| 243 | void SetUpOnMainThread() override { |
| 244 | host_resolver()->AddRule("*", "127.0.0.1"); |
| 245 | ASSERT_TRUE(embedded_test_server()->Start()); |
| 246 | ServiceWorkerTest::SetUpOnMainThread(); |
| 247 | } |
| 248 | |
| 249 | private: |
| 250 | DISALLOW_COPY_AND_ASSIGN(ServiceWorkerBasedBackgroundTest); |
| 251 | }; |
| 252 | |
| 253 | // Tests that Service Worker based background pages can be loaded and they can |
| 254 | // receive extension events. |
| 255 | // The extension is installed and loaded during this step and it registers |
| 256 | // an event listener for tabs.onCreated event. The step also verifies that tab |
| 257 | // creation correctly fires the listener. |
| 258 | IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, PRE_Basic) { |
| 259 | ExtensionTestMessageListener newtab_listener("CREATED", false); |
| 260 | newtab_listener.set_failure_message("CREATE_FAILED"); |
| 261 | ExtensionTestMessageListener worker_listener("WORKER_RUNNING", false); |
| 262 | worker_listener.set_failure_message("NON_WORKER_SCOPE"); |
| 263 | const Extension* extension = LoadExtension(test_data_dir_.AppendASCII( |
| 264 | "service_worker/worker_based_background/basic")); |
| 265 | ASSERT_TRUE(extension); |
| 266 | const ExtensionId extension_id = extension->id(); |
| 267 | EXPECT_TRUE(worker_listener.WaitUntilSatisfied()); |
| 268 | |
| 269 | const GURL url = embedded_test_server()->GetURL("/extensions/test_file.html"); |
| 270 | content::WebContents* new_web_contents = AddTab(browser(), url); |
| 271 | EXPECT_TRUE(new_web_contents); |
| 272 | EXPECT_TRUE(newtab_listener.WaitUntilSatisfied()); |
| 273 | |
| 274 | // Service Worker extension does not have ExtensionHost. |
| 275 | EXPECT_FALSE(process_manager()->GetBackgroundHostForExtension(extension_id)); |
| 276 | } |
| 277 | |
| 278 | // After browser restarts, this test step ensures that opening a tab fires |
| 279 | // tabs.onCreated event listener to the extension without explicitly loading the |
| 280 | // extension. This is because the extension registered a listener before browser |
| 281 | // restarted in PRE_Basic. |
Istiaque Ahmed | ad376e6b | 2018-09-13 22:48:25 | [diff] [blame] | 282 | IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, Basic) { |
Istiaque Ahmed | ccb44402 | 2018-06-19 02:11:12 | [diff] [blame] | 283 | ExtensionTestMessageListener newtab_listener("CREATED", false); |
| 284 | newtab_listener.set_failure_message("CREATE_FAILED"); |
| 285 | const GURL url = embedded_test_server()->GetURL("/extensions/test_file.html"); |
| 286 | content::WebContents* new_web_contents = AddTab(browser(), url); |
| 287 | EXPECT_TRUE(new_web_contents); |
| 288 | EXPECT_TRUE(newtab_listener.WaitUntilSatisfied()); |
| 289 | } |
| 290 | |
Istiaque Ahmed | bf08f95 | 2018-10-02 01:22:04 | [diff] [blame] | 291 | // Tests chrome.runtime.onInstalled fires for extension service workers. |
| 292 | IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, OnInstalledEvent) { |
| 293 | ASSERT_TRUE(RunExtensionTest( |
| 294 | "service_worker/worker_based_background/events_on_installed")) |
| 295 | << message_; |
| 296 | } |
| 297 | |
David Bertoni | 6998283 | 2019-02-13 21:24:21 | [diff] [blame] | 298 | // Tests chrome.storage APIs. |
| 299 | IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, StorageSetAndGet) { |
| 300 | ASSERT_TRUE( |
| 301 | RunExtensionTest("service_worker/worker_based_background/storage")) |
| 302 | << message_; |
| 303 | } |
| 304 | |
David Bertoni | 0665c89 | 2019-02-14 00:27:26 | [diff] [blame^] | 305 | // Tests chrome.storage.local and chrome.storage.local APIs. |
| 306 | IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, StorageNoPermissions) { |
| 307 | ASSERT_TRUE(RunExtensionTest( |
| 308 | "service_worker/worker_based_background/storage_no_permissions")) |
| 309 | << message_; |
| 310 | } |
| 311 | |
Istiaque Ahmed | 70f76ac | 2018-11-02 02:59:55 | [diff] [blame] | 312 | // Listens for |message| from extension Service Worker early so that tests can |
| 313 | // wait for the message on startup (and not miss it). |
| 314 | class ServiceWorkerWithEarlyMessageListenerTest |
| 315 | : public ServiceWorkerBasedBackgroundTest { |
Istiaque Ahmed | f70ab22 | 2018-10-02 03:08:24 | [diff] [blame] | 316 | public: |
Istiaque Ahmed | 70f76ac | 2018-11-02 02:59:55 | [diff] [blame] | 317 | explicit ServiceWorkerWithEarlyMessageListenerTest( |
| 318 | const std::string& test_message) |
| 319 | : test_message_(test_message) {} |
| 320 | ~ServiceWorkerWithEarlyMessageListenerTest() override = default; |
Istiaque Ahmed | f70ab22 | 2018-10-02 03:08:24 | [diff] [blame] | 321 | |
Istiaque Ahmed | 70f76ac | 2018-11-02 02:59:55 | [diff] [blame] | 322 | bool WaitForMessage() { return listener_->WaitUntilSatisfied(); } |
Istiaque Ahmed | f70ab22 | 2018-10-02 03:08:24 | [diff] [blame] | 323 | |
| 324 | void CreatedBrowserMainParts(content::BrowserMainParts* main_parts) override { |
| 325 | // At this point, the notification service is initialized but the profile |
| 326 | // and extensions have not. |
Istiaque Ahmed | 70f76ac | 2018-11-02 02:59:55 | [diff] [blame] | 327 | listener_ = |
| 328 | std::make_unique<ExtensionTestMessageListener>(test_message_, false); |
Istiaque Ahmed | f70ab22 | 2018-10-02 03:08:24 | [diff] [blame] | 329 | ServiceWorkerBasedBackgroundTest::CreatedBrowserMainParts(main_parts); |
| 330 | } |
| 331 | |
| 332 | private: |
Istiaque Ahmed | 70f76ac | 2018-11-02 02:59:55 | [diff] [blame] | 333 | const std::string test_message_; |
Istiaque Ahmed | f70ab22 | 2018-10-02 03:08:24 | [diff] [blame] | 334 | std::unique_ptr<ExtensionTestMessageListener> listener_; |
| 335 | |
Istiaque Ahmed | 70f76ac | 2018-11-02 02:59:55 | [diff] [blame] | 336 | DISALLOW_COPY_AND_ASSIGN(ServiceWorkerWithEarlyMessageListenerTest); |
| 337 | }; |
| 338 | |
| 339 | class ServiceWorkerOnStartupEventTest |
| 340 | : public ServiceWorkerWithEarlyMessageListenerTest { |
| 341 | public: |
| 342 | ServiceWorkerOnStartupEventTest() |
| 343 | : ServiceWorkerWithEarlyMessageListenerTest("onStartup event") {} |
| 344 | ~ServiceWorkerOnStartupEventTest() override = default; |
| 345 | |
| 346 | private: |
| 347 | DISALLOW_COPY_AND_ASSIGN(ServiceWorkerOnStartupEventTest); |
Istiaque Ahmed | f70ab22 | 2018-10-02 03:08:24 | [diff] [blame] | 348 | }; |
| 349 | |
| 350 | // Tests "runtime.onStartup" for extension SW. |
Istiaque Ahmed | 70f76ac | 2018-11-02 02:59:55 | [diff] [blame] | 351 | IN_PROC_BROWSER_TEST_P(ServiceWorkerOnStartupEventTest, PRE_Event) { |
Istiaque Ahmed | f70ab22 | 2018-10-02 03:08:24 | [diff] [blame] | 352 | ASSERT_TRUE(RunExtensionTest( |
| 353 | "service_worker/worker_based_background/on_startup_event")) |
| 354 | << message_; |
| 355 | } |
| 356 | |
Istiaque Ahmed | 70f76ac | 2018-11-02 02:59:55 | [diff] [blame] | 357 | IN_PROC_BROWSER_TEST_P(ServiceWorkerOnStartupEventTest, Event) { |
| 358 | EXPECT_TRUE(WaitForMessage()); |
| 359 | } |
| 360 | |
| 361 | class ServiceWorkerRegistrationAtStartupTest |
| 362 | : public ServiceWorkerWithEarlyMessageListenerTest, |
| 363 | public ServiceWorkerTaskQueue::TestObserver { |
| 364 | public: |
| 365 | ServiceWorkerRegistrationAtStartupTest() |
| 366 | : ServiceWorkerWithEarlyMessageListenerTest("WORKER_RUNNING") { |
| 367 | ServiceWorkerTaskQueue::SetObserverForTest(this); |
| 368 | } |
| 369 | ~ServiceWorkerRegistrationAtStartupTest() override { |
| 370 | ServiceWorkerTaskQueue::SetObserverForTest(nullptr); |
| 371 | } |
| 372 | |
| 373 | // ServiceWorkerTaskQueue::TestObserver: |
| 374 | void OnActivateExtension(const ExtensionId& extension_id, |
| 375 | bool will_register_service_worker) override { |
| 376 | if (extension_id != kExtensionId) |
| 377 | return; |
| 378 | |
| 379 | will_register_service_worker_ = will_register_service_worker; |
| 380 | |
| 381 | extension_activated_ = true; |
| 382 | if (run_loop_) |
| 383 | run_loop_->Quit(); |
| 384 | } |
| 385 | |
| 386 | void WaitForOnActivateExtension() { |
| 387 | if (extension_activated_) |
| 388 | return; |
| 389 | run_loop_ = std::make_unique<base::RunLoop>(); |
| 390 | run_loop_->Run(); |
| 391 | } |
| 392 | |
| 393 | bool WillRegisterServiceWorker() { |
| 394 | return will_register_service_worker_.value(); |
| 395 | } |
| 396 | |
| 397 | protected: |
| 398 | static const char kExtensionId[]; |
| 399 | |
| 400 | private: |
| 401 | bool extension_activated_ = false; |
| 402 | base::Optional<bool> will_register_service_worker_; |
| 403 | std::unique_ptr<base::RunLoop> run_loop_; |
| 404 | |
| 405 | DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRegistrationAtStartupTest); |
| 406 | }; |
| 407 | |
| 408 | // Test extension id at |
| 409 | // api_test/service_worker/worker_based_background/registration_at_startup/. |
| 410 | const char ServiceWorkerRegistrationAtStartupTest::kExtensionId[] = |
| 411 | "gnchfmandajfaiajniicagenfmhdjila"; |
| 412 | |
| 413 | // Tests that Service Worker registration for existing extension isn't issued |
| 414 | // upon browser restart. |
| 415 | // Regression test for https://crbug.com/889687. |
| 416 | IN_PROC_BROWSER_TEST_P(ServiceWorkerRegistrationAtStartupTest, |
| 417 | PRE_ExtensionActivationDoesNotReregister) { |
| 418 | const Extension* extension = LoadExtension(test_data_dir_.AppendASCII( |
| 419 | "service_worker/worker_based_background/registration_at_startup")); |
| 420 | ASSERT_TRUE(extension); |
| 421 | EXPECT_EQ(kExtensionId, extension->id()); |
| 422 | // Wait for "WORKER_RUNNING" message from the Service Worker. |
| 423 | EXPECT_TRUE(WaitForMessage()); |
| 424 | EXPECT_TRUE(WillRegisterServiceWorker()); |
| 425 | } |
| 426 | |
| 427 | IN_PROC_BROWSER_TEST_P(ServiceWorkerRegistrationAtStartupTest, |
| 428 | ExtensionActivationDoesNotReregister) { |
| 429 | // Since the extension has onStartup listener, the Service Worker will run on |
| 430 | // browser start and we'll see "WORKER_RUNNING" message from the worker. |
| 431 | EXPECT_TRUE(WaitForMessage()); |
| 432 | // As the extension activated during first run on PRE_ step, it shouldn't |
| 433 | // re-register the Service Worker upon browser restart. |
| 434 | EXPECT_FALSE(WillRegisterServiceWorker()); |
Istiaque Ahmed | f70ab22 | 2018-10-02 03:08:24 | [diff] [blame] | 435 | } |
| 436 | |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 437 | // Class that dispatches an event to |extension_id| right after a |
| 438 | // non-lazy listener to the event is added from the extension's Service Worker. |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 439 | class EarlyWorkerMessageSender : public EventRouter::Observer { |
| 440 | public: |
| 441 | EarlyWorkerMessageSender(content::BrowserContext* browser_context, |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 442 | const ExtensionId& extension_id, |
| 443 | std::unique_ptr<Event> event) |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 444 | : browser_context_(browser_context), |
| 445 | event_router_(EventRouter::EventRouter::Get(browser_context_)), |
| 446 | extension_id_(extension_id), |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 447 | event_(std::move(event)), |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 448 | listener_("PASS", false) { |
| 449 | DCHECK(browser_context_); |
| 450 | listener_.set_failure_message("FAIL"); |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 451 | event_router_->RegisterObserver(this, event_->event_name); |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 452 | } |
| 453 | |
| 454 | ~EarlyWorkerMessageSender() override { |
| 455 | event_router_->UnregisterObserver(this); |
| 456 | } |
| 457 | |
| 458 | // EventRouter::Observer: |
| 459 | void OnListenerAdded(const EventListenerInfo& details) override { |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 460 | if (!event_ || extension_id_ != details.extension_id || |
| 461 | event_->event_name != details.event_name) { |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 462 | return; |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 463 | } |
| 464 | |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 465 | const bool is_lazy_listener = details.browser_context == nullptr; |
| 466 | if (is_lazy_listener) { |
| 467 | // Wait for the non-lazy listener as we want to exercise the code to |
| 468 | // dispatch the event right after the Service Worker registration is |
| 469 | // completing. |
| 470 | return; |
| 471 | } |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 472 | DispatchEvent(std::move(event_)); |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 473 | } |
| 474 | |
| 475 | bool SendAndWait() { return listener_.WaitUntilSatisfied(); } |
| 476 | |
| 477 | private: |
| 478 | static constexpr const char* const kTestOnMessageEventName = "test.onMessage"; |
| 479 | |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 480 | void DispatchEvent(std::unique_ptr<Event> event) { |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 481 | EventRouter::Get(browser_context_) |
| 482 | ->DispatchEventToExtension(extension_id_, std::move(event)); |
| 483 | } |
| 484 | |
| 485 | content::BrowserContext* const browser_context_ = nullptr; |
| 486 | EventRouter* const event_router_ = nullptr; |
| 487 | const ExtensionId extension_id_; |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 488 | std::unique_ptr<Event> event_; |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 489 | ExtensionTestMessageListener listener_; |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 490 | |
| 491 | DISALLOW_COPY_AND_ASSIGN(EarlyWorkerMessageSender); |
| 492 | }; |
| 493 | |
| 494 | // Tests that extension event dispatch works correctly right after extension |
| 495 | // installation registers its Service Worker. |
| 496 | // Regression test for: https://crbug.com/850792. |
| 497 | IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, EarlyEventDispatch) { |
| 498 | const ExtensionId kId("pkplfbidichfdicaijlchgnapepdginl"); |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 499 | |
| 500 | // Build "test.onMessage" event for dispatch. |
| 501 | auto event = std::make_unique<Event>( |
| 502 | events::FOR_TEST, extensions::api::test::OnMessage::kEventName, |
Lei Zhang | 582ecd1 | 2019-02-13 20:28:54 | [diff] [blame] | 503 | base::ListValue::From(base::JSONReader::ReadDeprecated( |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 504 | R"([{"data": "hello", "lastMessage": true}])")), |
| 505 | profile()); |
| 506 | |
| 507 | EarlyWorkerMessageSender sender(profile(), kId, std::move(event)); |
Istiaque Ahmed | 771aa8a2 | 2018-06-20 23:40:53 | [diff] [blame] | 508 | // pkplfbidichfdicaijlchgnapepdginl |
| 509 | const Extension* extension = LoadExtension(test_data_dir_.AppendASCII( |
| 510 | "service_worker/worker_based_background/early_event_dispatch")); |
| 511 | CHECK(extension); |
| 512 | EXPECT_EQ(kId, extension->id()); |
| 513 | EXPECT_TRUE(sender.SendAndWait()); |
| 514 | } |
| 515 | |
Istiaque Ahmed | a14ec48 | 2018-08-25 01:02:18 | [diff] [blame] | 516 | // Tests that filtered events dispatches correctly right after a non-lazy |
| 517 | // listener is registered for that event (and before the corresponding lazy |
| 518 | // listener is registered). |
| 519 | IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, |
| 520 | EarlyFilteredEventDispatch) { |
| 521 | const ExtensionId kId("pkplfbidichfdicaijlchgnapepdginl"); |
| 522 | |
| 523 | // Add minimal details required to dispatch webNavigation.onCommitted event: |
| 524 | extensions::api::web_navigation::OnCommitted::Details details; |
| 525 | details.transition_type = |
| 526 | extensions::api::web_navigation::TRANSITION_TYPE_TYPED; |
| 527 | |
| 528 | // Build a dummy onCommited event to dispatch. |
| 529 | auto on_committed_event = std::make_unique<Event>( |
| 530 | events::WEB_NAVIGATION_ON_COMMITTED, "webNavigation.onCommitted", |
| 531 | api::web_navigation::OnCommitted::Create(details), profile()); |
| 532 | // The filter will match the listener filter registered from the extension. |
| 533 | EventFilteringInfo info; |
| 534 | info.url = GURL("http://foo.com/a.html"); |
| 535 | on_committed_event->filter_info = info; |
| 536 | |
| 537 | EarlyWorkerMessageSender sender(profile(), kId, |
| 538 | std::move(on_committed_event)); |
| 539 | |
| 540 | // pkplfbidichfdicaijlchgnapepdginl |
| 541 | const Extension* extension = LoadExtension(test_data_dir_.AppendASCII( |
| 542 | "service_worker/worker_based_background/early_filtered_event_dispatch")); |
| 543 | ASSERT_TRUE(extension); |
| 544 | EXPECT_EQ(kId, extension->id()); |
| 545 | EXPECT_TRUE(sender.SendAndWait()); |
| 546 | } |
| 547 | |
lazyboy | bd325ae | 2015-11-18 21:35:26 | [diff] [blame] | 548 | class ServiceWorkerBackgroundSyncTest : public ServiceWorkerTest { |
| 549 | public: |
| 550 | ServiceWorkerBackgroundSyncTest() {} |
| 551 | ~ServiceWorkerBackgroundSyncTest() override {} |
| 552 | |
| 553 | void SetUpCommandLine(base::CommandLine* command_line) override { |
| 554 | // ServiceWorkerRegistration.sync requires experimental flag. |
| 555 | command_line->AppendSwitch( |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 556 | ::switches::kEnableExperimentalWebPlatformFeatures); |
lazyboy | bd325ae | 2015-11-18 21:35:26 | [diff] [blame] | 557 | ServiceWorkerTest::SetUpCommandLine(command_line); |
| 558 | } |
| 559 | |
| 560 | void SetUp() override { |
Robbie McElrath | db12d8e | 2018-09-18 21:20:40 | [diff] [blame] | 561 | content::background_sync_test_util::SetIgnoreNetworkChanges(true); |
lazyboy | bd325ae | 2015-11-18 21:35:26 | [diff] [blame] | 562 | ServiceWorkerTest::SetUp(); |
| 563 | } |
| 564 | |
| 565 | private: |
| 566 | DISALLOW_COPY_AND_ASSIGN(ServiceWorkerBackgroundSyncTest); |
| 567 | }; |
| 568 | |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 569 | class ServiceWorkerPushMessagingTest : public ServiceWorkerTest { |
| 570 | public: |
| 571 | ServiceWorkerPushMessagingTest() |
Sylvain Defresne | 212b4b0 | 2018-10-11 16:32:05 | [diff] [blame] | 572 | : scoped_testing_factory_installer_( |
| 573 | base::BindRepeating(&gcm::FakeGCMProfileService::Build)), |
| 574 | gcm_driver_(nullptr), |
| 575 | push_service_(nullptr) {} |
| 576 | |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 577 | ~ServiceWorkerPushMessagingTest() override {} |
| 578 | |
| 579 | void GrantNotificationPermissionForTest(const GURL& url) { |
Peter Beverloo | dd4ef1e | 2018-06-21 15:41:04 | [diff] [blame] | 580 | NotificationPermissionContext::UpdatePermission(profile(), url.GetOrigin(), |
| 581 | CONTENT_SETTING_ALLOW); |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 582 | } |
| 583 | |
| 584 | PushMessagingAppIdentifier GetAppIdentifierForServiceWorkerRegistration( |
avi | a2f4804a | 2015-12-24 23:11:13 | [diff] [blame] | 585 | int64_t service_worker_registration_id, |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 586 | const GURL& origin) { |
| 587 | PushMessagingAppIdentifier app_identifier = |
| 588 | PushMessagingAppIdentifier::FindByServiceWorker( |
| 589 | profile(), origin, service_worker_registration_id); |
| 590 | |
| 591 | EXPECT_FALSE(app_identifier.is_null()); |
| 592 | return app_identifier; |
| 593 | } |
| 594 | |
| 595 | // ExtensionApiTest overrides. |
| 596 | void SetUpCommandLine(base::CommandLine* command_line) override { |
peter | 9de9627 | 2015-12-04 15:23:27 | [diff] [blame] | 597 | command_line->AppendSwitch( |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 598 | ::switches::kEnableExperimentalWebPlatformFeatures); |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 599 | ServiceWorkerTest::SetUpCommandLine(command_line); |
| 600 | } |
Tanja Gornak | 89128fd | 2018-09-18 08:49:34 | [diff] [blame] | 601 | |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 602 | void SetUpOnMainThread() override { |
miguelg | 9b50286 | 2017-04-24 18:13:53 | [diff] [blame] | 603 | NotificationDisplayServiceFactory::GetInstance()->SetTestingFactory( |
Sylvain Defresne | 711ff6b | 2018-10-04 12:33:54 | [diff] [blame] | 604 | profile(), |
| 605 | base::BindRepeating(&StubNotificationDisplayService::FactoryForTests)); |
miguelg | 9b50286 | 2017-04-24 18:13:53 | [diff] [blame] | 606 | |
johnme | a504573 | 2016-09-08 17:23:29 | [diff] [blame] | 607 | gcm::FakeGCMProfileService* gcm_service = |
| 608 | static_cast<gcm::FakeGCMProfileService*>( |
Tanja Gornak | 89128fd | 2018-09-18 08:49:34 | [diff] [blame] | 609 | gcm::GCMProfileServiceFactory::GetForProfile(profile())); |
johnme | a504573 | 2016-09-08 17:23:29 | [diff] [blame] | 610 | gcm_driver_ = static_cast<instance_id::FakeGCMDriverForInstanceID*>( |
| 611 | gcm_service->driver()); |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 612 | push_service_ = PushMessagingServiceFactory::GetForProfile(profile()); |
| 613 | |
| 614 | ServiceWorkerTest::SetUpOnMainThread(); |
| 615 | } |
| 616 | |
johnme | a504573 | 2016-09-08 17:23:29 | [diff] [blame] | 617 | instance_id::FakeGCMDriverForInstanceID* gcm_driver() const { |
| 618 | return gcm_driver_; |
| 619 | } |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 620 | PushMessagingServiceImpl* push_service() const { return push_service_; } |
| 621 | |
| 622 | private: |
Sylvain Defresne | 212b4b0 | 2018-10-11 16:32:05 | [diff] [blame] | 623 | gcm::GCMProfileServiceFactory::ScopedTestingFactoryInstaller |
| 624 | scoped_testing_factory_installer_; |
| 625 | |
johnme | a504573 | 2016-09-08 17:23:29 | [diff] [blame] | 626 | instance_id::FakeGCMDriverForInstanceID* gcm_driver_; |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 627 | PushMessagingServiceImpl* push_service_; |
| 628 | |
| 629 | DISALLOW_COPY_AND_ASSIGN(ServiceWorkerPushMessagingTest); |
| 630 | }; |
| 631 | |
Istiaque Ahmed | 805f6a83b | 2017-10-05 01:23:26 | [diff] [blame] | 632 | class ServiceWorkerLazyBackgroundTest : public ServiceWorkerTest { |
| 633 | public: |
Istiaque Ahmed | 7105f2a | 2017-10-07 01:11:59 | [diff] [blame] | 634 | ServiceWorkerLazyBackgroundTest() |
| 635 | : ServiceWorkerTest( |
| 636 | // Extensions APIs from SW are only enabled on trunk. |
| 637 | // It is important to set the channel early so that this change is |
| 638 | // visible in renderers running with service workers (and no |
| 639 | // extension). |
| 640 | version_info::Channel::UNKNOWN) {} |
Istiaque Ahmed | 805f6a83b | 2017-10-05 01:23:26 | [diff] [blame] | 641 | ~ServiceWorkerLazyBackgroundTest() override {} |
| 642 | |
| 643 | void SetUpCommandLine(base::CommandLine* command_line) override { |
| 644 | ServiceWorkerTest::SetUpCommandLine(command_line); |
| 645 | // Disable background network activity as it can suddenly bring the Lazy |
| 646 | // Background Page alive. |
| 647 | command_line->AppendSwitch(::switches::kDisableBackgroundNetworking); |
| 648 | command_line->AppendSwitch(::switches::kNoProxyServer); |
| 649 | } |
| 650 | |
| 651 | void SetUpInProcessBrowserTestFixture() override { |
| 652 | ServiceWorkerTest::SetUpInProcessBrowserTestFixture(); |
| 653 | // Set shorter delays to prevent test timeouts. |
| 654 | ProcessManager::SetEventPageIdleTimeForTesting(1); |
| 655 | ProcessManager::SetEventPageSuspendingTimeForTesting(1); |
| 656 | } |
| 657 | |
| 658 | private: |
| 659 | DISALLOW_COPY_AND_ASSIGN(ServiceWorkerLazyBackgroundTest); |
| 660 | }; |
| 661 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 662 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, RegisterSucceeds) { |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 663 | StartTestFromBackgroundPage("register.js"); |
annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 664 | } |
| 665 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 666 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, UpdateRefreshesServiceWorker) { |
Francois Doray | e6fb2d0 | 2017-10-18 21:29:13 | [diff] [blame] | 667 | base::ScopedAllowBlockingForTesting allow_blocking; |
lazyboy | c3e763a | 2015-12-09 23:09:58 | [diff] [blame] | 668 | base::ScopedTempDir scoped_temp_dir; |
| 669 | ASSERT_TRUE(scoped_temp_dir.CreateUniqueTempDir()); |
| 670 | base::FilePath pem_path = test_data_dir_.AppendASCII("service_worker") |
| 671 | .AppendASCII("update") |
| 672 | .AppendASCII("service_worker.pem"); |
vabr | 9142fe2 | 2016-09-08 13:19:22 | [diff] [blame] | 673 | base::FilePath path_v1 = |
| 674 | PackExtensionWithOptions(test_data_dir_.AppendASCII("service_worker") |
| 675 | .AppendASCII("update") |
| 676 | .AppendASCII("v1"), |
| 677 | scoped_temp_dir.GetPath().AppendASCII("v1.crx"), |
| 678 | pem_path, base::FilePath()); |
| 679 | base::FilePath path_v2 = |
| 680 | PackExtensionWithOptions(test_data_dir_.AppendASCII("service_worker") |
| 681 | .AppendASCII("update") |
| 682 | .AppendASCII("v2"), |
| 683 | scoped_temp_dir.GetPath().AppendASCII("v2.crx"), |
| 684 | pem_path, base::FilePath()); |
lazyboy | c3e763a | 2015-12-09 23:09:58 | [diff] [blame] | 685 | const char* kId = "hfaanndiiilofhfokeanhddpkfffchdi"; |
| 686 | |
| 687 | ExtensionTestMessageListener listener_v1("Pong from version 1", false); |
| 688 | listener_v1.set_failure_message("FAILURE_V1"); |
| 689 | // Install version 1.0 of the extension. |
| 690 | ASSERT_TRUE(InstallExtension(path_v1, 1)); |
| 691 | EXPECT_TRUE(extensions::ExtensionRegistry::Get(profile()) |
| 692 | ->enabled_extensions() |
| 693 | .GetByID(kId)); |
| 694 | EXPECT_TRUE(listener_v1.WaitUntilSatisfied()); |
| 695 | |
| 696 | ExtensionTestMessageListener listener_v2("Pong from version 2", false); |
| 697 | listener_v2.set_failure_message("FAILURE_V2"); |
| 698 | |
| 699 | // Update to version 2.0. |
| 700 | EXPECT_TRUE(UpdateExtension(kId, path_v2, 0)); |
| 701 | EXPECT_TRUE(extensions::ExtensionRegistry::Get(profile()) |
| 702 | ->enabled_extensions() |
| 703 | .GetByID(kId)); |
| 704 | EXPECT_TRUE(listener_v2.WaitUntilSatisfied()); |
| 705 | } |
| 706 | |
[email protected] | 2ef85d56 | 2017-09-15 18:41:52 | [diff] [blame] | 707 | // TODO(crbug.com/765736) Fix the test. |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 708 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, DISABLED_UpdateWithoutSkipWaiting) { |
Francois Doray | e6fb2d0 | 2017-10-18 21:29:13 | [diff] [blame] | 709 | base::ScopedAllowBlockingForTesting allow_blocking; |
lazyboy | 22eddc71 | 2015-12-10 21:16:26 | [diff] [blame] | 710 | base::ScopedTempDir scoped_temp_dir; |
| 711 | ASSERT_TRUE(scoped_temp_dir.CreateUniqueTempDir()); |
| 712 | base::FilePath pem_path = test_data_dir_.AppendASCII("service_worker") |
| 713 | .AppendASCII("update_without_skip_waiting") |
| 714 | .AppendASCII("update_without_skip_waiting.pem"); |
vabr | 9142fe2 | 2016-09-08 13:19:22 | [diff] [blame] | 715 | base::FilePath path_v1 = |
| 716 | PackExtensionWithOptions(test_data_dir_.AppendASCII("service_worker") |
| 717 | .AppendASCII("update_without_skip_waiting") |
| 718 | .AppendASCII("v1"), |
| 719 | scoped_temp_dir.GetPath().AppendASCII("v1.crx"), |
| 720 | pem_path, base::FilePath()); |
| 721 | base::FilePath path_v2 = |
| 722 | PackExtensionWithOptions(test_data_dir_.AppendASCII("service_worker") |
| 723 | .AppendASCII("update_without_skip_waiting") |
| 724 | .AppendASCII("v2"), |
| 725 | scoped_temp_dir.GetPath().AppendASCII("v2.crx"), |
| 726 | pem_path, base::FilePath()); |
lazyboy | 22eddc71 | 2015-12-10 21:16:26 | [diff] [blame] | 727 | const char* kId = "mhnnnflgagdakldgjpfcofkiocpdmogl"; |
| 728 | |
| 729 | // Install version 1.0 of the extension. |
| 730 | ASSERT_TRUE(InstallExtension(path_v1, 1)); |
| 731 | EXPECT_TRUE(extensions::ExtensionRegistry::Get(profile()) |
| 732 | ->enabled_extensions() |
| 733 | .GetByID(kId)); |
| 734 | const Extension* extension = extensions::ExtensionRegistry::Get(profile()) |
| 735 | ->enabled_extensions() |
| 736 | .GetByID(kId); |
| 737 | |
| 738 | ExtensionTestMessageListener listener1("Pong from version 1", false); |
| 739 | listener1.set_failure_message("FAILURE"); |
| 740 | content::WebContents* web_contents = |
| 741 | AddTab(browser(), extension->GetResourceURL("page.html")); |
| 742 | EXPECT_TRUE(listener1.WaitUntilSatisfied()); |
| 743 | |
| 744 | // Update to version 2.0. |
| 745 | EXPECT_TRUE(UpdateExtension(kId, path_v2, 0)); |
| 746 | EXPECT_TRUE(extensions::ExtensionRegistry::Get(profile()) |
| 747 | ->enabled_extensions() |
| 748 | .GetByID(kId)); |
| 749 | const Extension* extension_after_update = |
| 750 | extensions::ExtensionRegistry::Get(profile()) |
| 751 | ->enabled_extensions() |
| 752 | .GetByID(kId); |
| 753 | |
| 754 | // Service worker version 2 would be installed but it won't be controlling |
| 755 | // the extension page yet. |
| 756 | ExtensionTestMessageListener listener2("Pong from version 1", false); |
| 757 | listener2.set_failure_message("FAILURE"); |
| 758 | web_contents = |
| 759 | AddTab(browser(), extension_after_update->GetResourceURL("page.html")); |
| 760 | EXPECT_TRUE(listener2.WaitUntilSatisfied()); |
| 761 | |
| 762 | // Navigate the tab away from the extension page so that no clients are |
| 763 | // using the service worker. |
| 764 | // Note that just closing the tab with WebContentsDestroyedWatcher doesn't |
| 765 | // seem to be enough because it returns too early. |
| 766 | WebContentsLoadStopObserver navigate_away_observer(web_contents); |
| 767 | web_contents->GetController().LoadURL( |
| 768 | GURL(url::kAboutBlankURL), content::Referrer(), ui::PAGE_TRANSITION_TYPED, |
| 769 | std::string()); |
| 770 | navigate_away_observer.WaitForLoadStop(); |
| 771 | |
| 772 | // Now expect service worker version 2 to control the extension page. |
| 773 | ExtensionTestMessageListener listener3("Pong from version 2", false); |
| 774 | listener3.set_failure_message("FAILURE"); |
| 775 | web_contents = |
| 776 | AddTab(browser(), extension_after_update->GetResourceURL("page.html")); |
| 777 | EXPECT_TRUE(listener3.WaitUntilSatisfied()); |
| 778 | } |
| 779 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 780 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, FetchArbitraryPaths) { |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 781 | const Extension* extension = StartTestFromBackgroundPage("fetch.js"); |
annekao | 1db36fd | 2015-07-29 17:09:16 | [diff] [blame] | 782 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 783 | // Open some arbirary paths. Their contents should be what the service worker |
| 784 | // responds with, which in this case is the path of the fetch. |
| 785 | EXPECT_EQ( |
| 786 | "Caught a fetch for /index.html", |
| 787 | NavigateAndExtractInnerText(extension->GetResourceURL("index.html"))); |
| 788 | EXPECT_EQ("Caught a fetch for /path/to/other.html", |
| 789 | NavigateAndExtractInnerText( |
| 790 | extension->GetResourceURL("path/to/other.html"))); |
| 791 | EXPECT_EQ("Caught a fetch for /some/text/file.txt", |
| 792 | NavigateAndExtractInnerText( |
| 793 | extension->GetResourceURL("some/text/file.txt"))); |
| 794 | EXPECT_EQ("Caught a fetch for /no/file/extension", |
| 795 | NavigateAndExtractInnerText( |
| 796 | extension->GetResourceURL("no/file/extension"))); |
| 797 | EXPECT_EQ("Caught a fetch for /", |
| 798 | NavigateAndExtractInnerText(extension->GetResourceURL(""))); |
annekao | 1db36fd | 2015-07-29 17:09:16 | [diff] [blame] | 799 | } |
| 800 | |
Kenichi Ishibashi | 773b8297 | 2018-08-30 07:02:03 | [diff] [blame] | 801 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, |
| 802 | FetchExtensionResourceFromServiceWorker) { |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 803 | const Extension* extension = StartTestFromBackgroundPage("fetch_from_sw.js"); |
Kenichi Ishibashi | 773b8297 | 2018-08-30 07:02:03 | [diff] [blame] | 804 | ASSERT_TRUE(extension); |
| 805 | |
| 806 | // The service worker in this test tries to load 'hello.txt' via fetch() |
| 807 | // and sends back the content of the file, which should be 'hello'. |
| 808 | const char* kScript = R"( |
| 809 | let channel = new MessageChannel(); |
| 810 | test.waitForMessage(channel.port1).then(message => { |
| 811 | window.domAutomationController.send(message); |
| 812 | }); |
| 813 | test.registeredServiceWorker.postMessage( |
| 814 | {port: channel.port2}, [channel.port2]); |
| 815 | )"; |
| 816 | EXPECT_EQ("hello", ExecuteScriptInBackgroundPage(extension->id(), kScript)); |
| 817 | } |
| 818 | |
Kenichi Ishibashi | 09ee5e7 | 2018-11-27 07:12:38 | [diff] [blame] | 819 | // Tests that fetch() from service worker and network fallback |
| 820 | // go through webRequest.onBeforeRequest API. |
| 821 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, OnBeforeRequest) { |
| 822 | const Extension* extension = LoadExtensionWithFlags( |
| 823 | test_data_dir_.AppendASCII("service_worker/webrequest"), kFlagNone); |
| 824 | ASSERT_TRUE(extension); |
| 825 | ASSERT_TRUE(StartEmbeddedTestServer()); |
| 826 | |
| 827 | // Start a service worker and make it control the page. |
| 828 | GURL page_url = embedded_test_server()->GetURL( |
| 829 | "/extensions/api_test/service_worker/" |
| 830 | "webrequest/webpage.html"); |
| 831 | content::WebContents* web_contents = |
| 832 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 833 | ui_test_utils::NavigateToURL(browser(), page_url); |
| 834 | content::WaitForLoadStop(web_contents); |
| 835 | |
| 836 | std::string result; |
| 837 | ASSERT_TRUE(content::ExecuteScriptAndExtractString(web_contents, |
| 838 | "register();", &result)); |
| 839 | EXPECT_EQ("ready", result); |
| 840 | |
| 841 | // Initiate a fetch that the service worker doesn't intercept |
| 842 | // (network fallback). |
| 843 | result.clear(); |
| 844 | ASSERT_TRUE(content::ExecuteScriptAndExtractString( |
| 845 | web_contents, "doFetch('hello.txt?fallthrough');", &result)); |
| 846 | EXPECT_EQ("hello", result); |
| 847 | EXPECT_EQ( |
| 848 | "/extensions/api_test/service_worker/webrequest/hello.txt?fallthrough", |
| 849 | ExecuteScriptInBackgroundPage(extension->id(), "getLastHookedPath()")); |
| 850 | |
| 851 | // Initiate a fetch that results in calling fetch() in the service worker. |
| 852 | result.clear(); |
| 853 | ASSERT_TRUE(content::ExecuteScriptAndExtractString( |
| 854 | web_contents, "doFetch('hello.txt?respondWithFetch');", &result)); |
| 855 | EXPECT_EQ("hello", result); |
| 856 | EXPECT_EQ( |
| 857 | "/extensions/api_test/service_worker/webrequest/" |
| 858 | "hello.txt?respondWithFetch", |
| 859 | ExecuteScriptInBackgroundPage(extension->id(), "getLastHookedPath()")); |
| 860 | } |
| 861 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 862 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, SWServedBackgroundPageReceivesEvent) { |
lazyboy | 52c3bcf | 2016-01-08 00:11:29 | [diff] [blame] | 863 | const Extension* extension = |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 864 | StartTestFromBackgroundPage("replace_background.js"); |
lazyboy | 52c3bcf | 2016-01-08 00:11:29 | [diff] [blame] | 865 | ExtensionHost* background_page = |
| 866 | process_manager()->GetBackgroundHostForExtension(extension->id()); |
| 867 | ASSERT_TRUE(background_page); |
| 868 | |
| 869 | // Close the background page and start it again so that the service worker |
| 870 | // will start controlling pages. |
| 871 | background_page->Close(); |
| 872 | BackgroundPageWatcher(process_manager(), extension).WaitForClose(); |
| 873 | background_page = nullptr; |
Peter Kasting | 341e1fb | 2018-02-24 00:03:01 | [diff] [blame] | 874 | process_manager()->WakeEventPage(extension->id(), base::DoNothing()); |
lazyboy | 52c3bcf | 2016-01-08 00:11:29 | [diff] [blame] | 875 | BackgroundPageWatcher(process_manager(), extension).WaitForOpen(); |
| 876 | |
| 877 | // Since the SW is now controlling the extension, the SW serves the background |
| 878 | // script. page.html sends a message to the background script and we verify |
| 879 | // that the SW served background script correctly receives the message/event. |
| 880 | ExtensionTestMessageListener listener("onMessage/SW BG.", false); |
| 881 | listener.set_failure_message("onMessage/original BG."); |
| 882 | content::WebContents* web_contents = |
| 883 | AddTab(browser(), extension->GetResourceURL("page.html")); |
| 884 | ASSERT_TRUE(web_contents); |
| 885 | EXPECT_TRUE(listener.WaitUntilSatisfied()); |
| 886 | } |
| 887 | |
Matt Falkenhagen | a612fc0 | 2018-05-30 00:35:39 | [diff] [blame] | 888 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, SWServedBackgroundPage) { |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 889 | const Extension* extension = StartTestFromBackgroundPage("fetch.js"); |
annekao | 4924118 | 2015-08-18 17:14:01 | [diff] [blame] | 890 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 891 | std::string kExpectedInnerText = "background.html contents for testing."; |
annekao | 4924118 | 2015-08-18 17:14:01 | [diff] [blame] | 892 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 893 | // Sanity check that the background page has the expected content. |
| 894 | ExtensionHost* background_page = |
| 895 | process_manager()->GetBackgroundHostForExtension(extension->id()); |
| 896 | ASSERT_TRUE(background_page); |
| 897 | EXPECT_EQ(kExpectedInnerText, |
| 898 | ExtractInnerText(background_page->host_contents())); |
annekao | 4924118 | 2015-08-18 17:14:01 | [diff] [blame] | 899 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 900 | // Close the background page. |
| 901 | background_page->Close(); |
| 902 | BackgroundPageWatcher(process_manager(), extension).WaitForClose(); |
| 903 | background_page = nullptr; |
| 904 | |
| 905 | // Start it again. |
Peter Kasting | 341e1fb | 2018-02-24 00:03:01 | [diff] [blame] | 906 | process_manager()->WakeEventPage(extension->id(), base::DoNothing()); |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 907 | BackgroundPageWatcher(process_manager(), extension).WaitForOpen(); |
| 908 | |
Matt Falkenhagen | a612fc0 | 2018-05-30 00:35:39 | [diff] [blame] | 909 | // The service worker should get a fetch event for the background page. |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 910 | background_page = |
| 911 | process_manager()->GetBackgroundHostForExtension(extension->id()); |
| 912 | ASSERT_TRUE(background_page); |
| 913 | content::WaitForLoadStop(background_page->host_contents()); |
| 914 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 915 | EXPECT_EQ("Caught a fetch for /background.html", |
| 916 | ExtractInnerText(background_page->host_contents())); |
annekao | 4924118 | 2015-08-18 17:14:01 | [diff] [blame] | 917 | } |
| 918 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 919 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 920 | ServiceWorkerPostsMessageToBackgroundClient) { |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 921 | const Extension* extension = |
| 922 | StartTestFromBackgroundPage("post_message_to_background_client.js"); |
annekao | 53348222 | 2015-08-21 23:23:53 | [diff] [blame] | 923 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 924 | // The service worker in this test simply posts a message to the background |
| 925 | // client it receives from getBackgroundClient(). |
| 926 | const char* kScript = |
| 927 | "var messagePromise = null;\n" |
| 928 | "if (test.lastMessageFromServiceWorker) {\n" |
| 929 | " messagePromise = Promise.resolve(test.lastMessageFromServiceWorker);\n" |
| 930 | "} else {\n" |
| 931 | " messagePromise = test.waitForMessage(navigator.serviceWorker);\n" |
| 932 | "}\n" |
| 933 | "messagePromise.then(function(message) {\n" |
| 934 | " window.domAutomationController.send(String(message == 'success'));\n" |
| 935 | "})\n"; |
| 936 | EXPECT_EQ("true", ExecuteScriptInBackgroundPage(extension->id(), kScript)); |
annekao | 53348222 | 2015-08-21 23:23:53 | [diff] [blame] | 937 | } |
| 938 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 939 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 940 | BackgroundPagePostsMessageToServiceWorker) { |
| 941 | const Extension* extension = |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 942 | StartTestFromBackgroundPage("post_message_to_sw.js"); |
annekao | 53348222 | 2015-08-21 23:23:53 | [diff] [blame] | 943 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 944 | // The service worker in this test waits for a message, then echoes it back |
| 945 | // by posting a message to the background page via getBackgroundClient(). |
| 946 | const char* kScript = |
| 947 | "var mc = new MessageChannel();\n" |
| 948 | "test.waitForMessage(mc.port1).then(function(message) {\n" |
| 949 | " window.domAutomationController.send(String(message == 'hello'));\n" |
| 950 | "});\n" |
| 951 | "test.registeredServiceWorker.postMessage(\n" |
| 952 | " {message: 'hello', port: mc.port2}, [mc.port2])\n"; |
| 953 | EXPECT_EQ("true", ExecuteScriptInBackgroundPage(extension->id(), kScript)); |
annekao | 53348222 | 2015-08-21 23:23:53 | [diff] [blame] | 954 | } |
| 955 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 956 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 957 | ServiceWorkerSuspensionOnExtensionUnload) { |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 958 | // For this test, only hold onto the extension's ID and URL + a function to |
| 959 | // get a resource URL, because we're going to be disabling and uninstalling |
| 960 | // it, which will invalidate the pointer. |
| 961 | std::string extension_id; |
| 962 | GURL extension_url; |
| 963 | { |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 964 | const Extension* extension = StartTestFromBackgroundPage("fetch.js"); |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 965 | extension_id = extension->id(); |
| 966 | extension_url = extension->url(); |
| 967 | } |
| 968 | auto get_resource_url = [&extension_url](const std::string& path) { |
| 969 | return Extension::GetResourceURL(extension_url, path); |
| 970 | }; |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 971 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 972 | // Fetch should route to the service worker. |
| 973 | EXPECT_EQ("Caught a fetch for /index.html", |
| 974 | NavigateAndExtractInnerText(get_resource_url("index.html"))); |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 975 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 976 | // Disable the extension. Opening the page should fail. |
| 977 | extension_service()->DisableExtension(extension_id, |
Minh X. Nguyen | 4547901 | 2017-08-18 21:35:36 | [diff] [blame] | 978 | disable_reason::DISABLE_USER_ACTION); |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 979 | base::RunLoop().RunUntilIdle(); |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 980 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 981 | EXPECT_EQ(content::PAGE_TYPE_ERROR, |
| 982 | NavigateAndGetPageType(get_resource_url("index.html"))); |
| 983 | EXPECT_EQ(content::PAGE_TYPE_ERROR, |
| 984 | NavigateAndGetPageType(get_resource_url("other.html"))); |
| 985 | |
| 986 | // Re-enable the extension. Opening pages should immediately start to succeed |
| 987 | // again. |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 988 | extension_service()->EnableExtension(extension_id); |
| 989 | base::RunLoop().RunUntilIdle(); |
| 990 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 991 | EXPECT_EQ("Caught a fetch for /index.html", |
| 992 | NavigateAndExtractInnerText(get_resource_url("index.html"))); |
| 993 | EXPECT_EQ("Caught a fetch for /other.html", |
| 994 | NavigateAndExtractInnerText(get_resource_url("other.html"))); |
| 995 | EXPECT_EQ("Caught a fetch for /another.html", |
| 996 | NavigateAndExtractInnerText(get_resource_url("another.html"))); |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 997 | |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 998 | // Uninstall the extension. Opening pages should fail again. |
| 999 | base::string16 error; |
| 1000 | extension_service()->UninstallExtension( |
Devlin Cronin | 218df7f | 2017-11-21 21:41:31 | [diff] [blame] | 1001 | extension_id, UninstallReason::UNINSTALL_REASON_FOR_TESTING, &error); |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 1002 | base::RunLoop().RunUntilIdle(); |
| 1003 | |
| 1004 | EXPECT_EQ(content::PAGE_TYPE_ERROR, |
| 1005 | NavigateAndGetPageType(get_resource_url("index.html"))); |
| 1006 | EXPECT_EQ(content::PAGE_TYPE_ERROR, |
| 1007 | NavigateAndGetPageType(get_resource_url("other.html"))); |
| 1008 | EXPECT_EQ(content::PAGE_TYPE_ERROR, |
| 1009 | NavigateAndGetPageType(get_resource_url("anotherother.html"))); |
| 1010 | EXPECT_EQ(content::PAGE_TYPE_ERROR, |
| 1011 | NavigateAndGetPageType(get_resource_url("final.html"))); |
| 1012 | } |
| 1013 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1014 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, BackgroundPageIsWokenIfAsleep) { |
Istiaque Ahmed | 93ff7f4 | 2018-08-31 01:42:22 | [diff] [blame] | 1015 | const Extension* extension = StartTestFromBackgroundPage("wake_on_fetch.js"); |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 1016 | |
| 1017 | // Navigate to special URLs that this test's service worker recognises, each |
| 1018 | // making a check then populating the response with either "true" or "false". |
| 1019 | EXPECT_EQ("true", NavigateAndExtractInnerText(extension->GetResourceURL( |
| 1020 | "background-client-is-awake"))); |
| 1021 | EXPECT_EQ("true", NavigateAndExtractInnerText( |
| 1022 | extension->GetResourceURL("ping-background-client"))); |
| 1023 | // Ping more than once for good measure. |
| 1024 | EXPECT_EQ("true", NavigateAndExtractInnerText( |
| 1025 | extension->GetResourceURL("ping-background-client"))); |
| 1026 | |
| 1027 | // Shut down the event page. The SW should detect that it's closed, but still |
| 1028 | // be able to ping it. |
| 1029 | ExtensionHost* background_page = |
| 1030 | process_manager()->GetBackgroundHostForExtension(extension->id()); |
| 1031 | ASSERT_TRUE(background_page); |
| 1032 | background_page->Close(); |
| 1033 | BackgroundPageWatcher(process_manager(), extension).WaitForClose(); |
| 1034 | |
| 1035 | EXPECT_EQ("false", NavigateAndExtractInnerText(extension->GetResourceURL( |
| 1036 | "background-client-is-awake"))); |
| 1037 | EXPECT_EQ("true", NavigateAndExtractInnerText( |
| 1038 | extension->GetResourceURL("ping-background-client"))); |
| 1039 | EXPECT_EQ("true", NavigateAndExtractInnerText( |
| 1040 | extension->GetResourceURL("ping-background-client"))); |
| 1041 | EXPECT_EQ("true", NavigateAndExtractInnerText(extension->GetResourceURL( |
| 1042 | "background-client-is-awake"))); |
| 1043 | } |
| 1044 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1045 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, |
kalman | 6f984ae | 2015-09-18 17:21:58 | [diff] [blame] | 1046 | GetBackgroundClientFailsWithNoBackgroundPage) { |
| 1047 | // This extension doesn't have a background page, only a tab at page.html. |
| 1048 | // The service worker it registers tries to call getBackgroundClient() and |
| 1049 | // should fail. |
| 1050 | // Note that this also tests that service workers can be registered from tabs. |
| 1051 | EXPECT_TRUE(RunExtensionSubtest("service_worker/no_background", "page.html")); |
rdevlin.cronin | f5863da | 2015-09-10 19:21:45 | [diff] [blame] | 1052 | } |
| 1053 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1054 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, NotificationAPI) { |
lazyboy | 6ddb7d6 | 2015-11-10 23:15:27 | [diff] [blame] | 1055 | EXPECT_TRUE(RunExtensionSubtest("service_worker/notifications/has_permission", |
| 1056 | "page.html")); |
| 1057 | } |
| 1058 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1059 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, WebAccessibleResourcesFetch) { |
lazyboy | aea32c2 | 2016-01-04 21:37:07 | [diff] [blame] | 1060 | EXPECT_TRUE(RunExtensionSubtest( |
| 1061 | "service_worker/web_accessible_resources/fetch/", "page.html")); |
| 1062 | } |
| 1063 | |
Istiaque Ahmed | 75ad1d9 | 2018-08-30 05:16:54 | [diff] [blame] | 1064 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, TabsCreate) { |
lazyboy | ee4adef | 2016-05-24 00:55:16 | [diff] [blame] | 1065 | // Extensions APIs from SW are only enabled on trunk. |
| 1066 | ScopedCurrentChannel current_channel_override(version_info::Channel::UNKNOWN); |
| 1067 | const Extension* extension = LoadExtensionWithFlags( |
| 1068 | test_data_dir_.AppendASCII("service_worker/tabs_create"), kFlagNone); |
| 1069 | ASSERT_TRUE(extension); |
| 1070 | ui_test_utils::NavigateToURL(browser(), |
| 1071 | extension->GetResourceURL("page.html")); |
| 1072 | content::WebContents* web_contents = |
| 1073 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 1074 | |
| 1075 | int starting_tab_count = browser()->tab_strip_model()->count(); |
| 1076 | std::string result; |
| 1077 | ASSERT_TRUE(content::ExecuteScriptAndExtractString( |
| 1078 | web_contents, "window.runServiceWorker()", &result)); |
| 1079 | ASSERT_EQ("chrome.tabs.create callback", result); |
| 1080 | EXPECT_EQ(starting_tab_count + 1, browser()->tab_strip_model()->count()); |
| 1081 | |
| 1082 | // Check extension shutdown path. |
| 1083 | UnloadExtension(extension->id()); |
| 1084 | EXPECT_EQ(starting_tab_count, browser()->tab_strip_model()->count()); |
| 1085 | } |
| 1086 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1087 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, Events) { |
lazyboy | e784724 | 2017-06-07 23:29:18 | [diff] [blame] | 1088 | // Extensions APIs from SW are only enabled on trunk. |
| 1089 | ScopedCurrentChannel current_channel_override(version_info::Channel::UNKNOWN); |
| 1090 | const Extension* extension = LoadExtensionWithFlags( |
| 1091 | test_data_dir_.AppendASCII("service_worker/events"), kFlagNone); |
| 1092 | ASSERT_TRUE(extension); |
| 1093 | ui_test_utils::NavigateToURL(browser(), |
| 1094 | extension->GetResourceURL("page.html")); |
| 1095 | content::WebContents* web_contents = |
| 1096 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 1097 | std::string result; |
| 1098 | ASSERT_TRUE(content::ExecuteScriptAndExtractString( |
| 1099 | web_contents, "window.runEventTest()", &result)); |
| 1100 | ASSERT_EQ("chrome.tabs.onUpdated callback", result); |
| 1101 | } |
| 1102 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1103 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, EventsToStoppedWorker) { |
lazyboy | 63b994a | 2017-06-30 21:20:23 | [diff] [blame] | 1104 | // Extensions APIs from SW are only enabled on trunk. |
| 1105 | ScopedCurrentChannel current_channel_override(version_info::Channel::UNKNOWN); |
| 1106 | const Extension* extension = LoadExtensionWithFlags( |
| 1107 | test_data_dir_.AppendASCII("service_worker/events_to_stopped_worker"), |
| 1108 | kFlagNone); |
| 1109 | ASSERT_TRUE(extension); |
| 1110 | ui_test_utils::NavigateToURL(browser(), |
| 1111 | extension->GetResourceURL("page.html")); |
| 1112 | content::WebContents* web_contents = |
| 1113 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 1114 | { |
| 1115 | std::string result; |
| 1116 | ASSERT_TRUE(content::ExecuteScriptAndExtractString( |
| 1117 | web_contents, "window.runServiceWorker()", &result)); |
| 1118 | ASSERT_EQ("ready", result); |
| 1119 | |
| 1120 | base::RunLoop run_loop; |
| 1121 | content::StoragePartition* storage_partition = |
| 1122 | content::BrowserContext::GetDefaultStoragePartition( |
| 1123 | browser()->profile()); |
Zhuoyu Qian | 2266251f | 2018-10-13 02:59:00 | [diff] [blame] | 1124 | content::StopServiceWorkerForScope( |
lazyboy | 63b994a | 2017-06-30 21:20:23 | [diff] [blame] | 1125 | storage_partition->GetServiceWorkerContext(), |
| 1126 | // The service worker is registered at the top level scope. |
| 1127 | extension->url(), run_loop.QuitClosure()); |
| 1128 | run_loop.Run(); |
| 1129 | } |
| 1130 | |
| 1131 | std::string result; |
| 1132 | ASSERT_TRUE(content::ExecuteScriptAndExtractString( |
| 1133 | web_contents, "window.createTabThenUpdate()", &result)); |
| 1134 | ASSERT_EQ("chrome.tabs.onUpdated callback", result); |
| 1135 | } |
| 1136 | |
Istiaque Ahmed | 805f6a83b | 2017-10-05 01:23:26 | [diff] [blame] | 1137 | // Tests that events to service worker arrives correctly event if the owner |
| 1138 | // extension of the worker is not running. |
| 1139 | IN_PROC_BROWSER_TEST_P(ServiceWorkerLazyBackgroundTest, |
Istiaque Ahmed | b8e24bdb | 2018-09-13 15:17:25 | [diff] [blame] | 1140 | EventsToStoppedExtension) { |
Istiaque Ahmed | 805f6a83b | 2017-10-05 01:23:26 | [diff] [blame] | 1141 | LazyBackgroundObserver lazy_observer; |
| 1142 | ResultCatcher catcher; |
| 1143 | const Extension* extension = LoadExtensionWithFlags( |
| 1144 | test_data_dir_.AppendASCII("service_worker/events_to_stopped_extension"), |
| 1145 | kFlagNone); |
| 1146 | ASSERT_TRUE(extension); |
| 1147 | EXPECT_TRUE(catcher.GetNextResult()) << catcher.message(); |
| 1148 | |
| 1149 | ProcessManager* pm = ProcessManager::Get(browser()->profile()); |
| 1150 | EXPECT_GT(pm->GetLazyKeepaliveCount(extension), 0); |
David Bertoni | 3e1e9fa | 2018-08-29 20:39:30 | [diff] [blame] | 1151 | EXPECT_FALSE(pm->GetLazyKeepaliveActivities(extension).empty()); |
Istiaque Ahmed | 805f6a83b | 2017-10-05 01:23:26 | [diff] [blame] | 1152 | |
| 1153 | // |extension|'s background page opens a tab to its resource. |
| 1154 | content::WebContents* extension_web_contents = |
| 1155 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 1156 | EXPECT_TRUE(content::WaitForLoadStop(extension_web_contents)); |
| 1157 | EXPECT_EQ(extension->GetResourceURL("page.html").spec(), |
| 1158 | extension_web_contents->GetURL().spec()); |
| 1159 | { |
| 1160 | // Let the service worker start and register a listener to |
| 1161 | // chrome.tabs.onCreated event. |
| 1162 | ExtensionTestMessageListener add_listener_done("listener-added", false); |
| 1163 | content::ExecuteScriptAsync(extension_web_contents, |
| 1164 | "window.runServiceWorkerAsync()"); |
| 1165 | EXPECT_TRUE(add_listener_done.WaitUntilSatisfied()); |
| 1166 | |
| 1167 | base::RunLoop run_loop; |
| 1168 | content::StoragePartition* storage_partition = |
| 1169 | content::BrowserContext::GetDefaultStoragePartition( |
| 1170 | browser()->profile()); |
Zhuoyu Qian | 2266251f | 2018-10-13 02:59:00 | [diff] [blame] | 1171 | content::StopServiceWorkerForScope( |
Istiaque Ahmed | 805f6a83b | 2017-10-05 01:23:26 | [diff] [blame] | 1172 | storage_partition->GetServiceWorkerContext(), |
| 1173 | // The service worker is registered at the top level scope. |
| 1174 | extension->url(), run_loop.QuitClosure()); |
| 1175 | run_loop.Run(); |
| 1176 | } |
| 1177 | |
| 1178 | // Close the tab to |extension|'s resource. This will also close the |
| 1179 | // extension's event page. |
| 1180 | browser()->tab_strip_model()->CloseWebContentsAt( |
| 1181 | browser()->tab_strip_model()->active_index(), TabStripModel::CLOSE_NONE); |
| 1182 | lazy_observer.Wait(); |
| 1183 | |
| 1184 | // At this point both the extension worker and extension event page is not |
| 1185 | // running. Since the worker registered a listener for tabs.onCreated, it |
| 1186 | // will be started to dispatch the event once we create a tab. |
| 1187 | ExtensionTestMessageListener newtab_listener("hello-newtab", false); |
| 1188 | newtab_listener.set_failure_message("WRONG_NEWTAB"); |
| 1189 | content::WebContents* new_web_contents = |
Istiaque Ahmed | 7105f2a | 2017-10-07 01:11:59 | [diff] [blame] | 1190 | AddTab(browser(), GURL(url::kAboutBlankURL)); |
| 1191 | EXPECT_TRUE(new_web_contents); |
| 1192 | EXPECT_TRUE(newtab_listener.WaitUntilSatisfied()); |
| 1193 | } |
| 1194 | |
| 1195 | // Tests that events to service worker correctly after browser restart. |
| 1196 | // This test is similar to EventsToStoppedExtension, except that the event |
| 1197 | // delivery is verified after a browser restart. |
| 1198 | IN_PROC_BROWSER_TEST_P(ServiceWorkerLazyBackgroundTest, |
| 1199 | PRE_EventsAfterRestart) { |
| 1200 | LazyBackgroundObserver lazy_observer; |
| 1201 | ResultCatcher catcher; |
| 1202 | const Extension* extension = LoadExtensionWithFlags( |
| 1203 | test_data_dir_.AppendASCII("service_worker/events_to_stopped_extension"), |
| 1204 | kFlagNone); |
| 1205 | ASSERT_TRUE(extension); |
| 1206 | EXPECT_TRUE(catcher.GetNextResult()) << catcher.message(); |
| 1207 | |
| 1208 | ProcessManager* pm = ProcessManager::Get(browser()->profile()); |
| 1209 | EXPECT_GT(pm->GetLazyKeepaliveCount(extension), 0); |
David Bertoni | 3e1e9fa | 2018-08-29 20:39:30 | [diff] [blame] | 1210 | EXPECT_FALSE(pm->GetLazyKeepaliveActivities(extension).empty()); |
Istiaque Ahmed | 7105f2a | 2017-10-07 01:11:59 | [diff] [blame] | 1211 | |
| 1212 | // |extension|'s background page opens a tab to its resource. |
| 1213 | content::WebContents* extension_web_contents = |
| 1214 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 1215 | EXPECT_TRUE(content::WaitForLoadStop(extension_web_contents)); |
| 1216 | EXPECT_EQ(extension->GetResourceURL("page.html").spec(), |
| 1217 | extension_web_contents->GetURL().spec()); |
| 1218 | { |
| 1219 | // Let the service worker start and register a listener to |
| 1220 | // chrome.tabs.onCreated event. |
| 1221 | ExtensionTestMessageListener add_listener_done("listener-added", false); |
| 1222 | content::ExecuteScriptAsync(extension_web_contents, |
| 1223 | "window.runServiceWorkerAsync()"); |
| 1224 | EXPECT_TRUE(add_listener_done.WaitUntilSatisfied()); |
| 1225 | |
| 1226 | base::RunLoop run_loop; |
| 1227 | content::StoragePartition* storage_partition = |
| 1228 | content::BrowserContext::GetDefaultStoragePartition( |
| 1229 | browser()->profile()); |
Zhuoyu Qian | 2266251f | 2018-10-13 02:59:00 | [diff] [blame] | 1230 | content::StopServiceWorkerForScope( |
Istiaque Ahmed | 7105f2a | 2017-10-07 01:11:59 | [diff] [blame] | 1231 | storage_partition->GetServiceWorkerContext(), |
| 1232 | // The service worker is registered at the top level scope. |
| 1233 | extension->url(), run_loop.QuitClosure()); |
| 1234 | run_loop.Run(); |
| 1235 | } |
| 1236 | |
| 1237 | // Close the tab to |extension|'s resource. This will also close the |
| 1238 | // extension's event page. |
| 1239 | browser()->tab_strip_model()->CloseWebContentsAt( |
| 1240 | browser()->tab_strip_model()->active_index(), TabStripModel::CLOSE_NONE); |
| 1241 | lazy_observer.Wait(); |
| 1242 | } |
| 1243 | |
Istiaque Ahmed | 99aa96d | 2018-09-13 23:22:08 | [diff] [blame] | 1244 | IN_PROC_BROWSER_TEST_P(ServiceWorkerLazyBackgroundTest, EventsAfterRestart) { |
Istiaque Ahmed | 7105f2a | 2017-10-07 01:11:59 | [diff] [blame] | 1245 | ExtensionTestMessageListener newtab_listener("hello-newtab", false); |
| 1246 | content::WebContents* new_web_contents = |
| 1247 | AddTab(browser(), GURL(url::kAboutBlankURL)); |
Istiaque Ahmed | 805f6a83b | 2017-10-05 01:23:26 | [diff] [blame] | 1248 | EXPECT_TRUE(new_web_contents); |
| 1249 | EXPECT_TRUE(newtab_listener.WaitUntilSatisfied()); |
| 1250 | } |
| 1251 | |
lazyboy | 4c82177a | 2016-10-18 00:04:09 | [diff] [blame] | 1252 | // Tests that worker ref count increments while extension API function is |
| 1253 | // active. |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1254 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, WorkerRefCount) { |
lazyboy | 4c82177a | 2016-10-18 00:04:09 | [diff] [blame] | 1255 | // Extensions APIs from SW are only enabled on trunk. |
| 1256 | ScopedCurrentChannel current_channel_override(version_info::Channel::UNKNOWN); |
| 1257 | const Extension* extension = LoadExtensionWithFlags( |
| 1258 | test_data_dir_.AppendASCII("service_worker/api_worker_ref_count"), |
| 1259 | kFlagNone); |
| 1260 | ASSERT_TRUE(extension); |
| 1261 | ui_test_utils::NavigateToURL(browser(), |
| 1262 | extension->GetResourceURL("page.html")); |
| 1263 | content::WebContents* web_contents = |
| 1264 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 1265 | |
| 1266 | ExtensionTestMessageListener worker_start_listener("WORKER STARTED", false); |
| 1267 | worker_start_listener.set_failure_message("FAILURE"); |
| 1268 | ASSERT_TRUE( |
| 1269 | content::ExecuteScript(web_contents, "window.runServiceWorker()")); |
| 1270 | ASSERT_TRUE(worker_start_listener.WaitUntilSatisfied()); |
| 1271 | |
| 1272 | // Service worker should have no pending requests because it hasn't peformed |
| 1273 | // any extension API request yet. |
| 1274 | EXPECT_EQ(0u, GetWorkerRefCount(extension->url())); |
| 1275 | |
| 1276 | ExtensionTestMessageListener worker_listener("CHECK_REF_COUNT", true); |
| 1277 | worker_listener.set_failure_message("FAILURE"); |
| 1278 | ASSERT_TRUE(content::ExecuteScript(web_contents, "window.testSendMessage()")); |
| 1279 | ASSERT_TRUE(worker_listener.WaitUntilSatisfied()); |
| 1280 | |
| 1281 | // Service worker should have exactly one pending request because |
| 1282 | // chrome.test.sendMessage() API call is in-flight. |
| 1283 | EXPECT_EQ(1u, GetWorkerRefCount(extension->url())); |
| 1284 | |
| 1285 | // Peform another extension API request while one is ongoing. |
| 1286 | { |
| 1287 | ExtensionTestMessageListener listener("CHECK_REF_COUNT", true); |
| 1288 | listener.set_failure_message("FAILURE"); |
| 1289 | ASSERT_TRUE( |
| 1290 | content::ExecuteScript(web_contents, "window.testSendMessage()")); |
| 1291 | ASSERT_TRUE(listener.WaitUntilSatisfied()); |
| 1292 | |
| 1293 | // Service worker currently has two extension API requests in-flight. |
| 1294 | EXPECT_EQ(2u, GetWorkerRefCount(extension->url())); |
| 1295 | // Finish executing the nested chrome.test.sendMessage() first. |
| 1296 | listener.Reply("Hello world"); |
| 1297 | } |
| 1298 | |
Istiaque Ahmed | b57c975 | 2017-08-20 19:08:57 | [diff] [blame] | 1299 | ExtensionTestMessageListener worker_completion_listener("SUCCESS_FROM_WORKER", |
| 1300 | false); |
lazyboy | 4c82177a | 2016-10-18 00:04:09 | [diff] [blame] | 1301 | // Finish executing chrome.test.sendMessage(). |
| 1302 | worker_listener.Reply("Hello world"); |
Istiaque Ahmed | b57c975 | 2017-08-20 19:08:57 | [diff] [blame] | 1303 | EXPECT_TRUE(worker_completion_listener.WaitUntilSatisfied()); |
| 1304 | |
| 1305 | // The following block makes sure we have received all the IPCs related to |
| 1306 | // ref-count from the worker. |
| 1307 | { |
| 1308 | // The following roundtrip: |
| 1309 | // browser->extension->worker->extension->browser |
| 1310 | // will ensure that the worker sent the relevant ref count IPCs. |
| 1311 | std::string result; |
| 1312 | EXPECT_TRUE(content::ExecuteScriptAndExtractString( |
| 1313 | web_contents, "window.roundtripToWorker();", &result)); |
| 1314 | EXPECT_EQ("roundtrip-succeeded", result); |
| 1315 | |
| 1316 | // Ensure IO thread IPCs run. |
Gabriel Charette | 01507a2 | 2017-09-27 21:30:08 | [diff] [blame] | 1317 | content::RunAllTasksUntilIdle(); |
Istiaque Ahmed | b57c975 | 2017-08-20 19:08:57 | [diff] [blame] | 1318 | } |
lazyboy | 4c82177a | 2016-10-18 00:04:09 | [diff] [blame] | 1319 | |
| 1320 | // The ref count should drop to 0. |
| 1321 | EXPECT_EQ(0u, GetWorkerRefCount(extension->url())); |
| 1322 | } |
| 1323 | |
lazyboy | aea32c2 | 2016-01-04 21:37:07 | [diff] [blame] | 1324 | // This test loads a web page that has an iframe pointing to a |
| 1325 | // chrome-extension:// URL. The URL is listed in the extension's |
| 1326 | // web_accessible_resources. Initially the iframe is served from the extension's |
| 1327 | // resource file. After verifying that, we register a Service Worker that |
| 1328 | // controls the extension. Further requests to the same resource as before |
| 1329 | // should now be served by the Service Worker. |
| 1330 | // This test also verifies that if the requested resource exists in the manifest |
| 1331 | // but is not present in the extension directory, the Service Worker can still |
| 1332 | // serve the resource file. |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1333 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, WebAccessibleResourcesIframeSrc) { |
lazyboy | aea32c2 | 2016-01-04 21:37:07 | [diff] [blame] | 1334 | const Extension* extension = LoadExtensionWithFlags( |
| 1335 | test_data_dir_.AppendASCII( |
| 1336 | "service_worker/web_accessible_resources/iframe_src"), |
| 1337 | kFlagNone); |
| 1338 | ASSERT_TRUE(extension); |
| 1339 | ASSERT_TRUE(StartEmbeddedTestServer()); |
falken | ad18509 | 2016-06-16 06:10:02 | [diff] [blame] | 1340 | |
| 1341 | // Service workers can only control secure contexts |
| 1342 | // (https://w3c.github.io/webappsec-secure-contexts/). For documents, this |
| 1343 | // typically means the document must have a secure origin AND all its ancestor |
| 1344 | // frames must have documents with secure origins. However, extension pages |
| 1345 | // are considered secure, even if they have an ancestor document that is an |
| 1346 | // insecure context (see GetSchemesBypassingSecureContextCheckWhitelist). So |
| 1347 | // extension service workers must be able to control an extension page |
| 1348 | // embedded in an insecure context. To test this, set up an insecure |
| 1349 | // (non-localhost, non-https) URL for the web page. This page will create |
| 1350 | // iframes that load extension pages that must be controllable by service |
| 1351 | // worker. |
falken | ad18509 | 2016-06-16 06:10:02 | [diff] [blame] | 1352 | GURL page_url = |
| 1353 | embedded_test_server()->GetURL("a.com", |
| 1354 | "/extensions/api_test/service_worker/" |
| 1355 | "web_accessible_resources/webpage.html"); |
| 1356 | EXPECT_FALSE(content::IsOriginSecure(page_url)); |
lazyboy | aea32c2 | 2016-01-04 21:37:07 | [diff] [blame] | 1357 | |
| 1358 | content::WebContents* web_contents = AddTab(browser(), page_url); |
| 1359 | std::string result; |
| 1360 | // webpage.html will create an iframe pointing to a resource from |extension|. |
| 1361 | // Expect the resource to be served by the extension. |
| 1362 | EXPECT_TRUE(content::ExecuteScriptAndExtractString( |
| 1363 | web_contents, base::StringPrintf("window.testIframe('%s', 'iframe.html')", |
| 1364 | extension->id().c_str()), |
| 1365 | &result)); |
| 1366 | EXPECT_EQ("FROM_EXTENSION_RESOURCE", result); |
| 1367 | |
| 1368 | ExtensionTestMessageListener service_worker_ready_listener("SW_READY", false); |
| 1369 | EXPECT_TRUE(ExecuteScriptInBackgroundPageNoWait( |
| 1370 | extension->id(), "window.registerServiceWorker()")); |
| 1371 | EXPECT_TRUE(service_worker_ready_listener.WaitUntilSatisfied()); |
| 1372 | |
| 1373 | result.clear(); |
| 1374 | // webpage.html will create another iframe pointing to a resource from |
| 1375 | // |extension| as before. But this time, the resource should be be served |
| 1376 | // from the Service Worker. |
| 1377 | EXPECT_TRUE(content::ExecuteScriptAndExtractString( |
| 1378 | web_contents, base::StringPrintf("window.testIframe('%s', 'iframe.html')", |
| 1379 | extension->id().c_str()), |
| 1380 | &result)); |
| 1381 | EXPECT_EQ("FROM_SW_RESOURCE", result); |
| 1382 | |
| 1383 | result.clear(); |
| 1384 | // webpage.html will create yet another iframe pointing to a resource that |
| 1385 | // exists in the extension manifest's web_accessible_resources, but is not |
| 1386 | // present in the extension directory. Expect the resources of the iframe to |
| 1387 | // be served by the Service Worker. |
| 1388 | EXPECT_TRUE(content::ExecuteScriptAndExtractString( |
| 1389 | web_contents, |
| 1390 | base::StringPrintf("window.testIframe('%s', 'iframe_non_existent.html')", |
| 1391 | extension->id().c_str()), |
| 1392 | &result)); |
| 1393 | EXPECT_EQ("FROM_SW_RESOURCE", result); |
| 1394 | } |
| 1395 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1396 | IN_PROC_BROWSER_TEST_P(ServiceWorkerBackgroundSyncTest, Sync) { |
lazyboy | bd325ae | 2015-11-18 21:35:26 | [diff] [blame] | 1397 | const Extension* extension = LoadExtensionWithFlags( |
| 1398 | test_data_dir_.AppendASCII("service_worker/sync"), kFlagNone); |
| 1399 | ASSERT_TRUE(extension); |
| 1400 | ui_test_utils::NavigateToURL(browser(), |
| 1401 | extension->GetResourceURL("page.html")); |
| 1402 | content::WebContents* web_contents = |
| 1403 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 1404 | |
| 1405 | // Prevent firing by going offline. |
| 1406 | content::background_sync_test_util::SetOnline(web_contents, false); |
| 1407 | |
| 1408 | ExtensionTestMessageListener sync_listener("SYNC: send-chats", false); |
| 1409 | sync_listener.set_failure_message("FAIL"); |
| 1410 | |
| 1411 | std::string result; |
| 1412 | ASSERT_TRUE(content::ExecuteScriptAndExtractString( |
| 1413 | web_contents, "window.runServiceWorker()", &result)); |
| 1414 | ASSERT_EQ("SERVICE_WORKER_READY", result); |
| 1415 | |
| 1416 | EXPECT_FALSE(sync_listener.was_satisfied()); |
| 1417 | // Resume firing by going online. |
| 1418 | content::background_sync_test_util::SetOnline(web_contents, true); |
| 1419 | EXPECT_TRUE(sync_listener.WaitUntilSatisfied()); |
| 1420 | } |
| 1421 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1422 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, |
horo | 1eeddde | 2015-11-19 05:59:25 | [diff] [blame] | 1423 | FetchFromContentScriptShouldNotGoToServiceWorkerOfPage) { |
| 1424 | ASSERT_TRUE(StartEmbeddedTestServer()); |
| 1425 | GURL page_url = embedded_test_server()->GetURL( |
| 1426 | "/extensions/api_test/service_worker/content_script_fetch/" |
| 1427 | "controlled_page/index.html"); |
| 1428 | content::WebContents* tab = |
| 1429 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 1430 | ui_test_utils::NavigateToURL(browser(), page_url); |
| 1431 | content::WaitForLoadStop(tab); |
| 1432 | |
| 1433 | std::string value; |
| 1434 | ASSERT_TRUE( |
| 1435 | content::ExecuteScriptAndExtractString(tab, "register();", &value)); |
| 1436 | EXPECT_EQ("SW controlled", value); |
| 1437 | |
| 1438 | ASSERT_TRUE(RunExtensionTest("service_worker/content_script_fetch")) |
| 1439 | << message_; |
| 1440 | } |
| 1441 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1442 | IN_PROC_BROWSER_TEST_P(ServiceWorkerPushMessagingTest, OnPush) { |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 1443 | const Extension* extension = LoadExtensionWithFlags( |
| 1444 | test_data_dir_.AppendASCII("service_worker/push_messaging"), kFlagNone); |
| 1445 | ASSERT_TRUE(extension); |
| 1446 | GURL extension_url = extension->url(); |
| 1447 | |
Peter Beverloo | dd4ef1e | 2018-06-21 15:41:04 | [diff] [blame] | 1448 | GrantNotificationPermissionForTest(extension_url); |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 1449 | |
| 1450 | GURL url = extension->GetResourceURL("page.html"); |
| 1451 | ui_test_utils::NavigateToURL(browser(), url); |
| 1452 | |
| 1453 | content::WebContents* web_contents = |
| 1454 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 1455 | |
| 1456 | // Start the ServiceWorker. |
| 1457 | ExtensionTestMessageListener ready_listener("SERVICE_WORKER_READY", false); |
| 1458 | ready_listener.set_failure_message("SERVICE_WORKER_FAILURE"); |
| 1459 | const char* kScript = "window.runServiceWorker()"; |
| 1460 | EXPECT_TRUE(content::ExecuteScript(web_contents->GetMainFrame(), kScript)); |
| 1461 | EXPECT_TRUE(ready_listener.WaitUntilSatisfied()); |
| 1462 | |
| 1463 | PushMessagingAppIdentifier app_identifier = |
| 1464 | GetAppIdentifierForServiceWorkerRegistration(0LL, extension_url); |
johnme | a504573 | 2016-09-08 17:23:29 | [diff] [blame] | 1465 | ASSERT_EQ(app_identifier.app_id(), gcm_driver()->last_gettoken_app_id()); |
| 1466 | EXPECT_EQ("1234567890", gcm_driver()->last_gettoken_authorized_entity()); |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 1467 | |
lazyboy | d429e258 | 2016-05-20 20:18:52 | [diff] [blame] | 1468 | base::RunLoop run_loop; |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 1469 | // Send a push message via gcm and expect the ServiceWorker to receive it. |
| 1470 | ExtensionTestMessageListener push_message_listener("OK", false); |
| 1471 | push_message_listener.set_failure_message("FAIL"); |
| 1472 | gcm::IncomingMessage message; |
| 1473 | message.sender_id = "1234567890"; |
| 1474 | message.raw_data = "testdata"; |
| 1475 | message.decrypted = true; |
lazyboy | d429e258 | 2016-05-20 20:18:52 | [diff] [blame] | 1476 | push_service()->SetMessageCallbackForTesting(run_loop.QuitClosure()); |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 1477 | push_service()->OnMessage(app_identifier.app_id(), message); |
| 1478 | EXPECT_TRUE(push_message_listener.WaitUntilSatisfied()); |
lazyboy | d429e258 | 2016-05-20 20:18:52 | [diff] [blame] | 1479 | run_loop.Run(); // Wait until the message is handled by push service. |
lazyboy | 561b7de | 2015-11-19 19:27:30 | [diff] [blame] | 1480 | } |
| 1481 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1482 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, FilteredEvents) { |
Istiaque Ahmed | 9d166618 | 2017-09-21 23:58:18 | [diff] [blame] | 1483 | // Extensions APIs from SW are only enabled on trunk. |
| 1484 | ScopedCurrentChannel current_channel_override(version_info::Channel::UNKNOWN); |
| 1485 | ASSERT_TRUE(RunExtensionTest("service_worker/filtered_events")); |
| 1486 | } |
| 1487 | |
Rob Wu | e89b9003 | 2018-02-16 19:46:08 | [diff] [blame] | 1488 | IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, MimeHandlerView) { |
| 1489 | ASSERT_TRUE(RunExtensionTest("service_worker/mime_handler_view")); |
| 1490 | } |
| 1491 | |
Istiaque Ahmed | 9ce21b3 | 2017-10-10 20:43:18 | [diff] [blame] | 1492 | IN_PROC_BROWSER_TEST_P(ServiceWorkerLazyBackgroundTest, |
| 1493 | PRE_FilteredEventsAfterRestart) { |
| 1494 | LazyBackgroundObserver lazy_observer; |
| 1495 | ResultCatcher catcher; |
| 1496 | const Extension* extension = LoadExtensionWithFlags( |
| 1497 | test_data_dir_.AppendASCII( |
| 1498 | "service_worker/filtered_events_after_restart"), |
| 1499 | kFlagNone); |
| 1500 | ASSERT_TRUE(extension); |
| 1501 | EXPECT_TRUE(catcher.GetNextResult()) << catcher.message(); |
| 1502 | |
| 1503 | // |extension|'s background page opens a tab to its resource. |
| 1504 | content::WebContents* extension_web_contents = |
| 1505 | browser()->tab_strip_model()->GetActiveWebContents(); |
| 1506 | EXPECT_TRUE(content::WaitForLoadStop(extension_web_contents)); |
| 1507 | EXPECT_EQ(extension->GetResourceURL("page.html").spec(), |
| 1508 | extension_web_contents->GetURL().spec()); |
| 1509 | { |
| 1510 | // Let the service worker start and register a filtered listener to |
| 1511 | // chrome.webNavigation.onCommitted event. |
| 1512 | ExtensionTestMessageListener add_listener_done("listener-added", false); |
| 1513 | add_listener_done.set_failure_message("FAILURE"); |
| 1514 | content::ExecuteScriptAsync(extension_web_contents, |
| 1515 | "window.runServiceWorkerAsync()"); |
| 1516 | EXPECT_TRUE(add_listener_done.WaitUntilSatisfied()); |
| 1517 | |
| 1518 | base::RunLoop run_loop; |
| 1519 | content::StoragePartition* storage_partition = |
| 1520 | content::BrowserContext::GetDefaultStoragePartition( |
| 1521 | browser()->profile()); |
Zhuoyu Qian | 2266251f | 2018-10-13 02:59:00 | [diff] [blame] | 1522 | content::StopServiceWorkerForScope( |
Istiaque Ahmed | 9ce21b3 | 2017-10-10 20:43:18 | [diff] [blame] | 1523 | storage_partition->GetServiceWorkerContext(), |
| 1524 | // The service worker is registered at the top level scope. |
| 1525 | extension->url(), run_loop.QuitClosure()); |
| 1526 | run_loop.Run(); |
| 1527 | } |
| 1528 | |
| 1529 | // Close the tab to |extension|'s resource. This will also close the |
| 1530 | // extension's event page. |
| 1531 | browser()->tab_strip_model()->CloseWebContentsAt( |
| 1532 | browser()->tab_strip_model()->active_index(), TabStripModel::CLOSE_NONE); |
| 1533 | lazy_observer.Wait(); |
| 1534 | } |
| 1535 | |
| 1536 | IN_PROC_BROWSER_TEST_P(ServiceWorkerLazyBackgroundTest, |
Istiaque Ahmed | f571252 | 2018-09-20 03:35:47 | [diff] [blame] | 1537 | FilteredEventsAfterRestart) { |
Istiaque Ahmed | 9ce21b3 | 2017-10-10 20:43:18 | [diff] [blame] | 1538 | // Create a tab to a.html, expect it to navigate to b.html. The service worker |
| 1539 | // will see two webNavigation.onCommitted events. |
| 1540 | ASSERT_TRUE(StartEmbeddedTestServer()); |
| 1541 | GURL page_url = embedded_test_server()->GetURL( |
| 1542 | "/extensions/api_test/service_worker/filtered_events_after_restart/" |
| 1543 | "a.html"); |
| 1544 | ExtensionTestMessageListener worker_filtered_event_listener( |
| 1545 | "PASS_FROM_WORKER", false); |
| 1546 | worker_filtered_event_listener.set_failure_message("FAIL_FROM_WORKER"); |
| 1547 | content::WebContents* web_contents = AddTab(browser(), page_url); |
| 1548 | EXPECT_TRUE(web_contents); |
| 1549 | EXPECT_TRUE(worker_filtered_event_listener.WaitUntilSatisfied()); |
| 1550 | } |
| 1551 | |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1552 | // Run with both native and JS-based bindings. This ensures that both stable |
| 1553 | // (JS) and experimental (native) phases work correctly with worker scripts |
| 1554 | // while we launch native bindings to stable. |
Victor Costan | 4a060e8 | 2019-01-28 18:25:34 | [diff] [blame] | 1555 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithNativeBindings, |
| 1556 | ServiceWorkerTest, |
| 1557 | ::testing::Values(NATIVE_BINDINGS)); |
| 1558 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithJSBindings, |
| 1559 | ServiceWorkerTest, |
| 1560 | ::testing::Values(JAVASCRIPT_BINDINGS)); |
| 1561 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerBackgroundSyncTestWithNativeBindings, |
| 1562 | ServiceWorkerBackgroundSyncTest, |
| 1563 | ::testing::Values(NATIVE_BINDINGS)); |
| 1564 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerBackgroundSyncTestWithJSBindings, |
| 1565 | ServiceWorkerBackgroundSyncTest, |
| 1566 | ::testing::Values(JAVASCRIPT_BINDINGS)); |
| 1567 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerPushMessagingTestWithNativeBindings, |
| 1568 | ServiceWorkerPushMessagingTest, |
| 1569 | ::testing::Values(NATIVE_BINDINGS)); |
| 1570 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerPushMessagingTestWithJSBindings, |
| 1571 | ServiceWorkerPushMessagingTest, |
| 1572 | ::testing::Values(JAVASCRIPT_BINDINGS)); |
| 1573 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerLazyBackgroundTestWithNativeBindings, |
| 1574 | ServiceWorkerLazyBackgroundTest, |
| 1575 | ::testing::Values(NATIVE_BINDINGS)); |
| 1576 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerLazyBackgroundTestWithJSBindings, |
| 1577 | ServiceWorkerLazyBackgroundTest, |
| 1578 | ::testing::Values(JAVASCRIPT_BINDINGS)); |
| 1579 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithNativeBindings, |
| 1580 | ServiceWorkerBasedBackgroundTest, |
| 1581 | ::testing::Values(NATIVE_BINDINGS)); |
| 1582 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithJSBindings, |
| 1583 | ServiceWorkerBasedBackgroundTest, |
| 1584 | ::testing::Values(JAVASCRIPT_BINDINGS)); |
| 1585 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithNativeBindings, |
| 1586 | ServiceWorkerOnStartupEventTest, |
| 1587 | ::testing::Values(NATIVE_BINDINGS)); |
| 1588 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithJSBindings, |
| 1589 | ServiceWorkerOnStartupEventTest, |
| 1590 | ::testing::Values(JAVASCRIPT_BINDINGS)); |
| 1591 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithNativeBindings, |
| 1592 | ServiceWorkerRegistrationAtStartupTest, |
| 1593 | ::testing::Values(NATIVE_BINDINGS)); |
| 1594 | INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithJSBindings, |
| 1595 | ServiceWorkerRegistrationAtStartupTest, |
| 1596 | ::testing::Values(JAVASCRIPT_BINDINGS)); |
Istiaque Ahmed | ea5ed504 | 2017-09-25 19:00:16 | [diff] [blame] | 1597 | |
annekao | 3868550 | 2015-07-14 17:46:39 | [diff] [blame] | 1598 | } // namespace extensions |