blob: 9dee8185fc80069ad12785fbcb5ca7f61fc1ada3 [file] [log] [blame]
annekao38685502015-07-14 17:46:391// 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
avia2f4804a2015-12-24 23:11:135#include <stdint.h>
6
Sylvain Defresne4fdc727fd2018-10-04 11:09:467#include "base/bind.h"
kalman6f984ae2015-09-18 17:21:588#include "base/bind_helpers.h"
Istiaque Ahmeda14ec482018-08-25 01:02:189#include "base/json/json_reader.h"
avia2f4804a2015-12-24 23:11:1310#include "base/macros.h"
Gabriel Charette078e3662017-08-28 22:59:0411#include "base/run_loop.h"
kalman6f984ae2015-09-18 17:21:5812#include "base/strings/stringprintf.h"
horo1eeddde2015-11-19 05:59:2513#include "base/strings/utf_string_conversions.h"
jam3f2d3932017-04-26 20:28:5114#include "base/threading/thread_restrictions.h"
Olga Sharonova3e13cd92018-02-08 16:43:5615#include "build/build_config.h"
annekao38685502015-07-14 17:46:3916#include "chrome/browser/extensions/extension_apitest.h"
rdevlin.croninf5863da2015-09-10 19:21:4517#include "chrome/browser/extensions/extension_service.h"
Istiaque Ahmed805f6a83b2017-10-05 01:23:2618#include "chrome/browser/extensions/lazy_background_page_test_util.h"
peter9f4490a2017-01-27 00:58:3619#include "chrome/browser/gcm/gcm_profile_service_factory.h"
miguelg9b502862017-04-24 18:13:5320#include "chrome/browser/notifications/notification_display_service_factory.h"
Peter Beverloodd4ef1e2018-06-21 15:41:0421#include "chrome/browser/notifications/notification_permission_context.h"
miguelg9b502862017-04-24 18:13:5322#include "chrome/browser/notifications/stub_notification_display_service.h"
lshang106c1772016-06-06 01:43:2323#include "chrome/browser/permissions/permission_manager.h"
timlohc6911802017-03-01 05:37:0324#include "chrome/browser/permissions/permission_result.h"
lazyboy561b7de2015-11-19 19:27:3025#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"
annekao1db36fd2015-07-29 17:09:1628#include "chrome/browser/ui/tabs/tab_strip_model.h"
Trent Apted4267b942017-10-27 03:25:3629#include "chrome/common/chrome_switches.h"
Istiaque Ahmeda14ec482018-08-25 01:02:1830#include "chrome/common/extensions/api/web_navigation.h"
rdevlin.croninf5863da2015-09-10 19:21:4531#include "chrome/test/base/ui_test_utils.h"
timloh9a180ad2017-02-20 07:15:2332#include "components/content_settings/core/common/content_settings_types.h"
Peter Beverloo34139462018-04-10 14:18:0633#include "components/gcm_driver/fake_gcm_profile_service.h"
johnmea5045732016-09-08 17:23:2934#include "components/gcm_driver/instance_id/fake_gcm_driver_for_instance_id.h"
sdefresne9fb67692015-08-03 18:48:2235#include "components/version_info/version_info.h"
kalman6f984ae2015-09-18 17:21:5836#include "content/public/browser/navigation_controller.h"
rdevlin.croninf5863da2015-09-10 19:21:4537#include "content/public/browser/navigation_entry.h"
lazyboy4c82177a2016-10-18 00:04:0938#include "content/public/browser/service_worker_context.h"
39#include "content/public/browser/storage_partition.h"
kalman6f984ae2015-09-18 17:21:5840#include "content/public/browser/web_contents.h"
lazyboybd325ae2015-11-18 21:35:2641#include "content/public/common/content_switches.h"
falkenad185092016-06-16 06:10:0242#include "content/public/common/origin_util.h"
kalman6f984ae2015-09-18 17:21:5843#include "content/public/common/page_type.h"
lazyboybd325ae2015-11-18 21:35:2644#include "content/public/test/background_sync_test_util.h"
annekao1db36fd2015-07-29 17:09:1645#include "content/public/test/browser_test_utils.h"
lazyboy63b994a2017-06-30 21:20:2346#include "content/public/test/service_worker_test_helpers.h"
Istiaque Ahmed771aa8a22018-06-20 23:40:5347#include "extensions/browser/event_router.h"
kalman6f984ae2015-09-18 17:21:5848#include "extensions/browser/extension_host.h"
lazyboyc3e763a2015-12-09 23:09:5849#include "extensions/browser/extension_registry.h"
kalman6f984ae2015-09-18 17:21:5850#include "extensions/browser/process_manager.h"
Istiaque Ahmed70f76ac2018-11-02 02:59:5551#include "extensions/browser/service_worker_task_queue.h"
Istiaque Ahmeda14ec482018-08-25 01:02:1852#include "extensions/common/api/test.h"
Devlin Cronina3fe3d602017-11-22 04:47:4353#include "extensions/common/extension_features.h"
Istiaque Ahmed771aa8a22018-06-20 23:40:5354#include "extensions/common/value_builder.h"
kalman6f984ae2015-09-18 17:21:5855#include "extensions/test/background_page_watcher.h"
annekao38685502015-07-14 17:46:3956#include "extensions/test/extension_test_message_listener.h"
Istiaque Ahmed805f6a83b2017-10-05 01:23:2657#include "extensions/test/result_catcher.h"
falkenad185092016-06-16 06:10:0258#include "net/dns/mock_host_resolver.h"
horo1eeddde2015-11-19 05:59:2559#include "net/test/embedded_test_server/embedded_test_server.h"
lazyboy63b994a2017-06-30 21:20:2360#include "url/url_constants.h"
annekao38685502015-07-14 17:46:3961
62namespace extensions {
63
kalman6f984ae2015-09-18 17:21:5864namespace {
65
lazyboy22eddc712015-12-10 21:16:2666// Returns the newly added WebContents.
67content::WebContents* AddTab(Browser* browser, const GURL& url) {
68 int starting_tab_count = browser->tab_strip_model()->count();
69 ui_test_utils::NavigateToURLWithDisposition(
nick3b04f322016-08-31 19:29:1970 browser, url, WindowOpenDisposition::NEW_FOREGROUND_TAB,
lazyboy22eddc712015-12-10 21:16:2671 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 Ahmedea5ed5042017-09-25 19:00:1677enum BindingsType { NATIVE_BINDINGS, JAVASCRIPT_BINDINGS };
78
lazyboy22eddc712015-12-10 21:16:2679class 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
kalman6f984ae2015-09-18 17:21:58105} // namespace
106
Istiaque Ahmedea5ed5042017-09-25 19:00:16107class ServiceWorkerTest : public ExtensionApiTest,
108 public ::testing::WithParamInterface<BindingsType> {
annekao38685502015-07-14 17:46:39109 public:
lazyboy20167c22016-05-18 00:59:30110 ServiceWorkerTest() : current_channel_(version_info::Channel::STABLE) {}
Istiaque Ahmed7105f2a2017-10-07 01:11:59111 explicit ServiceWorkerTest(version_info::Channel channel)
112 : current_channel_(channel) {}
annekao38685502015-07-14 17:46:39113
114 ~ServiceWorkerTest() override {}
115
Devlin Cronina3fe3d602017-11-22 04:47:43116 void SetUp() override {
117 if (GetParam() == NATIVE_BINDINGS) {
Mostyn Bramley-Mooreb6a37c62018-09-04 21:43:35118 scoped_feature_list_.InitAndEnableFeature(
119 extensions_features::kNativeCrxBindings);
Devlin Cronina3fe3d602017-11-22 04:47:43120 } else {
121 DCHECK_EQ(JAVASCRIPT_BINDINGS, GetParam());
Mostyn Bramley-Mooreb6a37c62018-09-04 21:43:35122 scoped_feature_list_.InitAndDisableFeature(
123 extensions_features::kNativeCrxBindings);
Devlin Cronina3fe3d602017-11-22 04:47:43124 }
125 ExtensionApiTest::SetUp();
126 }
127
jam1a5b5582017-05-01 16:50:10128 void SetUpOnMainThread() override {
129 ExtensionApiTest::SetUpOnMainThread();
130 host_resolver()->AddRule("a.com", "127.0.0.1");
131 }
132
kalman6f984ae2015-09-18 17:21:58133 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 Ahmed93ff7f42018-08-31 01:42:22141 const Extension* StartTestFromBackgroundPage(const char* script_name) {
Istiaque Ahmed6475f542018-08-28 04:20:21142 ExtensionTestMessageListener ready_listener("ready", false);
kalman6f984ae2015-09-18 17:21:58143 const Extension* extension =
144 LoadExtension(test_data_dir_.AppendASCII("service_worker/background"));
145 CHECK(extension);
Istiaque Ahmed6475f542018-08-28 04:20:21146 CHECK(ready_listener.WaitUntilSatisfied());
147
kalman6f984ae2015-09-18 17:21:58148 ExtensionHost* background_host =
149 process_manager()->GetBackgroundHostForExtension(extension->id());
150 CHECK(background_host);
Istiaque Ahmed6475f542018-08-28 04:20:21151
kalman6f984ae2015-09-18 17:21:58152 std::string error;
153 CHECK(content::ExecuteScriptAndExtractString(
154 background_host->host_contents(),
155 base::StringPrintf("test.registerServiceWorker('%s')", script_name),
156 &error));
Istiaque Ahmed93ff7f42018-08-31 01:42:22157 if (!error.empty())
kalman6f984ae2015-09-18 17:21:58158 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(
nick3b04f322016-08-31 19:29:19166 browser(), url, WindowOpenDisposition::NEW_FOREGROUND_TAB,
kalman6f984ae2015-09-18 17:21:58167 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) {
clamy1d7a4112018-06-15 15:47:16176 return Navigate(url)
177 ->GetController()
178 .GetLastCommittedEntry()
179 ->GetPageType();
kalman6f984ae2015-09-18 17:21:58180 }
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
lazyboy4c82177a2016-10-18 00:04:09201 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 Falkenhagenc5cb4282017-09-07 08:43:42214 origin, base::BindOnce(set_ref_count, &ref_count, &run_loop));
lazyboy4c82177a2016-10-18 00:04:09215 run_loop.Run();
216 return ref_count;
217 }
218
annekao38685502015-07-14 17:46:39219 private:
lazyboy20167c22016-05-18 00:59:30220 // 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.
annekao38685502015-07-14 17:46:39225 ScopedCurrentChannel current_channel_;
kalman6f984ae2015-09-18 17:21:58226
Devlin Cronina3fe3d602017-11-22 04:47:43227 base::test::ScopedFeatureList scoped_feature_list_;
228
annekao38685502015-07-14 17:46:39229 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerTest);
230};
231
Istiaque Ahmedccb444022018-06-19 02:11:12232class 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.
258IN_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 Ahmedad376e6b2018-09-13 22:48:25282IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, Basic) {
Istiaque Ahmedccb444022018-06-19 02:11:12283 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 Ahmedbf08f952018-10-02 01:22:04291// Tests chrome.runtime.onInstalled fires for extension service workers.
292IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, OnInstalledEvent) {
293 ASSERT_TRUE(RunExtensionTest(
294 "service_worker/worker_based_background/events_on_installed"))
295 << message_;
296}
297
David Bertoni69982832019-02-13 21:24:21298// Tests chrome.storage APIs.
299IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, StorageSetAndGet) {
300 ASSERT_TRUE(
301 RunExtensionTest("service_worker/worker_based_background/storage"))
302 << message_;
303}
304
David Bertoni0665c892019-02-14 00:27:26305// Tests chrome.storage.local and chrome.storage.local APIs.
306IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, StorageNoPermissions) {
307 ASSERT_TRUE(RunExtensionTest(
308 "service_worker/worker_based_background/storage_no_permissions"))
309 << message_;
310}
311
Istiaque Ahmed70f76ac2018-11-02 02:59:55312// Listens for |message| from extension Service Worker early so that tests can
313// wait for the message on startup (and not miss it).
314class ServiceWorkerWithEarlyMessageListenerTest
315 : public ServiceWorkerBasedBackgroundTest {
Istiaque Ahmedf70ab222018-10-02 03:08:24316 public:
Istiaque Ahmed70f76ac2018-11-02 02:59:55317 explicit ServiceWorkerWithEarlyMessageListenerTest(
318 const std::string& test_message)
319 : test_message_(test_message) {}
320 ~ServiceWorkerWithEarlyMessageListenerTest() override = default;
Istiaque Ahmedf70ab222018-10-02 03:08:24321
Istiaque Ahmed70f76ac2018-11-02 02:59:55322 bool WaitForMessage() { return listener_->WaitUntilSatisfied(); }
Istiaque Ahmedf70ab222018-10-02 03:08:24323
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 Ahmed70f76ac2018-11-02 02:59:55327 listener_ =
328 std::make_unique<ExtensionTestMessageListener>(test_message_, false);
Istiaque Ahmedf70ab222018-10-02 03:08:24329 ServiceWorkerBasedBackgroundTest::CreatedBrowserMainParts(main_parts);
330 }
331
332 private:
Istiaque Ahmed70f76ac2018-11-02 02:59:55333 const std::string test_message_;
Istiaque Ahmedf70ab222018-10-02 03:08:24334 std::unique_ptr<ExtensionTestMessageListener> listener_;
335
Istiaque Ahmed70f76ac2018-11-02 02:59:55336 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerWithEarlyMessageListenerTest);
337};
338
339class 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 Ahmedf70ab222018-10-02 03:08:24348};
349
350// Tests "runtime.onStartup" for extension SW.
Istiaque Ahmed70f76ac2018-11-02 02:59:55351IN_PROC_BROWSER_TEST_P(ServiceWorkerOnStartupEventTest, PRE_Event) {
Istiaque Ahmedf70ab222018-10-02 03:08:24352 ASSERT_TRUE(RunExtensionTest(
353 "service_worker/worker_based_background/on_startup_event"))
354 << message_;
355}
356
Istiaque Ahmed70f76ac2018-11-02 02:59:55357IN_PROC_BROWSER_TEST_P(ServiceWorkerOnStartupEventTest, Event) {
358 EXPECT_TRUE(WaitForMessage());
359}
360
361class 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/.
410const 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.
416IN_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
427IN_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 Ahmedf70ab222018-10-02 03:08:24435}
436
Istiaque Ahmeda14ec482018-08-25 01:02:18437// 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 Ahmed771aa8a22018-06-20 23:40:53439class EarlyWorkerMessageSender : public EventRouter::Observer {
440 public:
441 EarlyWorkerMessageSender(content::BrowserContext* browser_context,
Istiaque Ahmeda14ec482018-08-25 01:02:18442 const ExtensionId& extension_id,
443 std::unique_ptr<Event> event)
Istiaque Ahmed771aa8a22018-06-20 23:40:53444 : browser_context_(browser_context),
445 event_router_(EventRouter::EventRouter::Get(browser_context_)),
446 extension_id_(extension_id),
Istiaque Ahmeda14ec482018-08-25 01:02:18447 event_(std::move(event)),
Istiaque Ahmed771aa8a22018-06-20 23:40:53448 listener_("PASS", false) {
449 DCHECK(browser_context_);
450 listener_.set_failure_message("FAIL");
Istiaque Ahmeda14ec482018-08-25 01:02:18451 event_router_->RegisterObserver(this, event_->event_name);
Istiaque Ahmed771aa8a22018-06-20 23:40:53452 }
453
454 ~EarlyWorkerMessageSender() override {
455 event_router_->UnregisterObserver(this);
456 }
457
458 // EventRouter::Observer:
459 void OnListenerAdded(const EventListenerInfo& details) override {
Istiaque Ahmeda14ec482018-08-25 01:02:18460 if (!event_ || extension_id_ != details.extension_id ||
461 event_->event_name != details.event_name) {
Istiaque Ahmed771aa8a22018-06-20 23:40:53462 return;
Istiaque Ahmeda14ec482018-08-25 01:02:18463 }
464
Istiaque Ahmed771aa8a22018-06-20 23:40:53465 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 Ahmeda14ec482018-08-25 01:02:18472 DispatchEvent(std::move(event_));
Istiaque Ahmed771aa8a22018-06-20 23:40:53473 }
474
475 bool SendAndWait() { return listener_.WaitUntilSatisfied(); }
476
477 private:
478 static constexpr const char* const kTestOnMessageEventName = "test.onMessage";
479
Istiaque Ahmeda14ec482018-08-25 01:02:18480 void DispatchEvent(std::unique_ptr<Event> event) {
Istiaque Ahmed771aa8a22018-06-20 23:40:53481 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 Ahmeda14ec482018-08-25 01:02:18488 std::unique_ptr<Event> event_;
Istiaque Ahmed771aa8a22018-06-20 23:40:53489 ExtensionTestMessageListener listener_;
Istiaque Ahmed771aa8a22018-06-20 23:40:53490
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.
497IN_PROC_BROWSER_TEST_P(ServiceWorkerBasedBackgroundTest, EarlyEventDispatch) {
498 const ExtensionId kId("pkplfbidichfdicaijlchgnapepdginl");
Istiaque Ahmeda14ec482018-08-25 01:02:18499
500 // Build "test.onMessage" event for dispatch.
501 auto event = std::make_unique<Event>(
502 events::FOR_TEST, extensions::api::test::OnMessage::kEventName,
Lei Zhang582ecd12019-02-13 20:28:54503 base::ListValue::From(base::JSONReader::ReadDeprecated(
Istiaque Ahmeda14ec482018-08-25 01:02:18504 R"([{"data": "hello", "lastMessage": true}])")),
505 profile());
506
507 EarlyWorkerMessageSender sender(profile(), kId, std::move(event));
Istiaque Ahmed771aa8a22018-06-20 23:40:53508 // 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 Ahmeda14ec482018-08-25 01:02:18516// 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).
519IN_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
lazyboybd325ae2015-11-18 21:35:26548class 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 Ahmedea5ed5042017-09-25 19:00:16556 ::switches::kEnableExperimentalWebPlatformFeatures);
lazyboybd325ae2015-11-18 21:35:26557 ServiceWorkerTest::SetUpCommandLine(command_line);
558 }
559
560 void SetUp() override {
Robbie McElrathdb12d8e2018-09-18 21:20:40561 content::background_sync_test_util::SetIgnoreNetworkChanges(true);
lazyboybd325ae2015-11-18 21:35:26562 ServiceWorkerTest::SetUp();
563 }
564
565 private:
566 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerBackgroundSyncTest);
567};
568
lazyboy561b7de2015-11-19 19:27:30569class ServiceWorkerPushMessagingTest : public ServiceWorkerTest {
570 public:
571 ServiceWorkerPushMessagingTest()
Sylvain Defresne212b4b02018-10-11 16:32:05572 : scoped_testing_factory_installer_(
573 base::BindRepeating(&gcm::FakeGCMProfileService::Build)),
574 gcm_driver_(nullptr),
575 push_service_(nullptr) {}
576
lazyboy561b7de2015-11-19 19:27:30577 ~ServiceWorkerPushMessagingTest() override {}
578
579 void GrantNotificationPermissionForTest(const GURL& url) {
Peter Beverloodd4ef1e2018-06-21 15:41:04580 NotificationPermissionContext::UpdatePermission(profile(), url.GetOrigin(),
581 CONTENT_SETTING_ALLOW);
lazyboy561b7de2015-11-19 19:27:30582 }
583
584 PushMessagingAppIdentifier GetAppIdentifierForServiceWorkerRegistration(
avia2f4804a2015-12-24 23:11:13585 int64_t service_worker_registration_id,
lazyboy561b7de2015-11-19 19:27:30586 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 {
peter9de96272015-12-04 15:23:27597 command_line->AppendSwitch(
Istiaque Ahmedea5ed5042017-09-25 19:00:16598 ::switches::kEnableExperimentalWebPlatformFeatures);
lazyboy561b7de2015-11-19 19:27:30599 ServiceWorkerTest::SetUpCommandLine(command_line);
600 }
Tanja Gornak89128fd2018-09-18 08:49:34601
lazyboy561b7de2015-11-19 19:27:30602 void SetUpOnMainThread() override {
miguelg9b502862017-04-24 18:13:53603 NotificationDisplayServiceFactory::GetInstance()->SetTestingFactory(
Sylvain Defresne711ff6b2018-10-04 12:33:54604 profile(),
605 base::BindRepeating(&StubNotificationDisplayService::FactoryForTests));
miguelg9b502862017-04-24 18:13:53606
johnmea5045732016-09-08 17:23:29607 gcm::FakeGCMProfileService* gcm_service =
608 static_cast<gcm::FakeGCMProfileService*>(
Tanja Gornak89128fd2018-09-18 08:49:34609 gcm::GCMProfileServiceFactory::GetForProfile(profile()));
johnmea5045732016-09-08 17:23:29610 gcm_driver_ = static_cast<instance_id::FakeGCMDriverForInstanceID*>(
611 gcm_service->driver());
lazyboy561b7de2015-11-19 19:27:30612 push_service_ = PushMessagingServiceFactory::GetForProfile(profile());
613
614 ServiceWorkerTest::SetUpOnMainThread();
615 }
616
johnmea5045732016-09-08 17:23:29617 instance_id::FakeGCMDriverForInstanceID* gcm_driver() const {
618 return gcm_driver_;
619 }
lazyboy561b7de2015-11-19 19:27:30620 PushMessagingServiceImpl* push_service() const { return push_service_; }
621
622 private:
Sylvain Defresne212b4b02018-10-11 16:32:05623 gcm::GCMProfileServiceFactory::ScopedTestingFactoryInstaller
624 scoped_testing_factory_installer_;
625
johnmea5045732016-09-08 17:23:29626 instance_id::FakeGCMDriverForInstanceID* gcm_driver_;
lazyboy561b7de2015-11-19 19:27:30627 PushMessagingServiceImpl* push_service_;
628
629 DISALLOW_COPY_AND_ASSIGN(ServiceWorkerPushMessagingTest);
630};
631
Istiaque Ahmed805f6a83b2017-10-05 01:23:26632class ServiceWorkerLazyBackgroundTest : public ServiceWorkerTest {
633 public:
Istiaque Ahmed7105f2a2017-10-07 01:11:59634 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 Ahmed805f6a83b2017-10-05 01:23:26641 ~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 Ahmedea5ed5042017-09-25 19:00:16662IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, RegisterSucceeds) {
Istiaque Ahmed93ff7f42018-08-31 01:42:22663 StartTestFromBackgroundPage("register.js");
annekao38685502015-07-14 17:46:39664}
665
Istiaque Ahmedea5ed5042017-09-25 19:00:16666IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, UpdateRefreshesServiceWorker) {
Francois Doraye6fb2d02017-10-18 21:29:13667 base::ScopedAllowBlockingForTesting allow_blocking;
lazyboyc3e763a2015-12-09 23:09:58668 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");
vabr9142fe22016-09-08 13:19:22673 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());
lazyboyc3e763a2015-12-09 23:09:58685 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]2ef85d562017-09-15 18:41:52707// TODO(crbug.com/765736) Fix the test.
Istiaque Ahmedea5ed5042017-09-25 19:00:16708IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, DISABLED_UpdateWithoutSkipWaiting) {
Francois Doraye6fb2d02017-10-18 21:29:13709 base::ScopedAllowBlockingForTesting allow_blocking;
lazyboy22eddc712015-12-10 21:16:26710 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");
vabr9142fe22016-09-08 13:19:22715 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());
lazyboy22eddc712015-12-10 21:16:26727 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 Ahmedea5ed5042017-09-25 19:00:16780IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, FetchArbitraryPaths) {
Istiaque Ahmed93ff7f42018-08-31 01:42:22781 const Extension* extension = StartTestFromBackgroundPage("fetch.js");
annekao1db36fd2015-07-29 17:09:16782
kalman6f984ae2015-09-18 17:21:58783 // 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("")));
annekao1db36fd2015-07-29 17:09:16799}
800
Kenichi Ishibashi773b82972018-08-30 07:02:03801IN_PROC_BROWSER_TEST_P(ServiceWorkerTest,
802 FetchExtensionResourceFromServiceWorker) {
Istiaque Ahmed93ff7f42018-08-31 01:42:22803 const Extension* extension = StartTestFromBackgroundPage("fetch_from_sw.js");
Kenichi Ishibashi773b82972018-08-30 07:02:03804 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 Ishibashi09ee5e72018-11-27 07:12:38819// Tests that fetch() from service worker and network fallback
820// go through webRequest.onBeforeRequest API.
821IN_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 Ahmedea5ed5042017-09-25 19:00:16862IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, SWServedBackgroundPageReceivesEvent) {
lazyboy52c3bcf2016-01-08 00:11:29863 const Extension* extension =
Istiaque Ahmed93ff7f42018-08-31 01:42:22864 StartTestFromBackgroundPage("replace_background.js");
lazyboy52c3bcf2016-01-08 00:11:29865 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 Kasting341e1fb2018-02-24 00:03:01874 process_manager()->WakeEventPage(extension->id(), base::DoNothing());
lazyboy52c3bcf2016-01-08 00:11:29875 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 Falkenhagena612fc02018-05-30 00:35:39888IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, SWServedBackgroundPage) {
Istiaque Ahmed93ff7f42018-08-31 01:42:22889 const Extension* extension = StartTestFromBackgroundPage("fetch.js");
annekao49241182015-08-18 17:14:01890
kalman6f984ae2015-09-18 17:21:58891 std::string kExpectedInnerText = "background.html contents for testing.";
annekao49241182015-08-18 17:14:01892
kalman6f984ae2015-09-18 17:21:58893 // 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()));
annekao49241182015-08-18 17:14:01899
kalman6f984ae2015-09-18 17:21:58900 // Close the background page.
901 background_page->Close();
902 BackgroundPageWatcher(process_manager(), extension).WaitForClose();
903 background_page = nullptr;
904
905 // Start it again.
Peter Kasting341e1fb2018-02-24 00:03:01906 process_manager()->WakeEventPage(extension->id(), base::DoNothing());
kalman6f984ae2015-09-18 17:21:58907 BackgroundPageWatcher(process_manager(), extension).WaitForOpen();
908
Matt Falkenhagena612fc02018-05-30 00:35:39909 // The service worker should get a fetch event for the background page.
kalman6f984ae2015-09-18 17:21:58910 background_page =
911 process_manager()->GetBackgroundHostForExtension(extension->id());
912 ASSERT_TRUE(background_page);
913 content::WaitForLoadStop(background_page->host_contents());
914
kalman6f984ae2015-09-18 17:21:58915 EXPECT_EQ("Caught a fetch for /background.html",
916 ExtractInnerText(background_page->host_contents()));
annekao49241182015-08-18 17:14:01917}
918
Istiaque Ahmedea5ed5042017-09-25 19:00:16919IN_PROC_BROWSER_TEST_P(ServiceWorkerTest,
kalman6f984ae2015-09-18 17:21:58920 ServiceWorkerPostsMessageToBackgroundClient) {
Istiaque Ahmed93ff7f42018-08-31 01:42:22921 const Extension* extension =
922 StartTestFromBackgroundPage("post_message_to_background_client.js");
annekao533482222015-08-21 23:23:53923
kalman6f984ae2015-09-18 17:21:58924 // 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));
annekao533482222015-08-21 23:23:53937}
938
Istiaque Ahmedea5ed5042017-09-25 19:00:16939IN_PROC_BROWSER_TEST_P(ServiceWorkerTest,
kalman6f984ae2015-09-18 17:21:58940 BackgroundPagePostsMessageToServiceWorker) {
941 const Extension* extension =
Istiaque Ahmed93ff7f42018-08-31 01:42:22942 StartTestFromBackgroundPage("post_message_to_sw.js");
annekao533482222015-08-21 23:23:53943
kalman6f984ae2015-09-18 17:21:58944 // 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));
annekao533482222015-08-21 23:23:53954}
955
Istiaque Ahmedea5ed5042017-09-25 19:00:16956IN_PROC_BROWSER_TEST_P(ServiceWorkerTest,
rdevlin.croninf5863da2015-09-10 19:21:45957 ServiceWorkerSuspensionOnExtensionUnload) {
kalman6f984ae2015-09-18 17:21:58958 // 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 Ahmed93ff7f42018-08-31 01:42:22964 const Extension* extension = StartTestFromBackgroundPage("fetch.js");
kalman6f984ae2015-09-18 17:21:58965 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.croninf5863da2015-09-10 19:21:45971
kalman6f984ae2015-09-18 17:21:58972 // Fetch should route to the service worker.
973 EXPECT_EQ("Caught a fetch for /index.html",
974 NavigateAndExtractInnerText(get_resource_url("index.html")));
rdevlin.croninf5863da2015-09-10 19:21:45975
kalman6f984ae2015-09-18 17:21:58976 // Disable the extension. Opening the page should fail.
977 extension_service()->DisableExtension(extension_id,
Minh X. Nguyen45479012017-08-18 21:35:36978 disable_reason::DISABLE_USER_ACTION);
rdevlin.croninf5863da2015-09-10 19:21:45979 base::RunLoop().RunUntilIdle();
rdevlin.croninf5863da2015-09-10 19:21:45980
kalman6f984ae2015-09-18 17:21:58981 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.croninf5863da2015-09-10 19:21:45988 extension_service()->EnableExtension(extension_id);
989 base::RunLoop().RunUntilIdle();
990
kalman6f984ae2015-09-18 17:21:58991 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.croninf5863da2015-09-10 19:21:45997
kalman6f984ae2015-09-18 17:21:58998 // Uninstall the extension. Opening pages should fail again.
999 base::string16 error;
1000 extension_service()->UninstallExtension(
Devlin Cronin218df7f2017-11-21 21:41:311001 extension_id, UninstallReason::UNINSTALL_REASON_FOR_TESTING, &error);
kalman6f984ae2015-09-18 17:21:581002 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 Ahmedea5ed5042017-09-25 19:00:161014IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, BackgroundPageIsWokenIfAsleep) {
Istiaque Ahmed93ff7f42018-08-31 01:42:221015 const Extension* extension = StartTestFromBackgroundPage("wake_on_fetch.js");
kalman6f984ae2015-09-18 17:21:581016
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 Ahmedea5ed5042017-09-25 19:00:161045IN_PROC_BROWSER_TEST_P(ServiceWorkerTest,
kalman6f984ae2015-09-18 17:21:581046 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.croninf5863da2015-09-10 19:21:451052}
1053
Istiaque Ahmedea5ed5042017-09-25 19:00:161054IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, NotificationAPI) {
lazyboy6ddb7d62015-11-10 23:15:271055 EXPECT_TRUE(RunExtensionSubtest("service_worker/notifications/has_permission",
1056 "page.html"));
1057}
1058
Istiaque Ahmedea5ed5042017-09-25 19:00:161059IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, WebAccessibleResourcesFetch) {
lazyboyaea32c22016-01-04 21:37:071060 EXPECT_TRUE(RunExtensionSubtest(
1061 "service_worker/web_accessible_resources/fetch/", "page.html"));
1062}
1063
Istiaque Ahmed75ad1d92018-08-30 05:16:541064IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, TabsCreate) {
lazyboyee4adef2016-05-24 00:55:161065 // 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 Ahmedea5ed5042017-09-25 19:00:161087IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, Events) {
lazyboye7847242017-06-07 23:29:181088 // 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 Ahmedea5ed5042017-09-25 19:00:161103IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, EventsToStoppedWorker) {
lazyboy63b994a2017-06-30 21:20:231104 // 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 Qian2266251f2018-10-13 02:59:001124 content::StopServiceWorkerForScope(
lazyboy63b994a2017-06-30 21:20:231125 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 Ahmed805f6a83b2017-10-05 01:23:261137// Tests that events to service worker arrives correctly event if the owner
1138// extension of the worker is not running.
1139IN_PROC_BROWSER_TEST_P(ServiceWorkerLazyBackgroundTest,
Istiaque Ahmedb8e24bdb2018-09-13 15:17:251140 EventsToStoppedExtension) {
Istiaque Ahmed805f6a83b2017-10-05 01:23:261141 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 Bertoni3e1e9fa2018-08-29 20:39:301151 EXPECT_FALSE(pm->GetLazyKeepaliveActivities(extension).empty());
Istiaque Ahmed805f6a83b2017-10-05 01:23:261152
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 Qian2266251f2018-10-13 02:59:001171 content::StopServiceWorkerForScope(
Istiaque Ahmed805f6a83b2017-10-05 01:23:261172 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 Ahmed7105f2a2017-10-07 01:11:591190 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.
1198IN_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 Bertoni3e1e9fa2018-08-29 20:39:301210 EXPECT_FALSE(pm->GetLazyKeepaliveActivities(extension).empty());
Istiaque Ahmed7105f2a2017-10-07 01:11:591211
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 Qian2266251f2018-10-13 02:59:001230 content::StopServiceWorkerForScope(
Istiaque Ahmed7105f2a2017-10-07 01:11:591231 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 Ahmed99aa96d2018-09-13 23:22:081244IN_PROC_BROWSER_TEST_P(ServiceWorkerLazyBackgroundTest, EventsAfterRestart) {
Istiaque Ahmed7105f2a2017-10-07 01:11:591245 ExtensionTestMessageListener newtab_listener("hello-newtab", false);
1246 content::WebContents* new_web_contents =
1247 AddTab(browser(), GURL(url::kAboutBlankURL));
Istiaque Ahmed805f6a83b2017-10-05 01:23:261248 EXPECT_TRUE(new_web_contents);
1249 EXPECT_TRUE(newtab_listener.WaitUntilSatisfied());
1250}
1251
lazyboy4c82177a2016-10-18 00:04:091252// Tests that worker ref count increments while extension API function is
1253// active.
Istiaque Ahmedea5ed5042017-09-25 19:00:161254IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, WorkerRefCount) {
lazyboy4c82177a2016-10-18 00:04:091255 // 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 Ahmedb57c9752017-08-20 19:08:571299 ExtensionTestMessageListener worker_completion_listener("SUCCESS_FROM_WORKER",
1300 false);
lazyboy4c82177a2016-10-18 00:04:091301 // Finish executing chrome.test.sendMessage().
1302 worker_listener.Reply("Hello world");
Istiaque Ahmedb57c9752017-08-20 19:08:571303 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 Charette01507a22017-09-27 21:30:081317 content::RunAllTasksUntilIdle();
Istiaque Ahmedb57c9752017-08-20 19:08:571318 }
lazyboy4c82177a2016-10-18 00:04:091319
1320 // The ref count should drop to 0.
1321 EXPECT_EQ(0u, GetWorkerRefCount(extension->url()));
1322}
1323
lazyboyaea32c22016-01-04 21:37:071324// 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 Ahmedea5ed5042017-09-25 19:00:161333IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, WebAccessibleResourcesIframeSrc) {
lazyboyaea32c22016-01-04 21:37:071334 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());
falkenad185092016-06-16 06:10:021340
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.
falkenad185092016-06-16 06:10:021352 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));
lazyboyaea32c22016-01-04 21:37:071357
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 Ahmedea5ed5042017-09-25 19:00:161396IN_PROC_BROWSER_TEST_P(ServiceWorkerBackgroundSyncTest, Sync) {
lazyboybd325ae2015-11-18 21:35:261397 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 Ahmedea5ed5042017-09-25 19:00:161422IN_PROC_BROWSER_TEST_P(ServiceWorkerTest,
horo1eeddde2015-11-19 05:59:251423 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 Ahmedea5ed5042017-09-25 19:00:161442IN_PROC_BROWSER_TEST_P(ServiceWorkerPushMessagingTest, OnPush) {
lazyboy561b7de2015-11-19 19:27:301443 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 Beverloodd4ef1e2018-06-21 15:41:041448 GrantNotificationPermissionForTest(extension_url);
lazyboy561b7de2015-11-19 19:27:301449
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);
johnmea5045732016-09-08 17:23:291465 ASSERT_EQ(app_identifier.app_id(), gcm_driver()->last_gettoken_app_id());
1466 EXPECT_EQ("1234567890", gcm_driver()->last_gettoken_authorized_entity());
lazyboy561b7de2015-11-19 19:27:301467
lazyboyd429e2582016-05-20 20:18:521468 base::RunLoop run_loop;
lazyboy561b7de2015-11-19 19:27:301469 // 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;
lazyboyd429e2582016-05-20 20:18:521476 push_service()->SetMessageCallbackForTesting(run_loop.QuitClosure());
lazyboy561b7de2015-11-19 19:27:301477 push_service()->OnMessage(app_identifier.app_id(), message);
1478 EXPECT_TRUE(push_message_listener.WaitUntilSatisfied());
lazyboyd429e2582016-05-20 20:18:521479 run_loop.Run(); // Wait until the message is handled by push service.
lazyboy561b7de2015-11-19 19:27:301480}
1481
Istiaque Ahmedea5ed5042017-09-25 19:00:161482IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, FilteredEvents) {
Istiaque Ahmed9d1666182017-09-21 23:58:181483 // 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 Wue89b90032018-02-16 19:46:081488IN_PROC_BROWSER_TEST_P(ServiceWorkerTest, MimeHandlerView) {
1489 ASSERT_TRUE(RunExtensionTest("service_worker/mime_handler_view"));
1490}
1491
Istiaque Ahmed9ce21b32017-10-10 20:43:181492IN_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 Qian2266251f2018-10-13 02:59:001522 content::StopServiceWorkerForScope(
Istiaque Ahmed9ce21b32017-10-10 20:43:181523 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
1536IN_PROC_BROWSER_TEST_P(ServiceWorkerLazyBackgroundTest,
Istiaque Ahmedf5712522018-09-20 03:35:471537 FilteredEventsAfterRestart) {
Istiaque Ahmed9ce21b32017-10-10 20:43:181538 // 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 Ahmedea5ed5042017-09-25 19:00:161552// 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 Costan4a060e82019-01-28 18:25:341555INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithNativeBindings,
1556 ServiceWorkerTest,
1557 ::testing::Values(NATIVE_BINDINGS));
1558INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithJSBindings,
1559 ServiceWorkerTest,
1560 ::testing::Values(JAVASCRIPT_BINDINGS));
1561INSTANTIATE_TEST_SUITE_P(ServiceWorkerBackgroundSyncTestWithNativeBindings,
1562 ServiceWorkerBackgroundSyncTest,
1563 ::testing::Values(NATIVE_BINDINGS));
1564INSTANTIATE_TEST_SUITE_P(ServiceWorkerBackgroundSyncTestWithJSBindings,
1565 ServiceWorkerBackgroundSyncTest,
1566 ::testing::Values(JAVASCRIPT_BINDINGS));
1567INSTANTIATE_TEST_SUITE_P(ServiceWorkerPushMessagingTestWithNativeBindings,
1568 ServiceWorkerPushMessagingTest,
1569 ::testing::Values(NATIVE_BINDINGS));
1570INSTANTIATE_TEST_SUITE_P(ServiceWorkerPushMessagingTestWithJSBindings,
1571 ServiceWorkerPushMessagingTest,
1572 ::testing::Values(JAVASCRIPT_BINDINGS));
1573INSTANTIATE_TEST_SUITE_P(ServiceWorkerLazyBackgroundTestWithNativeBindings,
1574 ServiceWorkerLazyBackgroundTest,
1575 ::testing::Values(NATIVE_BINDINGS));
1576INSTANTIATE_TEST_SUITE_P(ServiceWorkerLazyBackgroundTestWithJSBindings,
1577 ServiceWorkerLazyBackgroundTest,
1578 ::testing::Values(JAVASCRIPT_BINDINGS));
1579INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithNativeBindings,
1580 ServiceWorkerBasedBackgroundTest,
1581 ::testing::Values(NATIVE_BINDINGS));
1582INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithJSBindings,
1583 ServiceWorkerBasedBackgroundTest,
1584 ::testing::Values(JAVASCRIPT_BINDINGS));
1585INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithNativeBindings,
1586 ServiceWorkerOnStartupEventTest,
1587 ::testing::Values(NATIVE_BINDINGS));
1588INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithJSBindings,
1589 ServiceWorkerOnStartupEventTest,
1590 ::testing::Values(JAVASCRIPT_BINDINGS));
1591INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithNativeBindings,
1592 ServiceWorkerRegistrationAtStartupTest,
1593 ::testing::Values(NATIVE_BINDINGS));
1594INSTANTIATE_TEST_SUITE_P(ServiceWorkerTestWithJSBindings,
1595 ServiceWorkerRegistrationAtStartupTest,
1596 ::testing::Values(JAVASCRIPT_BINDINGS));
Istiaque Ahmedea5ed5042017-09-25 19:00:161597
annekao38685502015-07-14 17:46:391598} // namespace extensions