[extension SW] Support lazy events from extension service workers.

chrome/browser/extensions/service_worker_apitest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdint.h>
 
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 18 matching lines @@
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/service_worker_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/origin_util.h"
 #include "content/public/common/page_type.h"
 #include "content/public/test/background_sync_test_util.h"
 #include "content/public/test/browser_test_utils.h"
+#include "content/public/test/service_worker_test_helpers.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/test/background_page_watcher.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "url/url_constants.h"
 
 namespace extensions {
 
 namespace {
 
 // Pass into ServiceWorkerTest::StartTestFromBackgroundPage to indicate that
 // registration is expected to succeed.
 std::string* const kExpectSuccess = nullptr;
 
 void DoNothingWithBool(bool b) {}
 
 // Returns the newly added WebContents.
 content::WebContents* AddTab(Browser* browser, const GURL& url) {
   int starting_tab_count = browser->tab_strip_model()->count();
   ui_test_utils::NavigateToURLWithDisposition(
       browser, url, WindowOpenDisposition::NEW_FOREGROUND_TAB,
       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
   int tab_count = browser->tab_strip_model()->count();
   EXPECT_EQ(starting_tab_count + 1, tab_count);
   return browser->tab_strip_model()->GetActiveWebContents();
 }
 
+GURL GetOriginForExtension(const ExtensionId& extension_id) {

[Devlin, 2017/06/16 02:34:41]

Is this different than extension->url()?

[lazyboy, 2017/06/16 18:48:04]

You're right. Fixed.

+  return GURL(std::string(kExtensionScheme) + url::kStandardSchemeSeparator +
+              extension_id);
+}
+
 class WebContentsLoadStopObserver : content::WebContentsObserver {
  public:
   explicit WebContentsLoadStopObserver(content::WebContents* web_contents)
       : content::WebContentsObserver(web_contents),
         load_stop_observed_(false) {}
 
   void WaitForLoadStop() {
     if (load_stop_observed_)
       return;
     message_loop_runner_ = new content::MessageLoopRunner;
@@ skipping 597 matching lines @@
   ui_test_utils::NavigateToURL(browser(),
                                extension->GetResourceURL("page.html"));
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
   std::string result;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       web_contents, "window.runEventTest()", &result));
   ASSERT_EQ("chrome.tabs.onUpdated callback", result);
 }
 
+IN_PROC_BROWSER_TEST_F(ServiceWorkerTest, EventsToStoppedWorker) {
+  // Extensions APIs from SW are only enabled on trunk.
+  ScopedCurrentChannel current_channel_override(version_info::Channel::UNKNOWN);
+  const Extension* extension = LoadExtensionWithFlags(
+      test_data_dir_.AppendASCII("service_worker/events_to_stopped_worker"),
+      kFlagNone);
+  ASSERT_TRUE(extension);
+  ui_test_utils::NavigateToURL(browser(),
+                               extension->GetResourceURL("page.html"));
+  content::WebContents* web_contents =
+      browser()->tab_strip_model()->GetActiveWebContents();
+  {
+    content::StoragePartition* storage_partition =
+        content::BrowserContext::GetDefaultStoragePartition(
+            browser()->profile());
+    std::string result;
+    ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+        web_contents, "window.runServiceWorker()", &result));
+    ASSERT_EQ("ready", result);
+
+    {
+      base::RunLoop stop_called_run_loop;
+      content::StopServiceWorkerAtOrigin(

[Devlin, 2017/06/16 02:34:42]

can we move the storage_partition var into this scope?

[lazyboy, 2017/06/16 18:48:04]

Done.

+          storage_partition->GetServiceWorkerContext(),
+          GetOriginForExtension(extension->id()),
+          stop_called_run_loop.QuitClosure());
+      stop_called_run_loop.Run();
+    }

[Devlin, 2017/06/16 02:34:41]

Is there a simple method we can use to EXPECT_ that the service worker has
indeed stopped?

[lazyboy, 2017/06/16 18:48:04]

Not that I know of, hopefully StoppedObserver will always timeout when that
happens.

+  }
+
+  std::string result;
+  ASSERT_TRUE(content::ExecuteScriptAndExtractString(
+      web_contents, "window.createTabThenUpdate()", &result));
+  ASSERT_EQ("chrome.tabs.onUpdated callback", result);
+}
+
 // Tests that worker ref count increments while extension API function is
 // active.
 
 // Flaky on Linux and ChromeOS, https://crbug.com/702126
 #if defined(OS_LINUX)
 #define MAYBE_WorkerRefCount DISABLED_WorkerRefCount
 #else
 #define MAYBE_WorkerRefCount WorkerRefCount
 #endif
 IN_PROC_BROWSER_TEST_F(ServiceWorkerTest, MAYBE_WorkerRefCount) {
@@ skipping 203 matching lines @@
   message.sender_id = "1234567890";
   message.raw_data = "testdata";
   message.decrypted = true;
   push_service()->SetMessageCallbackForTesting(run_loop.QuitClosure());
   push_service()->OnMessage(app_identifier.app_id(), message);
   EXPECT_TRUE(push_message_listener.WaitUntilSatisfied());
   run_loop.Run();  // Wait until the message is handled by push service.
 }
 
 }  // namespace extensions