Add ref count to service workers for extension API.

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 604 matching lines @@
   ASSERT_TRUE(extension);
   ui_test_utils::NavigateToURL(browser(),
                                extension->GetResourceURL("page.html"));
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
 
   int starting_tab_count = browser()->tab_strip_model()->count();
   std::string result;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       web_contents, "window.runServiceWorker()", &result));
-  ASSERT_EQ("chrome.tabs.create callback", result);
+  ASSERT_EQ("chrome.tabs.update callback", result);

[Devlin, 2016/10/05 17:02:25]

I'm a little confused on the test for this.  Where do we adjust the timeout, or
ensure the worker would otherwise be terminated?

[lazyboy, 2016/10/06 01:02:06]

We don't.
I only tested them with hacking the timeout values in service worker and adding
artificial delay to update response. As is, it's hard to to test this. I hope to
write some unit tests later on.

[Devlin, 2016/10/06 16:35:12]

Can we add an explicit TODO?  And out of curiosity, what are the main
complications?

[lazyboy, 2016/10/06 17:57:37]

Done.

 And out of curiosity, what are the main
There's a worker timer that periodically fires (say X seconds) to check whether
the service worker has pending work to do. If it doesn't find on, on next timer
fire it will shutdown the worker. We need to mock the timer or override X to
small number for test. And then make an extension API run longer than (X + X)s.
Then check that we actually kept the worker running.

[Devlin, 2016/10/06 18:58:06]

Can we access the refcount from chrome/ (or could we add a test method or
something to do so)?  If so, we could use the test.sendMessage() API (which we
can control when it returns) and check that once the API call starts the
refcount increased by one.  That would be a pretty reasonable test, since I
think testing that a SW with any refcount isn't killed might be something better
tested in content/ (and for SWs in general).

[lazyboy, 2016/10/07 06:00:57]

Added a test only method in content/public, added test.

   EXPECT_EQ(starting_tab_count + 1, browser()->tab_strip_model()->count());
 
   // Check extension shutdown path.
   UnloadExtension(extension->id());
   EXPECT_EQ(starting_tab_count, browser()->tab_strip_model()->count());
 }
 
 // This test loads a web page that has an iframe pointing to a
 // chrome-extension:// URL. The URL is listed in the extension's
 // web_accessible_resources. Initially the iframe is served from the extension's
@@ skipping 147 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