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

content/browser/service_worker/service_worker_browsertest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #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"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/cache_storage/cache_storage_cache.h"
 #include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/browser/cache_storage/cache_storage_context_impl.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
@@ skipping 1213 matching lines @@
 IN_PROC_BROWSER_TEST_P(ServiceWorkerVersionBrowserTest, FetchWithoutSaveData) {
   embedded_test_server()->RegisterRequestHandler(
       base::Bind(&VerifySaveDataHeaderNotInRequest));
   MockContentBrowserClient content_browser_client;
   ContentBrowserClient* old_client =
       SetBrowserClientForTesting(&content_browser_client);
   InstallTestHelper("/service_worker/fetch_in_install.js", SERVICE_WORKER_OK);
   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";
   MockContentBrowserClient content_browser_client;
   content_browser_client.set_data_saver_enabled(true);
   ContentBrowserClient* old_client =
       SetBrowserClientForTesting(&content_browser_client);
   shell()->web_contents()->GetRenderViewHost()->OnWebkitPreferencesChanged();
   scoped_refptr<WorkerActivatedObserver> observer =
       new WorkerActivatedObserver(wrapper());
@@ skipping 1579 matching lines @@
                         ServiceWorkerV8CacheStrategiesNormalTest,
                         ::testing::Values(true, false));
 INSTANTIATE_TEST_CASE_P(ServiceWorkerBrowserTest,
                         ServiceWorkerV8CacheStrategiesAggressiveTest,
                         ::testing::Values(true, false));
 INSTANTIATE_TEST_CASE_P(ServiceWorkerBrowserTest,
                         ServiceWorkerDisableWebSecurityTest,
                         ::testing::Values(true, false));
 
 }  // namespace content