Prevent a service worker from keeping itself alive by self postMessage.

content/browser/service_worker/service_worker_browsertest.cc

Index: content/browser/service_worker/service_worker_browsertest.cc
diff --git a/content/browser/service_worker/service_worker_browsertest.cc b/content/browser/service_worker/service_worker_browsertest.cc
index 6011d1ac2fc9e44ee4df0b4865f358a63c720e60..23b63849312bf03f9e88ff5d9c8f849f644779bd 100644
--- a/content/browser/service_worker/service_worker_browsertest.cc
+++ b/content/browser/service_worker/service_worker_browsertest.cc
@@ -22,6 +22,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
@@ -1255,6 +1256,72 @@ IN_PROC_BROWSER_TEST_P(ServiceWorkerVersionBrowserTest, FetchWithoutSaveData) {
   SetBrowserClientForTesting(old_client);
 }
 
+IN_PROC_BROWSER_TEST_P(ServiceWorkerVersionBrowserTest, MessageSelf) {
+  const base::string16 activateMsg = base::ASCIIToUTF16("ACTIVATE");
+  const base::string16 messageMsg = base::ASCIIToUTF16("MESSAGE");

[falken, 2016/11/21 08:01:48]

nit: activateMsg isn't used, and naming style should be kMessageMsg

+
+  RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread,
+                           base::Unretained(this),
+                           "/service_worker/worker_message_to_self.js"));
+  base::SimpleTestTickClock* tick_clock = new base::SimpleTestTickClock();
+  tick_clock->SetNowTicks(base::TimeTicks::Now());
+  version_->SetTickClockForTesting(base::WrapUnique(tick_clock));
+
+  ConsoleListener console_listener;
+  RunOnIOThread(base::Bind(&EmbeddedWorkerInstance::AddListener,
+                           base::Unretained(version_->embedded_worker()),
+                           &console_listener));
+
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
+  base::RunLoop run_loop;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&self::ActivateOnIOThread, base::Unretained(this),
+                 run_loop.QuitClosure(), &status));
+  run_loop.Run();
+  ASSERT_EQ(SERVICE_WORKER_OK, status);
+
+  base::TimeDelta request_timeout = base::TimeDelta::FromMinutes(
+      ServiceWorkerVersion::kRequestTimeoutMinutes);
+  base::TimeDelta remaining = base::TimeDelta::FromSeconds(10);
+
+  console_listener.WaitForConsoleMessages(1);
+  EXPECT_EQ(messageMsg, console_listener.messages()[0]);
+  EXPECT_EQ(request_timeout, version_->remaining_timeout());
+
+  // Advance clock some, but not enough to trigger the timeout.
+  tick_clock->Advance(request_timeout - remaining);
+  EXPECT_EQ(remaining, version_->remaining_timeout());
+
+  // Wait for another onmessage event.
+  console_listener.WaitForConsoleMessages(2);
+  EXPECT_EQ(messageMsg, console_listener.messages()[1]);
+  // Timeout should not have changed.
+  EXPECT_EQ(remaining, version_->remaining_timeout());
+
+  // Advance clock enough to trigger the timeout.
+  tick_clock->Advance(remaining * 2);
+  EXPECT_LT(version_->remaining_timeout(), base::TimeDelta());
+  RunOnIOThread(base::Bind(&ServiceWorkerVersion::OnTimeoutTimer, version_));
+
+  // Advance clock more to trigger idle timeout.
+  tick_clock->Advance(base::TimeDelta::FromSeconds(
+      ServiceWorkerVersion::kIdleWorkerTimeoutSeconds));
+  RunOnIOThread(base::Bind(&ServiceWorkerVersion::OnTimeoutTimer, version_));
+
+  // Worker should be stopping.
+  EXPECT_EQ(EmbeddedWorkerStatus::STOPPING, version_->running_status());
+
+  // One more message event might already have been queued before advancing the
+  // time, but no other message events should have triggered while stopping
+  // worker.
+  EXPECT_LE(console_listener.messages().size(), 3u);
+

[falken, 2016/11/21 08:01:48]

It'd be slightly nicer if this could verify that the worker STOPPED and isn't
starting back up again, since STOPPING could still mean a StartWorker is queued
up and waiting to restart. Do you know if the test can do that?

[Marijn Kruisselbrink, 2016/12/01 19:54:29]

Unfortunately I couldn't even figure out how to make the existing assertions not
flakily fail (the test as written seemed to fail about 1% of the time) due to
timing issues with how far the renderer progresses while the browser is doing
things here... After trying all kinds of things I've just deleted this entire
browser test, although it would be nice to have some kind of more end-to-end
test than the unit tests... Just not sure how to reliably write one..

+  RunOnIOThread(base::Bind(&EmbeddedWorkerInstance::RemoveListener,
+                           base::Unretained(version_->embedded_worker()),
+                           &console_listener));
+}
+
 IN_PROC_BROWSER_TEST_P(ServiceWorkerBrowserTest, FetchPageWithSaveData) {
   const char kPageUrl[] = "/service_worker/handle_fetch.html";
   const char kWorkerUrl[] = "/service_worker/add_save_data_to_title.js";