Stop Service Workers that execute JavaScript for too long.

content/browser/service_worker/service_worker_version_unittest.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/basictypes.h"
 #include "base/run_loop.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_registration.h"
@@ skipping 169 matching lines @@
       : ServiceWorkerVersionTest() {}
 
   scoped_ptr<MessageReceiver> GetMessageReceiver() override {
     return make_scoped_ptr(new MessageReceiverDisallowStart());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerFailToStartTest);
 };
 
+class MessageReceiverHangAtScriptEvaluation : public MessageReceiver {
+ public:
+  MessageReceiverHangAtScriptEvaluation() : MessageReceiver() {}
+  ~MessageReceiverHangAtScriptEvaluation() override {}
+
+  void OnStartWorker(int embedded_worker_id,
+                     int64 service_worker_version_id,
+                     const GURL& scope,
+                     const GURL& script_url,
+                     bool pause_after_download) override {
+    if (pause_after_download) {
+      SimulatePausedAfterDownload(embedded_worker_id);
+      return;
+    }
+    SimulateWorkerReadyForInspection(embedded_worker_id);
+    SimulateWorkerScriptLoaded(next_thread_id_++, embedded_worker_id);
+    // To simulate while(true) {} in the script, don't call the following:
+    // SimulateWorkerScriptEvaluated(embedded_worker_id);
+    // SimulateWorkerStarted(embedded_worker_id);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MessageReceiverHangAtScriptEvaluation);
+};
+
+class MessageReceiverHangAtInstall : public MessageReceiver {
+ public:
+  MessageReceiverHangAtInstall() : MessageReceiver() {}
+  ~MessageReceiverHangAtInstall() override {}
+
+  void OnInstallEvent(int embedded_worker_id,
+                      int request_id,
+                      int active_version_id) override {
+    // Do nothing.
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MessageReceiverHangAtInstall);
+};
+
+class ServiceWorkerStartTimeoutTest : public ServiceWorkerVersionTest {
+ protected:
+  ServiceWorkerStartTimeoutTest() : ServiceWorkerVersionTest() {}
+
+  scoped_ptr<MessageReceiver> GetMessageReceiver() override {
+    return make_scoped_ptr(new MessageReceiverHangAtScriptEvaluation());
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerStartTimeoutTest);
+};
+
+class ServiceWorkerEventTimeoutTest : public ServiceWorkerVersionTest {
+ protected:
+  ServiceWorkerEventTimeoutTest() : ServiceWorkerVersionTest() {}
+
+  scoped_ptr<MessageReceiver> GetMessageReceiver() override {
+    return make_scoped_ptr(new MessageReceiverHangAtInstall());
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ServiceWorkerEventTimeoutTest);
+};
+
 TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) {
   // Call StartWorker() multiple times.
   ServiceWorkerStatusCode status1 = SERVICE_WORKER_ERROR_FAILED;
   ServiceWorkerStatusCode status2 = SERVICE_WORKER_ERROR_FAILED;
   ServiceWorkerStatusCode status3 = SERVICE_WORKER_ERROR_FAILED;
   version_->StartWorker(CreateReceiverOnCurrentThread(&status1));
   version_->StartWorker(CreateReceiverOnCurrentThread(&status2));
 
   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
   base::RunLoop().RunUntilIdle();
@@ skipping 235 matching lines @@
   helper_->context()->RemoveAllProviderHostsForProcess(process_id);
   helper_->context()->embedded_worker_registry()->RemoveChildProcessSender(
       process_id);
   base::RunLoop().RunUntilIdle();
 
   // Callback completed.
   EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status);
   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 }
 
+// Test starting a "while(true) {}" worker. StartWorker should timeout.
+TEST_F(ServiceWorkerStartTimeoutTest, ScriptEvaluationTimeout) {
+  ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK;  // dummy value
+  version_->StartWorker(CreateReceiverOnCurrentThread(&status));
+  base::RunLoop().RunUntilIdle();
+
+  // The start callback has not completed yet.
+  EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status);
+  EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
+
+  // The pings have started.
+  EXPECT_TRUE(version_->ping_worker_timer_.IsRunning());
+
+  // Simulate timing out.
+  version_->PingWorker();
+  version_->OnPingTimeout();
+  base::RunLoop().RunUntilIdle();
+
+  // The start callback should have completed with failure.
+  EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status);
+  EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
+}
+
+// Test "while(true) {}" after successful startup (e.g., in an event
+// handler). The worker should be stopped.
+TEST_F(ServiceWorkerEventTimeoutTest, EventTimeout) {
+  ServiceWorkerStatusCode status;
+  version_->StartWorker(CreateReceiverOnCurrentThread(&status));
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(SERVICE_WORKER_OK, status);
+
+  // The pings have started.
+  EXPECT_TRUE(version_->ping_worker_timer_.IsRunning());
+
+  // Simulate a successful ping.
+  version_->PingWorker();
+  version_->OnPongFromWorker();
+  EXPECT_TRUE(version_->ping_worker_timer_.IsRunning());
+
+  // Dispatch an event.
+  version_->SetStatus(ServiceWorkerVersion::INSTALLING);
+  version_->DispatchInstallEvent(0, CreateReceiverOnCurrentThread(&status));
+
+  // Simulate timing out.
+  EXPECT_TRUE(version_->ping_worker_timer_.IsRunning());
+  version_->PingWorker();
+  version_->OnPingTimeout();
+  base::RunLoop().RunUntilIdle();
+
+  // The event callback should have completed with failure.
+  EXPECT_EQ(SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED, status);
+  EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
+}
+
 }  // namespace content