Stop Service Workers that execute JavaScript for too long.

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
@@ skipping 44 matching lines @@
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
 };
 
 void RunAndQuit(const base::Closure& closure,
                 const base::Closure& quit,
                 base::MessageLoopProxy* original_message_loop) {
   closure.Run();
   original_message_loop->PostTask(FROM_HERE, quit);
 }
 
-void RunOnIOThread(const base::Closure& closure) {
+void RunOnIOThreadWithDelay(const base::Closure& closure,
+                            base::TimeDelta delay) {
   base::RunLoop run_loop;
-  BrowserThread::PostTask(
+  BrowserThread::PostDelayedTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&RunAndQuit, closure, run_loop.QuitClosure(),
-                 base::MessageLoopProxy::current()));
+                 base::MessageLoopProxy::current()),
+      delay);
   run_loop.Run();
 }
 
+void RunOnIOThread(const base::Closure& closure) {
+  RunOnIOThreadWithDelay(closure, base::TimeDelta());
+}
+
 void RunOnIOThread(
     const base::Callback<void(const base::Closure& continuation)>& closure) {
   base::RunLoop run_loop;
   base::Closure quit_on_original_thread =
       base::Bind(base::IgnoreResult(&base::MessageLoopProxy::PostTask),
                  base::MessageLoopProxy::current().get(),
                  FROM_HERE,
                  run_loop.QuitClosure());
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
@@ skipping 431 matching lines @@
         wrapper()->context()->storage()->NewRegistrationId(),
         wrapper()->context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(
         registration_.get(),
         embedded_test_server()->GetURL(worker_url),
         wrapper()->context()->storage()->NewVersionId(),
         wrapper()->context()->AsWeakPtr());
     AssociateRendererProcessToPattern(pattern);
   }
 
+  void TimeoutWorkerOnIOThread() {
+    ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
+    version_->PingWorker();
+    version_->OnPingTimeout();
+  }
+
   void StartOnIOThread(const base::Closure& done,
                        ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->StartWorker(CreateReceiver(BrowserThread::UI, done, result));
   }
 
   void InstallOnIOThread(const base::Closure& done,
                          ServiceWorkerStatusCode* result) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
     version_->SetStatus(ServiceWorkerVersion::INSTALLING);
@@ skipping 157 matching lines @@
   ActivateTestHelper("/service_worker/worker_activate_rejected.js",
                      SERVICE_WORKER_ERROR_ACTIVATE_WORKER_FAILED);
 }
 
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest,
                        InstallWithWaitUntil_Rejected) {
   InstallTestHelper("/service_worker/worker_install_rejected.js",
                     SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED);
 }
 
+class WaitForLoaded : public EmbeddedWorkerInstance::Listener {
+ public:
+  WaitForLoaded(const base::Closure& quit) : quit_(quit) {}
+
+  void OnScriptLoaded() override {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, quit_);
+  }
+  bool OnMessageReceived(const IPC::Message& message) override { return false; }
+
+ private:
+  base::Closure quit_;
+};
+
+IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, TimeoutStartingWorker) {
+  RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, this,
+                           "/service_worker/while_true_worker.js"));
+
+  // Start a worker, waiting until the script is loaded.
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
+  base::RunLoop start_run_loop;
+  base::RunLoop load_run_loop;
+  WaitForLoaded wait_for_load(load_run_loop.QuitClosure());
+  version_->embedded_worker()->AddListener(&wait_for_load);
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&self::StartOnIOThread, this,
+                                     start_run_loop.QuitClosure(), &status));
+  load_run_loop.Run();
+  version_->embedded_worker()->RemoveListener(&wait_for_load);
+
+  // The script has loaded but start has not completed yet.
+  ASSERT_EQ(SERVICE_WORKER_ERROR_FAILED, status);
+  EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
+
+  // Simulate execution timeout. Use a delay to prevent killing the worker
+  // before it's started execution.
+  EXPECT_TRUE(version_->ping_worker_timer_.IsRunning());
+  RunOnIOThreadWithDelay(base::Bind(&self::TimeoutWorkerOnIOThread, this),
+                         base::TimeDelta::FromMilliseconds(100));
+  start_run_loop.Run();
+
+  EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status);
+}
+
+IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, TimeoutWorkerInEvent) {
+  RunOnIOThread(base::Bind(&self::SetUpRegistrationOnIOThread, this,
+                           "/service_worker/while_true_in_install_worker.js"));
+
+  // Start a worker.
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
+  base::RunLoop start_run_loop;
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&self::StartOnIOThread, this,
+                                     start_run_loop.QuitClosure(), &status));
+  start_run_loop.Run();
+  ASSERT_EQ(SERVICE_WORKER_OK, status);
+
+  // Dispatch an event.
+  base::RunLoop install_run_loop;
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(&self::InstallOnIOThread, this,
+                                     install_run_loop.QuitClosure(), &status));
+
+  // Simulate execution timeout. Use a delay to prevent killing the worker
+  // before it's started execution.
+  EXPECT_TRUE(version_->ping_worker_timer_.IsRunning());
+  RunOnIOThreadWithDelay(base::Bind(&self::TimeoutWorkerOnIOThread, this),
+                         base::TimeDelta::FromMilliseconds(100));
+  install_run_loop.Run();
+
+  EXPECT_EQ(SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED, status);
+}
+
 IN_PROC_BROWSER_TEST_F(ServiceWorkerVersionBrowserTest, FetchEvent_Response) {
   ServiceWorkerFetchEventResult result;
   ServiceWorkerResponse response;
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
   FetchTestHelper("/service_worker/fetch_event.js",
                   &result, &response, &blob_data_handle);
   ASSERT_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, result);
   EXPECT_EQ(301, response.status_code);
   EXPECT_EQ("Moved Permanently", response.status_text);
   ServiceWorkerHeaderMap expected_headers;
@@ skipping 328 matching lines @@
   const base::string16 kOKTitle2(base::ASCIIToUTF16("OK_2"));
   const base::string16 kFailTitle2(base::ASCIIToUTF16("FAIL_2"));
   content::TitleWatcher title_watcher2(shell()->web_contents(), kOKTitle2);
   title_watcher2.AlsoWaitForTitle(kFailTitle2);
 
   NavigateToURL(shell(), embedded_test_server()->GetURL(kConfirmPageUrl));
   EXPECT_EQ(kOKTitle2, title_watcher2.WaitAndGetTitle());
 }
 
 }  // namespace content