content/browser/service_worker/service_worker_version_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/basictypes.h"
   6 #include "base/run_loop.h"
   7 #include "content/browser/message_port_service.h"
   8 #include "content/browser/service_worker/embedded_worker_registry.h"
   9 #include "content/browser/service_worker/embedded_worker_test_helper.h"
  10 #include "content/browser/service_worker/service_worker_context_core.h"
  11 #include "content/browser/service_worker/service_worker_registration.h"
  12 #include "content/browser/service_worker/service_worker_test_utils.h"
  13 #include "content/browser/service_worker/service_worker_utils.h"
  14 #include "content/browser/service_worker/service_worker_version.h"
  15 #include "content/public/test/test_browser_thread_bundle.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 // IPC messages for testing ---------------------------------------------------
  19
  20 #define IPC_MESSAGE_IMPL
  21 #include "ipc/ipc_message_macros.h"
  22
  23 #define IPC_MESSAGE_START TestMsgStart
  24
  25 IPC_MESSAGE_CONTROL0(TestMsg_Message);
  26 IPC_MESSAGE_ROUTED1(TestMsg_MessageFromWorker, int);
  27
  28 // ---------------------------------------------------------------------------
  29
  30 namespace content {
  31
  32 namespace {
  33
  34 static const int kRenderProcessId = 1;
  35
  36 class MessageReceiver : public EmbeddedWorkerTestHelper {
  37  public:
  38   MessageReceiver()
  39       : EmbeddedWorkerTestHelper(base::FilePath(), kRenderProcessId),
  40         current_embedded_worker_id_(0) {}
  41   ~MessageReceiver() override {}
  42
  43   bool OnMessageToWorker(int thread_id,
  44                          int embedded_worker_id,
  45                          const IPC::Message& message) override {
  46     if (EmbeddedWorkerTestHelper::OnMessageToWorker(
  47             thread_id, embedded_worker_id, message)) {
  48       return true;
  49     }
  50     current_embedded_worker_id_ = embedded_worker_id;
  51     bool handled = true;
  52     IPC_BEGIN_MESSAGE_MAP(MessageReceiver, message)
  53       IPC_MESSAGE_HANDLER(TestMsg_Message, OnMessage)
  54       IPC_MESSAGE_UNHANDLED(handled = false)
  55     IPC_END_MESSAGE_MAP()
  56     return handled;
  57   }
  58
  59   void SimulateSendValueToBrowser(int embedded_worker_id, int value) {
  60     SimulateSend(new TestMsg_MessageFromWorker(embedded_worker_id, value));
  61   }
  62
  63  private:
  64   void OnMessage() {
  65     // Do nothing.
  66   }
  67
  68   int current_embedded_worker_id_;
  69   DISALLOW_COPY_AND_ASSIGN(MessageReceiver);
  70 };
  71
  72 void VerifyCalled(bool* called) {
  73   *called = true;
  74 }
  75
  76 void ObserveStatusChanges(ServiceWorkerVersion* version,
  77                           std::vector<ServiceWorkerVersion::Status>* statuses) {
  78   statuses->push_back(version->status());
  79   version->RegisterStatusChangeCallback(
  80       base::Bind(&ObserveStatusChanges, base::Unretained(version), statuses));
  81 }
  82
  83 void ReceiveFetchResult(ServiceWorkerStatusCode* status,
  84                         ServiceWorkerStatusCode actual_status,
  85                         ServiceWorkerFetchEventResult actual_result,
  86                         const ServiceWorkerResponse& response) {
  87   *status = actual_status;
  88 }
  89
  90 // A specialized listener class to receive test messages from a worker.
  91 class MessageReceiverFromWorker : public EmbeddedWorkerInstance::Listener {
  92  public:
  93   explicit MessageReceiverFromWorker(EmbeddedWorkerInstance* instance)
  94       : instance_(instance) {
  95     instance_->AddListener(this);
  96   }
  97   ~MessageReceiverFromWorker() override { instance_->RemoveListener(this); }
  98
  99   void OnStarted() override { NOTREACHED(); }
 100   void OnStopped(EmbeddedWorkerInstance::Status old_status) override {
 101     NOTREACHED();
 102   }
 103   bool OnMessageReceived(const IPC::Message& message) override {
 104     bool handled = true;
 105     IPC_BEGIN_MESSAGE_MAP(MessageReceiverFromWorker, message)
 106       IPC_MESSAGE_HANDLER(TestMsg_MessageFromWorker, OnMessageFromWorker)
 107       IPC_MESSAGE_UNHANDLED(handled = false)
 108     IPC_END_MESSAGE_MAP()
 109     return handled;
 110   }
 111
 112   void OnMessageFromWorker(int value) { received_values_.push_back(value); }
 113   const std::vector<int>& received_values() const { return received_values_; }
 114
 115  private:
 116   EmbeddedWorkerInstance* instance_;
 117   std::vector<int> received_values_;
 118   DISALLOW_COPY_AND_ASSIGN(MessageReceiverFromWorker);
 119 };
 120
 121 void SetUpDummyMessagePort(std::vector<TransferredMessagePort>* ports) {
 122   int port_id = -1;
 123   MessagePortService::GetInstance()->Create(MSG_ROUTING_NONE, nullptr,
 124                                             &port_id);
 125   TransferredMessagePort dummy_port;
 126   dummy_port.id = port_id;
 127   ports->push_back(dummy_port);
 128 }
 129
 130 }  // namespace
 131
 132 class ServiceWorkerVersionTest : public testing::Test {
 133  protected:
 134   struct RunningStateListener : public ServiceWorkerVersion::Listener {
 135     RunningStateListener() : last_status(ServiceWorkerVersion::STOPPED) {}
 136     ~RunningStateListener() override {}
 137     void OnRunningStateChanged(ServiceWorkerVersion* version) override {
 138       last_status = version->running_status();
 139     }
 140     ServiceWorkerVersion::RunningStatus last_status;
 141   };
 142
 143   ServiceWorkerVersionTest()
 144       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP) {}
 145
 146   void SetUp() override {
 147     helper_ = GetMessageReceiver();
 148
 149     pattern_ = GURL("http://www.example.com/");
 150     registration_ = new ServiceWorkerRegistration(
 151         pattern_,
 152         1L,
 153         helper_->context()->AsWeakPtr());
 154     version_ = new ServiceWorkerVersion(
 155         registration_.get(),
 156         GURL("http://www.example.com/service_worker.js"),
 157         1L,
 158         helper_->context()->AsWeakPtr());
 159     std::vector<ServiceWorkerDatabase::ResourceRecord> records;
 160     records.push_back(
 161         ServiceWorkerDatabase::ResourceRecord(10, version_->script_url(), 100));
 162     version_->script_cache_map()->SetResources(records);
 163
 164     // Make the registration findable via storage functions.
 165     helper_->context()->storage()->LazyInitialize(base::Bind(&base::DoNothing));
 166     base::RunLoop().RunUntilIdle();
 167     ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 168     helper_->context()->storage()->StoreRegistration(
 169         registration_.get(),
 170         version_.get(),
 171         CreateReceiverOnCurrentThread(&status));
 172     base::RunLoop().RunUntilIdle();
 173     ASSERT_EQ(SERVICE_WORKER_OK, status);
 174
 175     // Simulate adding one process to the pattern.
 176     helper_->SimulateAddProcessToPattern(pattern_, kRenderProcessId);
 177     ASSERT_TRUE(helper_->context()->process_manager()
 178         ->PatternHasProcessToRun(pattern_));
 179   }
 180
 181   virtual scoped_ptr<MessageReceiver> GetMessageReceiver() {
 182     return make_scoped_ptr(new MessageReceiver());
 183   }
 184
 185   void TearDown() override {
 186     version_ = 0;
 187     registration_ = 0;
 188     helper_.reset();
 189   }
 190
 191   TestBrowserThreadBundle thread_bundle_;
 192   scoped_ptr<MessageReceiver> helper_;
 193   scoped_refptr<ServiceWorkerRegistration> registration_;
 194   scoped_refptr<ServiceWorkerVersion> version_;
 195   GURL pattern_;
 196
 197  private:
 198   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersionTest);
 199 };
 200
 201 class MessageReceiverDisallowStart : public MessageReceiver {
 202  public:
 203   MessageReceiverDisallowStart()
 204       : MessageReceiver() {}
 205   ~MessageReceiverDisallowStart() override {}
 206
 207   void OnStartWorker(int embedded_worker_id,
 208                      int64 service_worker_version_id,
 209                      const GURL& scope,
 210                      const GURL& script_url,
 211                      bool pause_after_download) override {
 212     // Do nothing.
 213   }
 214
 215  private:
 216   DISALLOW_COPY_AND_ASSIGN(MessageReceiverDisallowStart);
 217 };
 218
 219 class ServiceWorkerFailToStartTest : public ServiceWorkerVersionTest {
 220  protected:
 221   ServiceWorkerFailToStartTest()
 222       : ServiceWorkerVersionTest() {}
 223
 224   scoped_ptr<MessageReceiver> GetMessageReceiver() override {
 225     return make_scoped_ptr(new MessageReceiverDisallowStart());
 226   }
 227
 228  private:
 229   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerFailToStartTest);
 230 };
 231
 232 class MessageReceiverDisallowFetch : public MessageReceiver {
 233  public:
 234   MessageReceiverDisallowFetch() : MessageReceiver() {}
 235   ~MessageReceiverDisallowFetch() override {}
 236
 237   void OnFetchEvent(int embedded_worker_id,
 238                     int request_id,
 239                     const ServiceWorkerFetchRequest& request) override {
 240     // Do nothing.
 241   }
 242
 243  private:
 244   DISALLOW_COPY_AND_ASSIGN(MessageReceiverDisallowFetch);
 245 };
 246
 247 class ServiceWorkerWaitForeverInFetchTest : public ServiceWorkerVersionTest {
 248  protected:
 249   ServiceWorkerWaitForeverInFetchTest() : ServiceWorkerVersionTest() {}
 250
 251   scoped_ptr<MessageReceiver> GetMessageReceiver() override {
 252     return make_scoped_ptr(new MessageReceiverDisallowFetch());
 253   }
 254
 255  private:
 256   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerWaitForeverInFetchTest);
 257 };
 258
 259 TEST_F(ServiceWorkerVersionTest, ConcurrentStartAndStop) {
 260   // Call StartWorker() multiple times.
 261   ServiceWorkerStatusCode status1 = SERVICE_WORKER_ERROR_FAILED;
 262   ServiceWorkerStatusCode status2 = SERVICE_WORKER_ERROR_FAILED;
 263   ServiceWorkerStatusCode status3 = SERVICE_WORKER_ERROR_FAILED;
 264   version_->StartWorker(CreateReceiverOnCurrentThread(&status1));
 265   version_->StartWorker(CreateReceiverOnCurrentThread(&status2));
 266
 267   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
 268   base::RunLoop().RunUntilIdle();
 269   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 270
 271   // Call StartWorker() after it's started.
 272   version_->StartWorker(CreateReceiverOnCurrentThread(&status3));
 273   base::RunLoop().RunUntilIdle();
 274
 275   // All should just succeed.
 276   EXPECT_EQ(SERVICE_WORKER_OK, status1);
 277   EXPECT_EQ(SERVICE_WORKER_OK, status2);
 278   EXPECT_EQ(SERVICE_WORKER_OK, status3);
 279
 280   // Call StopWorker() multiple times.
 281   status1 = SERVICE_WORKER_ERROR_FAILED;
 282   status2 = SERVICE_WORKER_ERROR_FAILED;
 283   version_->StopWorker(CreateReceiverOnCurrentThread(&status1));
 284   version_->StopWorker(CreateReceiverOnCurrentThread(&status2));
 285
 286   EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status());
 287   base::RunLoop().RunUntilIdle();
 288   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 289
 290   // All StopWorker should just succeed.
 291   EXPECT_EQ(SERVICE_WORKER_OK, status1);
 292   EXPECT_EQ(SERVICE_WORKER_OK, status2);
 293
 294   // Start worker again.
 295   status1 = SERVICE_WORKER_ERROR_FAILED;
 296   status2 = SERVICE_WORKER_ERROR_FAILED;
 297   status3 = SERVICE_WORKER_ERROR_FAILED;
 298
 299   version_->StartWorker(CreateReceiverOnCurrentThread(&status1));
 300
 301   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
 302   base::RunLoop().RunUntilIdle();
 303   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 304
 305   // Call StopWorker()
 306   status2 = SERVICE_WORKER_ERROR_FAILED;
 307   version_->StopWorker(CreateReceiverOnCurrentThread(&status2));
 308
 309   // And try calling StartWorker while StopWorker is in queue.
 310   version_->StartWorker(CreateReceiverOnCurrentThread(&status3));
 311
 312   EXPECT_EQ(ServiceWorkerVersion::STOPPING, version_->running_status());
 313   base::RunLoop().RunUntilIdle();
 314   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 315
 316   // All should just succeed.
 317   EXPECT_EQ(SERVICE_WORKER_OK, status1);
 318   EXPECT_EQ(SERVICE_WORKER_OK, status2);
 319   EXPECT_EQ(SERVICE_WORKER_OK, status3);
 320 }
 321
 322 TEST_F(ServiceWorkerVersionTest, DispatchEventToStoppedWorker) {
 323   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 324
 325   // Dispatch an event without starting the worker.
 326   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 327   version_->SetStatus(ServiceWorkerVersion::INSTALLING);
 328   version_->DispatchInstallEvent(CreateReceiverOnCurrentThread(&status));
 329   base::RunLoop().RunUntilIdle();
 330   EXPECT_EQ(SERVICE_WORKER_OK, status);
 331
 332   // The worker should be now started.
 333   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 334
 335   // Stop the worker, and then dispatch an event immediately after that.
 336   status = SERVICE_WORKER_ERROR_FAILED;
 337   ServiceWorkerStatusCode stop_status = SERVICE_WORKER_ERROR_FAILED;
 338   version_->StopWorker(CreateReceiverOnCurrentThread(&stop_status));
 339   version_->DispatchInstallEvent(CreateReceiverOnCurrentThread(&status));
 340   base::RunLoop().RunUntilIdle();
 341   EXPECT_EQ(SERVICE_WORKER_OK, stop_status);
 342
 343   // Dispatch an event should return SERVICE_WORKER_OK since the worker
 344   // should have been restarted to dispatch the event.
 345   EXPECT_EQ(SERVICE_WORKER_OK, status);
 346
 347   // The worker should be now started again.
 348   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 349 }
 350
 351 TEST_F(ServiceWorkerVersionTest, ReceiveMessageFromWorker) {
 352   // Start worker.
 353   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 354   version_->StartWorker(CreateReceiverOnCurrentThread(&status));
 355   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
 356   base::RunLoop().RunUntilIdle();
 357   EXPECT_EQ(SERVICE_WORKER_OK, status);
 358   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 359
 360   MessageReceiverFromWorker receiver(version_->embedded_worker());
 361
 362   // Simulate sending some dummy values from the worker.
 363   helper_->SimulateSendValueToBrowser(
 364       version_->embedded_worker()->embedded_worker_id(), 555);
 365   helper_->SimulateSendValueToBrowser(
 366       version_->embedded_worker()->embedded_worker_id(), 777);
 367
 368   // Verify the receiver received the values.
 369   ASSERT_EQ(2U, receiver.received_values().size());
 370   EXPECT_EQ(555, receiver.received_values()[0]);
 371   EXPECT_EQ(777, receiver.received_values()[1]);
 372 }
 373
 374 TEST_F(ServiceWorkerVersionTest, InstallAndWaitCompletion) {
 375   version_->SetStatus(ServiceWorkerVersion::INSTALLING);
 376
 377   // Dispatch an install event.
 378   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 379   version_->DispatchInstallEvent(CreateReceiverOnCurrentThread(&status));
 380
 381   // Wait for the completion.
 382   bool status_change_called = false;
 383   version_->RegisterStatusChangeCallback(
 384       base::Bind(&VerifyCalled, &status_change_called));
 385
 386   base::RunLoop().RunUntilIdle();
 387
 388   // Version's status must not have changed during installation.
 389   EXPECT_EQ(SERVICE_WORKER_OK, status);
 390   EXPECT_FALSE(status_change_called);
 391   EXPECT_EQ(ServiceWorkerVersion::INSTALLING, version_->status());
 392 }
 393
 394 TEST_F(ServiceWorkerVersionTest, ActivateAndWaitCompletion) {
 395   version_->SetStatus(ServiceWorkerVersion::ACTIVATING);
 396
 397   // Dispatch an activate event.
 398   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 399   version_->DispatchActivateEvent(CreateReceiverOnCurrentThread(&status));
 400
 401   // Wait for the completion.
 402   bool status_change_called = false;
 403   version_->RegisterStatusChangeCallback(
 404       base::Bind(&VerifyCalled, &status_change_called));
 405
 406   base::RunLoop().RunUntilIdle();
 407
 408   // Version's status must not have changed during activation.
 409   EXPECT_EQ(SERVICE_WORKER_OK, status);
 410   EXPECT_FALSE(status_change_called);
 411   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING, version_->status());
 412 }
 413
 414 TEST_F(ServiceWorkerVersionTest, RepeatedlyObserveStatusChanges) {
 415   EXPECT_EQ(ServiceWorkerVersion::NEW, version_->status());
 416
 417   // Repeatedly observe status changes (the callback re-registers itself).
 418   std::vector<ServiceWorkerVersion::Status> statuses;
 419   version_->RegisterStatusChangeCallback(
 420       base::Bind(&ObserveStatusChanges, version_, &statuses));
 421
 422   version_->SetStatus(ServiceWorkerVersion::INSTALLING);
 423   version_->SetStatus(ServiceWorkerVersion::INSTALLED);
 424   version_->SetStatus(ServiceWorkerVersion::ACTIVATING);
 425   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
 426   version_->SetStatus(ServiceWorkerVersion::REDUNDANT);
 427
 428   // Verify that we could successfully observe repeated status changes.
 429   ASSERT_EQ(5U, statuses.size());
 430   ASSERT_EQ(ServiceWorkerVersion::INSTALLING, statuses[0]);
 431   ASSERT_EQ(ServiceWorkerVersion::INSTALLED, statuses[1]);
 432   ASSERT_EQ(ServiceWorkerVersion::ACTIVATING, statuses[2]);
 433   ASSERT_EQ(ServiceWorkerVersion::ACTIVATED, statuses[3]);
 434   ASSERT_EQ(ServiceWorkerVersion::REDUNDANT, statuses[4]);
 435 }
 436
 437 TEST_F(ServiceWorkerVersionTest, IdleTimeout) {
 438   // Used to reliably test when the idle time gets reset regardless of clock
 439   // granularity.
 440   const base::TimeDelta kOneSecond = base::TimeDelta::FromSeconds(1);
 441
 442   // Verify the timer is not running when version initializes its status.
 443   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
 444   EXPECT_FALSE(version_->timeout_timer_.IsRunning());
 445
 446   // Verify the timer is running after the worker is started.
 447   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 448   version_->StartWorker(CreateReceiverOnCurrentThread(&status));
 449   base::RunLoop().RunUntilIdle();
 450   EXPECT_EQ(SERVICE_WORKER_OK, status);
 451   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
 452   EXPECT_FALSE(version_->idle_time_.is_null());
 453
 454   // The idle time should be reset if the worker is restarted without
 455   // controllee.
 456   status = SERVICE_WORKER_ERROR_FAILED;
 457   version_->idle_time_ -= kOneSecond;
 458   base::TimeTicks idle_time = version_->idle_time_;
 459   version_->StopWorker(CreateReceiverOnCurrentThread(&status));
 460   base::RunLoop().RunUntilIdle();
 461   EXPECT_EQ(SERVICE_WORKER_OK, status);
 462   status = SERVICE_WORKER_ERROR_FAILED;
 463   version_->StartWorker(CreateReceiverOnCurrentThread(&status));
 464   base::RunLoop().RunUntilIdle();
 465   EXPECT_EQ(SERVICE_WORKER_OK, status);
 466   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
 467   EXPECT_LT(idle_time, version_->idle_time_);
 468
 469   // Adding a controllee resets the idle time.
 470   version_->idle_time_ -= kOneSecond;
 471   idle_time = version_->idle_time_;
 472   scoped_ptr<ServiceWorkerProviderHost> host(new ServiceWorkerProviderHost(
 473       33 /* dummy render process id */, MSG_ROUTING_NONE /* render_frame_id */,
 474       1 /* dummy provider_id */, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
 475       helper_->context()->AsWeakPtr(), NULL));
 476   version_->AddControllee(host.get());
 477   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
 478   EXPECT_LT(idle_time, version_->idle_time_);
 479
 480   // Completing an event resets the idle time.
 481   status = SERVICE_WORKER_ERROR_FAILED;
 482   version_->idle_time_ -= kOneSecond;
 483   idle_time = version_->idle_time_;
 484   version_->DispatchFetchEvent(ServiceWorkerFetchRequest(),
 485                                base::Bind(&base::DoNothing),
 486                                base::Bind(&ReceiveFetchResult, &status));
 487   base::RunLoop().RunUntilIdle();
 488
 489   EXPECT_EQ(SERVICE_WORKER_OK, status);
 490   EXPECT_LT(idle_time, version_->idle_time_);
 491
 492   // Dispatching a message event resets the idle time.
 493   std::vector<TransferredMessagePort> ports;
 494   SetUpDummyMessagePort(&ports);
 495   status = SERVICE_WORKER_ERROR_FAILED;
 496   version_->idle_time_ -= kOneSecond;
 497   idle_time = version_->idle_time_;
 498   version_->DispatchMessageEvent(base::string16(), ports,
 499                                  CreateReceiverOnCurrentThread(&status));
 500   base::RunLoop().RunUntilIdle();
 501   MessagePortService::GetInstance()->Destroy(ports[0].id);
 502
 503   EXPECT_EQ(SERVICE_WORKER_OK, status);
 504   EXPECT_LT(idle_time, version_->idle_time_);
 505 }
 506
 507 TEST_F(ServiceWorkerVersionTest, SetDevToolsAttached) {
 508   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 509   version_->StartWorker(CreateReceiverOnCurrentThread(&status));
 510
 511   ASSERT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
 512
 513   ASSERT_TRUE(version_->timeout_timer_.IsRunning());
 514   ASSERT_FALSE(version_->start_time_.is_null());
 515   ASSERT_FALSE(version_->skip_recording_startup_time_);
 516
 517   // Simulate DevTools is attached. This should deactivate the timer for start
 518   // timeout, but not stop the timer itself.
 519   version_->SetDevToolsAttached(true);
 520   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
 521   EXPECT_TRUE(version_->start_time_.is_null());
 522   EXPECT_TRUE(version_->skip_recording_startup_time_);
 523
 524   // Simulate DevTools is detached. This should reactivate the timer for start
 525   // timeout.
 526   version_->SetDevToolsAttached(false);
 527   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
 528   EXPECT_FALSE(version_->start_time_.is_null());
 529   EXPECT_TRUE(version_->skip_recording_startup_time_);
 530
 531   base::RunLoop().RunUntilIdle();
 532   EXPECT_EQ(SERVICE_WORKER_OK, status);
 533   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 534 }
 535
 536 TEST_F(ServiceWorkerVersionTest, StoppingBeforeDestruct) {
 537   RunningStateListener listener;
 538   version_->AddListener(&listener);
 539
 540   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 541   version_->StartWorker(CreateReceiverOnCurrentThread(&status));
 542   base::RunLoop().RunUntilIdle();
 543   EXPECT_EQ(SERVICE_WORKER_OK, status);
 544   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 545   EXPECT_EQ(ServiceWorkerVersion::RUNNING, listener.last_status);
 546
 547   version_ = nullptr;
 548   EXPECT_EQ(ServiceWorkerVersion::STOPPING, listener.last_status);
 549 }
 550
 551 TEST_F(ServiceWorkerWaitForeverInFetchTest, RequestTimeout) {
 552   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK;  // dummy value
 553
 554   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
 555   version_->DispatchFetchEvent(ServiceWorkerFetchRequest(),
 556                                base::Bind(&base::DoNothing),
 557                                base::Bind(&ReceiveFetchResult, &status));
 558   base::RunLoop().RunUntilIdle();
 559
 560   // Callback has not completed yet.
 561   EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status);
 562   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version_->running_status());
 563
 564   // Simulate timeout.
 565   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
 566   version_->SetAllRequestTimes(
 567       base::TimeTicks::Now() -
 568       base::TimeDelta::FromMinutes(
 569           ServiceWorkerVersion::kRequestTimeoutMinutes + 1));
 570   version_->timeout_timer_.user_task().Run();
 571   base::RunLoop().RunUntilIdle();
 572   EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status);
 573   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 574 }
 575
 576 TEST_F(ServiceWorkerFailToStartTest, RendererCrash) {
 577   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK;  // dummy value
 578   version_->StartWorker(
 579       CreateReceiverOnCurrentThread(&status));
 580   base::RunLoop().RunUntilIdle();
 581
 582   // Callback has not completed yet.
 583   EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status);
 584   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
 585
 586   // Simulate renderer crash: do what
 587   // ServiceWorkerDispatcherHost::OnFilterRemoved does.
 588   int process_id = helper_->mock_render_process_id();
 589   helper_->context()->RemoveAllProviderHostsForProcess(process_id);
 590   helper_->context()->embedded_worker_registry()->RemoveChildProcessSender(
 591       process_id);
 592   base::RunLoop().RunUntilIdle();
 593
 594   // Callback completed.
 595   EXPECT_EQ(SERVICE_WORKER_ERROR_START_WORKER_FAILED, status);
 596   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 597 }
 598
 599 TEST_F(ServiceWorkerFailToStartTest, Timeout) {
 600   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_NETWORK;  // dummy value
 601
 602   // We could just call StartWorker but make it interesting and test
 603   // starting the worker as part of dispatching an event.
 604   version_->SetStatus(ServiceWorkerVersion::ACTIVATING);
 605   version_->DispatchActivateEvent(CreateReceiverOnCurrentThread(&status));
 606   base::RunLoop().RunUntilIdle();
 607
 608   // Callback has not completed yet.
 609   EXPECT_EQ(SERVICE_WORKER_ERROR_NETWORK, status);
 610   EXPECT_EQ(ServiceWorkerVersion::STARTING, version_->running_status());
 611
 612   // Simulate timeout.
 613   EXPECT_TRUE(version_->timeout_timer_.IsRunning());
 614   version_->start_time_ =
 615       base::TimeTicks::Now() -
 616       base::TimeDelta::FromMinutes(
 617           ServiceWorkerVersion::kStartWorkerTimeoutMinutes + 1);
 618   version_->timeout_timer_.user_task().Run();
 619   base::RunLoop().RunUntilIdle();
 620   EXPECT_EQ(SERVICE_WORKER_ERROR_TIMEOUT, status);
 621   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version_->running_status());
 622 }
 623
 624 }  // namespace content