content/browser/service_worker/service_worker_job_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/files/scoped_temp_dir.h"
   6 #include "base/logging.h"
   7 #include "base/run_loop.h"
   8 #include "content/browser/browser_thread_impl.h"
   9 #include "content/browser/service_worker/embedded_worker_registry.h"
  10 #include "content/browser/service_worker/embedded_worker_test_helper.h"
  11 #include "content/browser/service_worker/service_worker_context_core.h"
  12 #include "content/browser/service_worker/service_worker_disk_cache.h"
  13 #include "content/browser/service_worker/service_worker_job_coordinator.h"
  14 #include "content/browser/service_worker/service_worker_registration.h"
  15 #include "content/browser/service_worker/service_worker_registration_status.h"
  16 #include "content/browser/service_worker/service_worker_test_utils.h"
  17 #include "content/common/service_worker/service_worker_messages.h"
  18 #include "content/public/test/test_browser_thread_bundle.h"
  19 #include "ipc/ipc_test_sink.h"
  20 #include "net/base/io_buffer.h"
  21 #include "net/base/net_errors.h"
  22 #include "net/base/test_completion_callback.h"
  23 #include "net/http/http_response_headers.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25
  26 using net::IOBuffer;
  27 using net::TestCompletionCallback;
  28 using net::WrappedIOBuffer;
  29
  30 // Unit tests for testing all job registration tasks.
  31 namespace content {
  32
  33 namespace {
  34
  35 int kMockRenderProcessId = 88;
  36
  37 void SaveRegistrationCallback(
  38     ServiceWorkerStatusCode expected_status,
  39     bool* called,
  40     scoped_refptr<ServiceWorkerRegistration>* registration_out,
  41     ServiceWorkerStatusCode status,
  42     const std::string& status_message,
  43     ServiceWorkerRegistration* registration) {
  44   EXPECT_EQ(expected_status, status);
  45   *called = true;
  46   *registration_out = registration;
  47 }
  48
  49 void SaveFoundRegistrationCallback(
  50     ServiceWorkerStatusCode expected_status,
  51     bool* called,
  52     scoped_refptr<ServiceWorkerRegistration>* registration,
  53     ServiceWorkerStatusCode status,
  54     const scoped_refptr<ServiceWorkerRegistration>& result) {
  55   EXPECT_EQ(expected_status, status);
  56   *called = true;
  57   *registration = result;
  58 }
  59
  60 // Creates a callback which both keeps track of if it's been called,
  61 // as well as the resulting registration. Whent the callback is fired,
  62 // it ensures that the resulting status matches the expectation.
  63 // 'called' is useful for making sure a sychronous callback is or
  64 // isn't called.
  65 ServiceWorkerRegisterJob::RegistrationCallback SaveRegistration(
  66     ServiceWorkerStatusCode expected_status,
  67     bool* called,
  68     scoped_refptr<ServiceWorkerRegistration>* registration) {
  69   *called = false;
  70   return base::Bind(
  71       &SaveRegistrationCallback, expected_status, called, registration);
  72 }
  73
  74 ServiceWorkerStorage::FindRegistrationCallback SaveFoundRegistration(
  75     ServiceWorkerStatusCode expected_status,
  76     bool* called,
  77     scoped_refptr<ServiceWorkerRegistration>* registration) {
  78   *called = false;
  79   return base::Bind(&SaveFoundRegistrationCallback,
  80                     expected_status,
  81                     called,
  82                     registration);
  83 }
  84
  85 void SaveUnregistrationCallback(ServiceWorkerStatusCode expected_status,
  86                                 bool* called,
  87                                 int64 registration_id,
  88                                 ServiceWorkerStatusCode status) {
  89   EXPECT_EQ(expected_status, status);
  90   *called = true;
  91 }
  92
  93 ServiceWorkerUnregisterJob::UnregistrationCallback SaveUnregistration(
  94     ServiceWorkerStatusCode expected_status,
  95     bool* called) {
  96   *called = false;
  97   return base::Bind(&SaveUnregistrationCallback, expected_status, called);
  98 }
  99
 100 }  // namespace
 101
 102 class ServiceWorkerJobTest : public testing::Test {
 103  public:
 104   ServiceWorkerJobTest()
 105       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
 106         render_process_id_(kMockRenderProcessId) {}
 107
 108   void SetUp() override {
 109     helper_.reset(
 110         new EmbeddedWorkerTestHelper(base::FilePath(), render_process_id_));
 111   }
 112
 113   void TearDown() override { helper_.reset(); }
 114
 115   ServiceWorkerContextCore* context() const { return helper_->context(); }
 116
 117   ServiceWorkerJobCoordinator* job_coordinator() const {
 118     return context()->job_coordinator();
 119   }
 120   ServiceWorkerStorage* storage() const { return context()->storage(); }
 121
 122  protected:
 123   scoped_refptr<ServiceWorkerRegistration> RunRegisterJob(
 124       const GURL& pattern,
 125       const GURL& script_url,
 126       ServiceWorkerStatusCode expected_status = SERVICE_WORKER_OK);
 127   void RunUnregisterJob(
 128       const GURL& pattern,
 129       ServiceWorkerStatusCode expected_status = SERVICE_WORKER_OK);
 130   scoped_refptr<ServiceWorkerRegistration> FindRegistrationForPattern(
 131       const GURL& pattern,
 132       ServiceWorkerStatusCode expected_status = SERVICE_WORKER_OK);
 133   scoped_ptr<ServiceWorkerProviderHost> CreateControllee();
 134
 135   TestBrowserThreadBundle browser_thread_bundle_;
 136   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
 137   int render_process_id_;
 138 };
 139
 140 scoped_refptr<ServiceWorkerRegistration> ServiceWorkerJobTest::RunRegisterJob(
 141     const GURL& pattern,
 142     const GURL& script_url,
 143     ServiceWorkerStatusCode expected_status) {
 144   scoped_refptr<ServiceWorkerRegistration> registration;
 145   bool called;
 146   job_coordinator()->Register(
 147       pattern, script_url, NULL,
 148       SaveRegistration(expected_status, &called, &registration));
 149   EXPECT_FALSE(called);
 150   base::RunLoop().RunUntilIdle();
 151   EXPECT_TRUE(called);
 152   return registration;
 153 }
 154
 155 void ServiceWorkerJobTest::RunUnregisterJob(
 156     const GURL& pattern,
 157     ServiceWorkerStatusCode expected_status) {
 158   bool called;
 159   job_coordinator()->Unregister(pattern,
 160                                 SaveUnregistration(expected_status, &called));
 161   EXPECT_FALSE(called);
 162   base::RunLoop().RunUntilIdle();
 163   EXPECT_TRUE(called);
 164 }
 165
 166 scoped_refptr<ServiceWorkerRegistration>
 167 ServiceWorkerJobTest::FindRegistrationForPattern(
 168     const GURL& pattern,
 169     ServiceWorkerStatusCode expected_status) {
 170   bool called;
 171   scoped_refptr<ServiceWorkerRegistration> registration;
 172   storage()->FindRegistrationForPattern(
 173       pattern,
 174       SaveFoundRegistration(expected_status, &called, &registration));
 175
 176   EXPECT_FALSE(called);
 177   base::RunLoop().RunUntilIdle();
 178   EXPECT_TRUE(called);
 179   return registration;
 180 }
 181
 182 scoped_ptr<ServiceWorkerProviderHost> ServiceWorkerJobTest::CreateControllee() {
 183   return scoped_ptr<ServiceWorkerProviderHost>(new ServiceWorkerProviderHost(
 184       33 /* dummy render_process id */, MSG_ROUTING_NONE /* render_frame_id */,
 185       1 /* dummy provider_id */, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
 186       helper_->context()->AsWeakPtr(), NULL));
 187 }
 188
 189 TEST_F(ServiceWorkerJobTest, SameDocumentSameRegistration) {
 190   scoped_refptr<ServiceWorkerRegistration> original_registration =
 191       RunRegisterJob(GURL("http://www.example.com/"),
 192                      GURL("http://www.example.com/service_worker.js"));
 193   bool called;
 194   scoped_refptr<ServiceWorkerRegistration> registration1;
 195   storage()->FindRegistrationForDocument(
 196       GURL("http://www.example.com/"),
 197       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration1));
 198   scoped_refptr<ServiceWorkerRegistration> registration2;
 199   storage()->FindRegistrationForDocument(
 200       GURL("http://www.example.com/"),
 201       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration2));
 202   base::RunLoop().RunUntilIdle();
 203   EXPECT_TRUE(called);
 204   ASSERT_TRUE(registration1.get());
 205   ASSERT_EQ(registration1, original_registration);
 206   ASSERT_EQ(registration1, registration2);
 207 }
 208
 209 TEST_F(ServiceWorkerJobTest, SameMatchSameRegistration) {
 210   bool called;
 211   scoped_refptr<ServiceWorkerRegistration> original_registration =
 212       RunRegisterJob(GURL("http://www.example.com/"),
 213                      GURL("http://www.example.com/service_worker.js"));
 214   ASSERT_NE(static_cast<ServiceWorkerRegistration*>(NULL),
 215             original_registration.get());
 216
 217   scoped_refptr<ServiceWorkerRegistration> registration1;
 218   storage()->FindRegistrationForDocument(
 219       GURL("http://www.example.com/one"),
 220       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration1));
 221   base::RunLoop().RunUntilIdle();
 222   EXPECT_TRUE(called);
 223
 224   scoped_refptr<ServiceWorkerRegistration> registration2;
 225   storage()->FindRegistrationForDocument(
 226       GURL("http://www.example.com/two"),
 227       SaveFoundRegistration(SERVICE_WORKER_OK, &called, &registration2));
 228   base::RunLoop().RunUntilIdle();
 229   EXPECT_TRUE(called);
 230   ASSERT_EQ(registration1, original_registration);
 231   ASSERT_EQ(registration1, registration2);
 232 }
 233
 234 TEST_F(ServiceWorkerJobTest, DifferentMatchDifferentRegistration) {
 235   bool called1;
 236   scoped_refptr<ServiceWorkerRegistration> original_registration1;
 237   job_coordinator()->Register(
 238       GURL("http://www.example.com/one/"),
 239       GURL("http://www.example.com/service_worker.js"),
 240       NULL,
 241       SaveRegistration(SERVICE_WORKER_OK, &called1, &original_registration1));
 242
 243   bool called2;
 244   scoped_refptr<ServiceWorkerRegistration> original_registration2;
 245   job_coordinator()->Register(
 246       GURL("http://www.example.com/two/"),
 247       GURL("http://www.example.com/service_worker.js"),
 248       NULL,
 249       SaveRegistration(SERVICE_WORKER_OK, &called2, &original_registration2));
 250
 251   EXPECT_FALSE(called1);
 252   EXPECT_FALSE(called2);
 253   base::RunLoop().RunUntilIdle();
 254   EXPECT_TRUE(called2);
 255   EXPECT_TRUE(called1);
 256
 257   scoped_refptr<ServiceWorkerRegistration> registration1;
 258   storage()->FindRegistrationForDocument(
 259       GURL("http://www.example.com/one/"),
 260       SaveFoundRegistration(SERVICE_WORKER_OK, &called1, &registration1));
 261   scoped_refptr<ServiceWorkerRegistration> registration2;
 262   storage()->FindRegistrationForDocument(
 263       GURL("http://www.example.com/two/"),
 264       SaveFoundRegistration(SERVICE_WORKER_OK, &called2, &registration2));
 265
 266   base::RunLoop().RunUntilIdle();
 267   EXPECT_TRUE(called2);
 268   EXPECT_TRUE(called1);
 269   ASSERT_NE(registration1, registration2);
 270 }
 271
 272 // Make sure basic registration is working.
 273 TEST_F(ServiceWorkerJobTest, Register) {
 274   scoped_refptr<ServiceWorkerRegistration> registration =
 275       RunRegisterJob(GURL("http://www.example.com/"),
 276                      GURL("http://www.example.com/service_worker.js"));
 277
 278   ASSERT_NE(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
 279 }
 280
 281 // Make sure registrations are cleaned up when they are unregistered.
 282 TEST_F(ServiceWorkerJobTest, Unregister) {
 283   GURL pattern("http://www.example.com/");
 284
 285   scoped_refptr<ServiceWorkerRegistration> registration =
 286       RunRegisterJob(pattern, GURL("http://www.example.com/service_worker.js"));
 287
 288   RunUnregisterJob(pattern);
 289
 290   ASSERT_TRUE(registration->HasOneRef());
 291
 292   registration = FindRegistrationForPattern(pattern,
 293                                             SERVICE_WORKER_ERROR_NOT_FOUND);
 294
 295   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
 296 }
 297
 298 TEST_F(ServiceWorkerJobTest, Unregister_NothingRegistered) {
 299   GURL pattern("http://www.example.com/");
 300
 301   RunUnregisterJob(pattern, SERVICE_WORKER_ERROR_NOT_FOUND);
 302 }
 303
 304 // Make sure registering a new script creates a new version and shares an
 305 // existing registration.
 306 TEST_F(ServiceWorkerJobTest, RegisterNewScript) {
 307   GURL pattern("http://www.example.com/");
 308
 309   scoped_refptr<ServiceWorkerRegistration> old_registration =
 310       RunRegisterJob(pattern, GURL("http://www.example.com/service_worker.js"));
 311
 312   scoped_refptr<ServiceWorkerRegistration> old_registration_by_pattern =
 313       FindRegistrationForPattern(pattern);
 314
 315   ASSERT_EQ(old_registration, old_registration_by_pattern);
 316   old_registration_by_pattern = NULL;
 317
 318   scoped_refptr<ServiceWorkerRegistration> new_registration =
 319       RunRegisterJob(pattern,
 320                      GURL("http://www.example.com/service_worker_new.js"));
 321
 322   ASSERT_EQ(old_registration, new_registration);
 323
 324   scoped_refptr<ServiceWorkerRegistration> new_registration_by_pattern =
 325       FindRegistrationForPattern(pattern);
 326
 327   ASSERT_EQ(new_registration, new_registration_by_pattern);
 328 }
 329
 330 // Make sure that when registering a duplicate pattern+script_url
 331 // combination, that the same registration is used.
 332 TEST_F(ServiceWorkerJobTest, RegisterDuplicateScript) {
 333   GURL pattern("http://www.example.com/");
 334   GURL script_url("http://www.example.com/service_worker.js");
 335
 336   scoped_refptr<ServiceWorkerRegistration> old_registration =
 337       RunRegisterJob(pattern, script_url);
 338
 339   scoped_refptr<ServiceWorkerRegistration> old_registration_by_pattern =
 340       FindRegistrationForPattern(pattern);
 341
 342   ASSERT_TRUE(old_registration_by_pattern.get());
 343
 344   scoped_refptr<ServiceWorkerRegistration> new_registration =
 345       RunRegisterJob(pattern, script_url);
 346
 347   ASSERT_EQ(old_registration, new_registration);
 348
 349   ASSERT_FALSE(old_registration->HasOneRef());
 350
 351   scoped_refptr<ServiceWorkerRegistration> new_registration_by_pattern =
 352       FindRegistrationForPattern(pattern);
 353
 354   ASSERT_EQ(new_registration, old_registration);
 355 }
 356
 357 class FailToStartWorkerTestHelper : public EmbeddedWorkerTestHelper {
 358  public:
 359   explicit FailToStartWorkerTestHelper(int mock_render_process_id)
 360       : EmbeddedWorkerTestHelper(base::FilePath(), mock_render_process_id) {}
 361
 362   void OnStartWorker(int embedded_worker_id,
 363                      int64 service_worker_version_id,
 364                      const GURL& scope,
 365                      const GURL& script_url,
 366                      bool pause_after_download) override {
 367     EmbeddedWorkerInstance* worker = registry()->GetWorker(embedded_worker_id);
 368     registry()->OnWorkerStopped(worker->process_id(), embedded_worker_id);
 369   }
 370 };
 371
 372 TEST_F(ServiceWorkerJobTest, Register_FailToStartWorker) {
 373   helper_.reset(new FailToStartWorkerTestHelper(render_process_id_));
 374
 375   scoped_refptr<ServiceWorkerRegistration> registration =
 376       RunRegisterJob(GURL("http://www.example.com/"),
 377                      GURL("http://www.example.com/service_worker.js"),
 378                      SERVICE_WORKER_ERROR_START_WORKER_FAILED);
 379
 380   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(NULL), registration);
 381 }
 382
 383 // Register and then unregister the pattern, in parallel. Job coordinator should
 384 // process jobs until the last job.
 385 TEST_F(ServiceWorkerJobTest, ParallelRegUnreg) {
 386   GURL pattern("http://www.example.com/");
 387   GURL script_url("http://www.example.com/service_worker.js");
 388
 389   bool registration_called = false;
 390   scoped_refptr<ServiceWorkerRegistration> registration;
 391   job_coordinator()->Register(
 392       pattern,
 393       script_url,
 394       NULL,
 395       SaveRegistration(SERVICE_WORKER_OK, &registration_called, &registration));
 396
 397   bool unregistration_called = false;
 398   job_coordinator()->Unregister(
 399       pattern,
 400       SaveUnregistration(SERVICE_WORKER_OK, &unregistration_called));
 401
 402   ASSERT_FALSE(registration_called);
 403   ASSERT_FALSE(unregistration_called);
 404   base::RunLoop().RunUntilIdle();
 405   ASSERT_TRUE(registration_called);
 406   ASSERT_TRUE(unregistration_called);
 407
 408   registration = FindRegistrationForPattern(pattern,
 409                                             SERVICE_WORKER_ERROR_NOT_FOUND);
 410
 411   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 412 }
 413
 414 // Register conflicting scripts for the same pattern. The most recent
 415 // registration should win, and the old registration should have been
 416 // shutdown.
 417 TEST_F(ServiceWorkerJobTest, ParallelRegNewScript) {
 418   GURL pattern("http://www.example.com/");
 419
 420   GURL script_url1("http://www.example.com/service_worker1.js");
 421   bool registration1_called = false;
 422   scoped_refptr<ServiceWorkerRegistration> registration1;
 423   job_coordinator()->Register(
 424       pattern,
 425       script_url1,
 426       NULL,
 427       SaveRegistration(
 428           SERVICE_WORKER_OK, &registration1_called, &registration1));
 429
 430   GURL script_url2("http://www.example.com/service_worker2.js");
 431   bool registration2_called = false;
 432   scoped_refptr<ServiceWorkerRegistration> registration2;
 433   job_coordinator()->Register(
 434       pattern,
 435       script_url2,
 436       NULL,
 437       SaveRegistration(
 438           SERVICE_WORKER_OK, &registration2_called, &registration2));
 439
 440   ASSERT_FALSE(registration1_called);
 441   ASSERT_FALSE(registration2_called);
 442   base::RunLoop().RunUntilIdle();
 443   ASSERT_TRUE(registration1_called);
 444   ASSERT_TRUE(registration2_called);
 445
 446   scoped_refptr<ServiceWorkerRegistration> registration =
 447       FindRegistrationForPattern(pattern);
 448
 449   ASSERT_EQ(registration2, registration);
 450 }
 451
 452 // Register the exact same pattern + script. Requests should be
 453 // coalesced such that both callers get the exact same registration
 454 // object.
 455 TEST_F(ServiceWorkerJobTest, ParallelRegSameScript) {
 456   GURL pattern("http://www.example.com/");
 457
 458   GURL script_url("http://www.example.com/service_worker1.js");
 459   bool registration1_called = false;
 460   scoped_refptr<ServiceWorkerRegistration> registration1;
 461   job_coordinator()->Register(
 462       pattern,
 463       script_url,
 464       NULL,
 465       SaveRegistration(
 466           SERVICE_WORKER_OK, &registration1_called, &registration1));
 467
 468   bool registration2_called = false;
 469   scoped_refptr<ServiceWorkerRegistration> registration2;
 470   job_coordinator()->Register(
 471       pattern,
 472       script_url,
 473       NULL,
 474       SaveRegistration(
 475           SERVICE_WORKER_OK, &registration2_called, &registration2));
 476
 477   ASSERT_FALSE(registration1_called);
 478   ASSERT_FALSE(registration2_called);
 479   base::RunLoop().RunUntilIdle();
 480   ASSERT_TRUE(registration1_called);
 481   ASSERT_TRUE(registration2_called);
 482
 483   ASSERT_EQ(registration1, registration2);
 484
 485   scoped_refptr<ServiceWorkerRegistration> registration =
 486       FindRegistrationForPattern(pattern);
 487
 488   ASSERT_EQ(registration, registration1);
 489 }
 490
 491 // Call simulataneous unregister calls.
 492 TEST_F(ServiceWorkerJobTest, ParallelUnreg) {
 493   GURL pattern("http://www.example.com/");
 494
 495   GURL script_url("http://www.example.com/service_worker.js");
 496   bool unregistration1_called = false;
 497   job_coordinator()->Unregister(
 498       pattern,
 499       SaveUnregistration(SERVICE_WORKER_ERROR_NOT_FOUND,
 500                          &unregistration1_called));
 501
 502   bool unregistration2_called = false;
 503   job_coordinator()->Unregister(
 504       pattern,
 505       SaveUnregistration(SERVICE_WORKER_ERROR_NOT_FOUND,
 506                          &unregistration2_called));
 507
 508   ASSERT_FALSE(unregistration1_called);
 509   ASSERT_FALSE(unregistration2_called);
 510   base::RunLoop().RunUntilIdle();
 511   ASSERT_TRUE(unregistration1_called);
 512   ASSERT_TRUE(unregistration2_called);
 513
 514   // There isn't really a way to test that they are being coalesced,
 515   // but we can make sure they can exist simultaneously without
 516   // crashing.
 517   scoped_refptr<ServiceWorkerRegistration> registration =
 518       FindRegistrationForPattern(pattern, SERVICE_WORKER_ERROR_NOT_FOUND);
 519
 520   ASSERT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 521 }
 522
 523 TEST_F(ServiceWorkerJobTest, AbortAll_Register) {
 524   GURL pattern1("http://www1.example.com/");
 525   GURL pattern2("http://www2.example.com/");
 526   GURL script_url1("http://www1.example.com/service_worker.js");
 527   GURL script_url2("http://www2.example.com/service_worker.js");
 528
 529   bool registration_called1 = false;
 530   scoped_refptr<ServiceWorkerRegistration> registration1;
 531   job_coordinator()->Register(
 532       pattern1,
 533       script_url1,
 534       NULL,
 535       SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
 536                        &registration_called1, &registration1));
 537
 538   bool registration_called2 = false;
 539   scoped_refptr<ServiceWorkerRegistration> registration2;
 540   job_coordinator()->Register(
 541       pattern2,
 542       script_url2,
 543       NULL,
 544       SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
 545                        &registration_called2, &registration2));
 546
 547   ASSERT_FALSE(registration_called1);
 548   ASSERT_FALSE(registration_called2);
 549   job_coordinator()->AbortAll();
 550
 551   base::RunLoop().RunUntilIdle();
 552   ASSERT_TRUE(registration_called1);
 553   ASSERT_TRUE(registration_called2);
 554
 555   bool find_called1 = false;
 556   storage()->FindRegistrationForPattern(
 557       pattern1,
 558       SaveFoundRegistration(
 559           SERVICE_WORKER_ERROR_NOT_FOUND, &find_called1, &registration1));
 560
 561   bool find_called2 = false;
 562   storage()->FindRegistrationForPattern(
 563       pattern2,
 564       SaveFoundRegistration(
 565           SERVICE_WORKER_ERROR_NOT_FOUND, &find_called2, &registration2));
 566
 567   base::RunLoop().RunUntilIdle();
 568   ASSERT_TRUE(find_called1);
 569   ASSERT_TRUE(find_called2);
 570   EXPECT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration1);
 571   EXPECT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration2);
 572 }
 573
 574 TEST_F(ServiceWorkerJobTest, AbortAll_Unregister) {
 575   GURL pattern1("http://www1.example.com/");
 576   GURL pattern2("http://www2.example.com/");
 577
 578   bool unregistration_called1 = false;
 579   scoped_refptr<ServiceWorkerRegistration> registration1;
 580   job_coordinator()->Unregister(
 581       pattern1,
 582       SaveUnregistration(SERVICE_WORKER_ERROR_ABORT,
 583                          &unregistration_called1));
 584
 585   bool unregistration_called2 = false;
 586   job_coordinator()->Unregister(
 587       pattern2,
 588       SaveUnregistration(SERVICE_WORKER_ERROR_ABORT,
 589                          &unregistration_called2));
 590
 591   ASSERT_FALSE(unregistration_called1);
 592   ASSERT_FALSE(unregistration_called2);
 593   job_coordinator()->AbortAll();
 594
 595   base::RunLoop().RunUntilIdle();
 596   ASSERT_TRUE(unregistration_called1);
 597   ASSERT_TRUE(unregistration_called2);
 598 }
 599
 600 TEST_F(ServiceWorkerJobTest, AbortAll_RegUnreg) {
 601   GURL pattern("http://www.example.com/");
 602   GURL script_url("http://www.example.com/service_worker.js");
 603
 604   bool registration_called = false;
 605   scoped_refptr<ServiceWorkerRegistration> registration;
 606   job_coordinator()->Register(
 607       pattern,
 608       script_url,
 609       NULL,
 610       SaveRegistration(SERVICE_WORKER_ERROR_ABORT,
 611                        &registration_called, &registration));
 612
 613   bool unregistration_called = false;
 614   job_coordinator()->Unregister(
 615       pattern,
 616       SaveUnregistration(SERVICE_WORKER_ERROR_ABORT,
 617                          &unregistration_called));
 618
 619   ASSERT_FALSE(registration_called);
 620   ASSERT_FALSE(unregistration_called);
 621   job_coordinator()->AbortAll();
 622
 623   base::RunLoop().RunUntilIdle();
 624   ASSERT_TRUE(registration_called);
 625   ASSERT_TRUE(unregistration_called);
 626
 627   registration = FindRegistrationForPattern(pattern,
 628                                             SERVICE_WORKER_ERROR_NOT_FOUND);
 629
 630   EXPECT_EQ(scoped_refptr<ServiceWorkerRegistration>(), registration);
 631 }
 632
 633 // Tests that the waiting worker enters the 'redundant' state upon
 634 // unregistration.
 635 TEST_F(ServiceWorkerJobTest, UnregisterWaitingSetsRedundant) {
 636   GURL script_url("http://www.example.com/service_worker.js");
 637   scoped_refptr<ServiceWorkerRegistration> registration =
 638       RunRegisterJob(GURL("http://www.example.com/"), script_url);
 639   ASSERT_TRUE(registration.get());
 640
 641   // Manually create the waiting worker since there is no way to become a
 642   // waiting worker until Update is implemented.
 643   scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
 644       registration.get(), script_url, 1L, helper_->context()->AsWeakPtr());
 645   ServiceWorkerStatusCode status = SERVICE_WORKER_ERROR_FAILED;
 646   version->StartWorker(CreateReceiverOnCurrentThread(&status));
 647   base::RunLoop().RunUntilIdle();
 648   ASSERT_EQ(SERVICE_WORKER_OK, status);
 649
 650   version->SetStatus(ServiceWorkerVersion::INSTALLED);
 651   registration->SetWaitingVersion(version);
 652   EXPECT_EQ(ServiceWorkerVersion::RUNNING,
 653             version->running_status());
 654   EXPECT_EQ(ServiceWorkerVersion::INSTALLED, version->status());
 655
 656   RunUnregisterJob(GURL("http://www.example.com/"));
 657
 658   // The version should be stopped since there is no controllee after
 659   // unregistration.
 660   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version->running_status());
 661   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version->status());
 662 }
 663
 664 // Tests that the active worker enters the 'redundant' state upon
 665 // unregistration.
 666 TEST_F(ServiceWorkerJobTest, UnregisterActiveSetsRedundant) {
 667   scoped_refptr<ServiceWorkerRegistration> registration =
 668       RunRegisterJob(GURL("http://www.example.com/"),
 669                      GURL("http://www.example.com/service_worker.js"));
 670   ASSERT_TRUE(registration.get());
 671
 672   scoped_refptr<ServiceWorkerVersion> version = registration->active_version();
 673   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version->running_status());
 674   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, version->status());
 675
 676   RunUnregisterJob(GURL("http://www.example.com/"));
 677
 678   // The version should be stopped since there is no controllee after
 679   // unregistration.
 680   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version->running_status());
 681   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version->status());
 682 }
 683
 684 // Tests that the active worker enters the 'redundant' state upon
 685 // unregistration.
 686 TEST_F(ServiceWorkerJobTest,
 687        UnregisterActiveSetsRedundant_WaitForNoControllee) {
 688   scoped_refptr<ServiceWorkerRegistration> registration =
 689       RunRegisterJob(GURL("http://www.example.com/"),
 690                      GURL("http://www.example.com/service_worker.js"));
 691   ASSERT_TRUE(registration.get());
 692
 693   scoped_ptr<ServiceWorkerProviderHost> host = CreateControllee();
 694   registration->active_version()->AddControllee(host.get());
 695
 696   scoped_refptr<ServiceWorkerVersion> version = registration->active_version();
 697   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version->running_status());
 698   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, version->status());
 699
 700   RunUnregisterJob(GURL("http://www.example.com/"));
 701
 702   // The version should be running since there is still a controllee.
 703   EXPECT_EQ(ServiceWorkerVersion::RUNNING, version->running_status());
 704   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, version->status());
 705
 706   registration->active_version()->RemoveControllee(host.get());
 707   base::RunLoop().RunUntilIdle();
 708
 709   // The version should be stopped since there is no controllee.
 710   EXPECT_EQ(ServiceWorkerVersion::STOPPED, version->running_status());
 711   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version->status());
 712 }
 713
 714 namespace {  // Helpers for the update job tests.
 715
 716 const GURL kNoChangeOrigin("http://nochange/");
 717 const GURL kNewVersionOrigin("http://newversion/");
 718 const std::string kScope("scope/");
 719 const std::string kScript("script.js");
 720
 721 void RunNestedUntilIdle() {
 722   base::MessageLoop::ScopedNestableTaskAllower allow(
 723       base::MessageLoop::current());
 724   base::MessageLoop::current()->RunUntilIdle();
 725 }
 726
 727 void OnIOComplete(int* rv_out, int rv) {
 728   *rv_out = rv;
 729 }
 730
 731 void WriteResponse(
 732     ServiceWorkerStorage* storage, int64 id,
 733     const std::string& headers,
 734     IOBuffer* body, int length) {
 735   scoped_ptr<ServiceWorkerResponseWriter> writer =
 736       storage->CreateResponseWriter(id);
 737
 738   scoped_ptr<net::HttpResponseInfo> info(new net::HttpResponseInfo);
 739   info->request_time = base::Time::Now();
 740   info->response_time = base::Time::Now();
 741   info->was_cached = false;
 742   info->headers = new net::HttpResponseHeaders(headers);
 743   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer =
 744       new HttpResponseInfoIOBuffer(info.release());
 745
 746   int rv = -1234;
 747   writer->WriteInfo(info_buffer.get(), base::Bind(&OnIOComplete, &rv));
 748   RunNestedUntilIdle();
 749   EXPECT_LT(0, rv);
 750
 751   rv = -1234;
 752   writer->WriteData(body, length,
 753                     base::Bind(&OnIOComplete, &rv));
 754   RunNestedUntilIdle();
 755   EXPECT_EQ(length, rv);
 756 }
 757
 758 void WriteStringResponse(
 759     ServiceWorkerStorage* storage, int64 id,
 760     const std::string& body) {
 761   scoped_refptr<IOBuffer> body_buffer(new WrappedIOBuffer(body.data()));
 762   const char kHttpHeaders[] = "HTTP/1.0 200 HONKYDORY\0\0";
 763   std::string headers(kHttpHeaders, arraysize(kHttpHeaders));
 764   WriteResponse(storage, id, headers, body_buffer.get(), body.length());
 765 }
 766
 767 class UpdateJobTestHelper
 768     : public EmbeddedWorkerTestHelper,
 769       public ServiceWorkerRegistration::Listener,
 770       public ServiceWorkerVersion::Listener {
 771  public:
 772   struct AttributeChangeLogEntry {
 773     int64 registration_id;
 774     ChangedVersionAttributesMask mask;
 775     ServiceWorkerRegistrationInfo info;
 776   };
 777
 778   struct StateChangeLogEntry {
 779     int64 version_id;
 780     ServiceWorkerVersion::Status status;
 781   };
 782
 783   UpdateJobTestHelper(int mock_render_process_id)
 784       : EmbeddedWorkerTestHelper(base::FilePath(), mock_render_process_id),
 785         update_found_(false) {}
 786   ~UpdateJobTestHelper() override {
 787     if (registration_.get())
 788       registration_->RemoveListener(this);
 789   }
 790
 791   ServiceWorkerStorage* storage() { return context()->storage(); }
 792   ServiceWorkerJobCoordinator* job_coordinator() {
 793     return context()->job_coordinator();
 794   }
 795
 796   scoped_refptr<ServiceWorkerRegistration> SetupInitialRegistration(
 797       const GURL& test_origin) {
 798     scoped_refptr<ServiceWorkerRegistration> registration;
 799     bool called = false;
 800     job_coordinator()->Register(
 801         test_origin.Resolve(kScope),
 802         test_origin.Resolve(kScript),
 803         NULL,
 804         SaveRegistration(SERVICE_WORKER_OK, &called, &registration));
 805     base::RunLoop().RunUntilIdle();
 806     EXPECT_TRUE(called);
 807     EXPECT_TRUE(registration.get());
 808     EXPECT_TRUE(registration->active_version());
 809     EXPECT_FALSE(registration->installing_version());
 810     EXPECT_FALSE(registration->waiting_version());
 811     registration_ = registration;
 812     return registration;
 813   }
 814
 815   // EmbeddedWorkerTestHelper overrides
 816   void OnStartWorker(int embedded_worker_id,
 817                      int64 version_id,
 818                      const GURL& scope,
 819                      const GURL& script,
 820                      bool pause_after_download) override {
 821     const std::string kMockScriptBody = "mock_script";
 822     const uint64 kMockScriptSize = 19284;
 823     ServiceWorkerVersion* version = context()->GetLiveVersion(version_id);
 824     ASSERT_TRUE(version);
 825     version->AddListener(this);
 826
 827     if (!pause_after_download) {
 828       // Spoof caching the script for the initial version.
 829       int64 resource_id = storage()->NewResourceId();
 830       version->script_cache_map()->NotifyStartedCaching(script, resource_id);
 831       WriteStringResponse(storage(), resource_id, kMockScriptBody);
 832       version->script_cache_map()->NotifyFinishedCaching(
 833           script, kMockScriptSize, net::URLRequestStatus(), std::string());
 834     } else {
 835       // Spoof caching the script for the new version.
 836       int64 resource_id = storage()->NewResourceId();
 837       version->script_cache_map()->NotifyStartedCaching(script, resource_id);
 838       if (script.GetOrigin() == kNoChangeOrigin)
 839         WriteStringResponse(storage(), resource_id, kMockScriptBody);
 840       else
 841         WriteStringResponse(storage(), resource_id, "mock_different_script");
 842       version->script_cache_map()->NotifyFinishedCaching(
 843           script, kMockScriptSize, net::URLRequestStatus(), std::string());
 844     }
 845     EmbeddedWorkerTestHelper::OnStartWorker(
 846         embedded_worker_id, version_id, scope, script, pause_after_download);
 847   }
 848
 849   // ServiceWorkerRegistration::Listener overrides
 850   void OnVersionAttributesChanged(
 851       ServiceWorkerRegistration* registration,
 852       ChangedVersionAttributesMask changed_mask,
 853       const ServiceWorkerRegistrationInfo& info) override {
 854     AttributeChangeLogEntry entry;
 855     entry.registration_id = registration->id();
 856     entry.mask = changed_mask;
 857     entry.info = info;
 858     attribute_change_log_.push_back(entry);
 859   }
 860
 861   void OnRegistrationFailed(ServiceWorkerRegistration* registration) override {
 862     NOTREACHED();
 863   }
 864
 865   void OnUpdateFound(ServiceWorkerRegistration* registration) override {
 866     ASSERT_FALSE(update_found_);
 867     update_found_ = true;
 868   }
 869
 870   // ServiceWorkerVersion::Listener overrides
 871   void OnVersionStateChanged(ServiceWorkerVersion* version) override {
 872     StateChangeLogEntry entry;
 873     entry.version_id = version->version_id();
 874     entry.status = version->status();
 875     state_change_log_.push_back(entry);
 876   }
 877
 878   scoped_refptr<ServiceWorkerRegistration> registration_;
 879
 880   std::vector<AttributeChangeLogEntry> attribute_change_log_;
 881   std::vector<StateChangeLogEntry> state_change_log_;
 882   bool update_found_;
 883 };
 884
 885 // Helper class for update tests that evicts the active version when the update
 886 // worker is about to be started.
 887 class EvictIncumbentVersionHelper : public UpdateJobTestHelper {
 888  public:
 889   EvictIncumbentVersionHelper(int mock_render_process_id)
 890       : UpdateJobTestHelper(mock_render_process_id) {}
 891   ~EvictIncumbentVersionHelper() override {}
 892
 893   void OnStartWorker(int embedded_worker_id,
 894                      int64 version_id,
 895                      const GURL& scope,
 896                      const GURL& script,
 897                      bool pause_after_download) override {
 898     if (pause_after_download) {
 899       // Evict the incumbent worker.
 900       ServiceWorkerVersion* version = context()->GetLiveVersion(version_id);
 901       ASSERT_TRUE(version);
 902       ServiceWorkerRegistration* registration =
 903           context()->GetLiveRegistration(version->registration_id());
 904       ASSERT_TRUE(registration);
 905       ASSERT_TRUE(registration->active_version());
 906       ASSERT_FALSE(registration->waiting_version());
 907       registration->DeleteVersion(
 908           make_scoped_refptr(registration->active_version()));
 909     }
 910     UpdateJobTestHelper::OnStartWorker(embedded_worker_id, version_id, scope,
 911                                        script, pause_after_download);
 912   }
 913
 914   void OnRegistrationFailed(ServiceWorkerRegistration* registration) override {
 915     registration_failed_ = true;
 916   }
 917
 918   bool registration_failed_ = false;
 919 };
 920
 921 }  // namespace
 922
 923 TEST_F(ServiceWorkerJobTest, Update_NoChange) {
 924   UpdateJobTestHelper* update_helper =
 925       new UpdateJobTestHelper(render_process_id_);
 926   helper_.reset(update_helper);
 927   scoped_refptr<ServiceWorkerRegistration> registration =
 928       update_helper->SetupInitialRegistration(kNoChangeOrigin);
 929   ASSERT_TRUE(registration.get());
 930   ASSERT_EQ(4u, update_helper->state_change_log_.size());
 931   EXPECT_EQ(ServiceWorkerVersion::INSTALLING,
 932             update_helper->state_change_log_[0].status);
 933   EXPECT_EQ(ServiceWorkerVersion::INSTALLED,
 934             update_helper->state_change_log_[1].status);
 935   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING,
 936             update_helper->state_change_log_[2].status);
 937   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED,
 938             update_helper->state_change_log_[3].status);
 939   update_helper->state_change_log_.clear();
 940
 941   // Run the update job.
 942   registration->AddListener(update_helper);
 943   scoped_refptr<ServiceWorkerVersion> first_version =
 944       registration->active_version();
 945   first_version->StartUpdate();
 946   base::RunLoop().RunUntilIdle();
 947
 948   // Verify results.
 949   ASSERT_TRUE(registration->active_version());
 950   EXPECT_EQ(first_version.get(), registration->active_version());
 951   EXPECT_FALSE(registration->installing_version());
 952   EXPECT_FALSE(registration->waiting_version());
 953   EXPECT_TRUE(update_helper->attribute_change_log_.empty());
 954   ASSERT_EQ(1u, update_helper->state_change_log_.size());
 955   EXPECT_NE(registration->active_version()->version_id(),
 956             update_helper->state_change_log_[0].version_id);
 957   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT,
 958             update_helper->state_change_log_[0].status);
 959   EXPECT_FALSE(update_helper->update_found_);
 960 }
 961
 962 TEST_F(ServiceWorkerJobTest, Update_NewVersion) {
 963   UpdateJobTestHelper* update_helper =
 964       new UpdateJobTestHelper(render_process_id_);
 965   helper_.reset(update_helper);
 966   scoped_refptr<ServiceWorkerRegistration> registration =
 967       update_helper->SetupInitialRegistration(kNewVersionOrigin);
 968   ASSERT_TRUE(registration.get());
 969   update_helper->state_change_log_.clear();
 970
 971   // Run the update job.
 972   registration->AddListener(update_helper);
 973   scoped_refptr<ServiceWorkerVersion> first_version =
 974       registration->active_version();
 975   first_version->StartUpdate();
 976   base::RunLoop().RunUntilIdle();
 977
 978   // Verify results.
 979   ASSERT_TRUE(registration->active_version());
 980   EXPECT_NE(first_version.get(), registration->active_version());
 981   EXPECT_FALSE(registration->installing_version());
 982   EXPECT_FALSE(registration->waiting_version());
 983   ASSERT_EQ(3u, update_helper->attribute_change_log_.size());
 984
 985   UpdateJobTestHelper::AttributeChangeLogEntry entry;
 986   entry = update_helper->attribute_change_log_[0];
 987   EXPECT_TRUE(entry.mask.installing_changed());
 988   EXPECT_FALSE(entry.mask.waiting_changed());
 989   EXPECT_FALSE(entry.mask.active_changed());
 990   EXPECT_NE(entry.info.installing_version.version_id,
 991             kInvalidServiceWorkerVersionId);
 992   EXPECT_EQ(entry.info.waiting_version.version_id,
 993             kInvalidServiceWorkerVersionId);
 994   EXPECT_NE(entry.info.active_version.version_id,
 995             kInvalidServiceWorkerVersionId);
 996
 997   entry = update_helper->attribute_change_log_[1];
 998   EXPECT_TRUE(entry.mask.installing_changed());
 999   EXPECT_TRUE(entry.mask.waiting_changed());
1000   EXPECT_FALSE(entry.mask.active_changed());
1001   EXPECT_EQ(entry.info.installing_version.version_id,
1002             kInvalidServiceWorkerVersionId);
1003   EXPECT_NE(entry.info.waiting_version.version_id,
1004             kInvalidServiceWorkerVersionId);
1005   EXPECT_NE(entry.info.active_version.version_id,
1006             kInvalidServiceWorkerVersionId);
1007
1008   entry = update_helper->attribute_change_log_[2];
1009   EXPECT_FALSE(entry.mask.installing_changed());
1010   EXPECT_TRUE(entry.mask.waiting_changed());
1011   EXPECT_TRUE(entry.mask.active_changed());
1012   EXPECT_EQ(entry.info.installing_version.version_id,
1013             kInvalidServiceWorkerVersionId);
1014   EXPECT_EQ(entry.info.waiting_version.version_id,
1015             kInvalidServiceWorkerVersionId);
1016   EXPECT_NE(entry.info.active_version.version_id,
1017             kInvalidServiceWorkerVersionId);
1018
1019   // expected version state transitions:
1020   // new.installing, new.installed,
1021   // old.redundant,
1022   // new.activating, new.activated
1023   ASSERT_EQ(5u, update_helper->state_change_log_.size());
1024
1025   EXPECT_EQ(registration->active_version()->version_id(),
1026             update_helper->state_change_log_[0].version_id);
1027   EXPECT_EQ(ServiceWorkerVersion::INSTALLING,
1028             update_helper->state_change_log_[0].status);
1029
1030   EXPECT_EQ(registration->active_version()->version_id(),
1031             update_helper->state_change_log_[1].version_id);
1032   EXPECT_EQ(ServiceWorkerVersion::INSTALLED,
1033             update_helper->state_change_log_[1].status);
1034
1035   EXPECT_EQ(first_version->version_id(),
1036             update_helper->state_change_log_[2].version_id);
1037   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT,
1038             update_helper->state_change_log_[2].status);
1039
1040   EXPECT_EQ(registration->active_version()->version_id(),
1041             update_helper->state_change_log_[3].version_id);
1042   EXPECT_EQ(ServiceWorkerVersion::ACTIVATING,
1043             update_helper->state_change_log_[3].status);
1044
1045   EXPECT_EQ(registration->active_version()->version_id(),
1046             update_helper->state_change_log_[4].version_id);
1047   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED,
1048             update_helper->state_change_log_[4].status);
1049
1050   EXPECT_TRUE(update_helper->update_found_);
1051 }
1052
1053 TEST_F(ServiceWorkerJobTest, Update_NewestVersionChanged) {
1054   scoped_refptr<ServiceWorkerRegistration> registration =
1055       RunRegisterJob(GURL("http://www.example.com/one/"),
1056                      GURL("http://www.example.com/service_worker.js"));
1057
1058   ServiceWorkerVersion* active_version = registration->active_version();
1059
1060   // Queue an Update, it should abort when it starts and sees the new version.
1061   job_coordinator()->Update(registration.get(), false);
1062
1063   // Add a waiting version with new script.
1064   scoped_refptr<ServiceWorkerVersion> version =
1065       new ServiceWorkerVersion(registration.get(),
1066                                GURL("http://www.example.com/new_worker.js"),
1067                                2L /* dummy version id */,
1068                                helper_->context()->AsWeakPtr());
1069   registration->SetWaitingVersion(version);
1070
1071   base::RunLoop().RunUntilIdle();
1072
1073   // Verify the registration was not modified by the Update.
1074   EXPECT_EQ(active_version, registration->active_version());
1075   EXPECT_EQ(version.get(), registration->waiting_version());
1076   EXPECT_EQ(NULL, registration->installing_version());
1077 }
1078
1079 // Test that update succeeds if the incumbent worker was evicted
1080 // during the update job (this can happen on disk cache failure).
1081 TEST_F(ServiceWorkerJobTest, Update_EvictedIncumbent) {
1082   EvictIncumbentVersionHelper* update_helper =
1083       new EvictIncumbentVersionHelper(render_process_id_);
1084   helper_.reset(update_helper);
1085   scoped_refptr<ServiceWorkerRegistration> registration =
1086       update_helper->SetupInitialRegistration(kNewVersionOrigin);
1087   ASSERT_TRUE(registration.get());
1088   update_helper->state_change_log_.clear();
1089
1090   // Run the update job.
1091   registration->AddListener(update_helper);
1092   scoped_refptr<ServiceWorkerVersion> first_version =
1093       registration->active_version();
1094   first_version->StartUpdate();
1095   base::RunLoop().RunUntilIdle();
1096
1097   // Verify results.
1098   ASSERT_TRUE(registration->active_version());
1099   EXPECT_NE(first_version.get(), registration->active_version());
1100   EXPECT_FALSE(registration->installing_version());
1101   EXPECT_FALSE(registration->waiting_version());
1102   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, first_version->status());
1103   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED,
1104             registration->active_version()->status());
1105   ASSERT_EQ(4u, update_helper->attribute_change_log_.size());
1106   EXPECT_TRUE(update_helper->update_found_);
1107   EXPECT_TRUE(update_helper->registration_failed_);
1108   EXPECT_FALSE(registration->is_uninstalled());
1109 }
1110
1111 TEST_F(ServiceWorkerJobTest, Update_UninstallingRegistration) {
1112   bool called;
1113   scoped_refptr<ServiceWorkerRegistration> registration =
1114       RunRegisterJob(GURL("http://www.example.com/one/"),
1115                      GURL("http://www.example.com/service_worker.js"));
1116
1117   // Add a controllee and queue an unregister to force the uninstalling state.
1118   scoped_ptr<ServiceWorkerProviderHost> host = CreateControllee();
1119   ServiceWorkerVersion* active_version = registration->active_version();
1120   active_version->AddControllee(host.get());
1121   job_coordinator()->Unregister(GURL("http://www.example.com/one/"),
1122                                 SaveUnregistration(SERVICE_WORKER_OK, &called));
1123
1124   // Update should abort after it starts and sees uninstalling.
1125   job_coordinator()->Update(registration.get(), false);
1126
1127   EXPECT_FALSE(called);
1128   base::RunLoop().RunUntilIdle();
1129   EXPECT_TRUE(called);
1130
1131   // Verify the registration was not modified by the Update.
1132   EXPECT_TRUE(registration->is_uninstalling());
1133   EXPECT_EQ(active_version, registration->active_version());
1134   EXPECT_EQ(NULL, registration->waiting_version());
1135   EXPECT_EQ(NULL, registration->installing_version());
1136 }
1137
1138 TEST_F(ServiceWorkerJobTest, RegisterWhileUninstalling) {
1139   GURL pattern("http://www.example.com/one/");
1140   GURL script1("http://www.example.com/service_worker.js");
1141   GURL script2("http://www.example.com/service_worker.js?new");
1142
1143   scoped_refptr<ServiceWorkerRegistration> registration =
1144       RunRegisterJob(pattern, script1);
1145
1146   // Add a controllee and queue an unregister to force the uninstalling state.
1147   scoped_ptr<ServiceWorkerProviderHost> host = CreateControllee();
1148   scoped_refptr<ServiceWorkerVersion> old_version =
1149       registration->active_version();
1150   old_version->AddControllee(host.get());
1151   RunUnregisterJob(pattern);
1152
1153   // Register another script.
1154   EXPECT_EQ(registration, RunRegisterJob(pattern, script2));
1155
1156   EXPECT_FALSE(registration->is_uninstalling());
1157   EXPECT_EQ(old_version, registration->active_version());
1158
1159   scoped_refptr<ServiceWorkerVersion> new_version =
1160       registration->waiting_version();
1161
1162   // Verify the new version is installed but not activated yet.
1163   EXPECT_EQ(NULL, registration->installing_version());
1164   EXPECT_TRUE(new_version);
1165   EXPECT_EQ(ServiceWorkerVersion::RUNNING, new_version->running_status());
1166   EXPECT_EQ(ServiceWorkerVersion::INSTALLED, new_version->status());
1167
1168   old_version->RemoveControllee(host.get());
1169   base::RunLoop().RunUntilIdle();
1170
1171   EXPECT_FALSE(registration->is_uninstalling());
1172   EXPECT_FALSE(registration->is_uninstalled());
1173
1174   // Verify the new version is activated.
1175   EXPECT_EQ(NULL, registration->installing_version());
1176   EXPECT_EQ(NULL, registration->waiting_version());
1177   EXPECT_EQ(new_version, registration->active_version());
1178   EXPECT_EQ(ServiceWorkerVersion::RUNNING, new_version->running_status());
1179   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, new_version->status());
1180 }
1181
1182 TEST_F(ServiceWorkerJobTest, RegisterAndUnregisterWhileUninstalling) {
1183   GURL pattern("http://www.example.com/one/");
1184   GURL script1("http://www.example.com/service_worker.js");
1185   GURL script2("http://www.example.com/service_worker.js?new");
1186
1187   scoped_refptr<ServiceWorkerRegistration> registration =
1188       RunRegisterJob(pattern, script1);
1189
1190   // Add a controllee and queue an unregister to force the uninstalling state.
1191   scoped_ptr<ServiceWorkerProviderHost> host = CreateControllee();
1192   scoped_refptr<ServiceWorkerVersion> old_version =
1193       registration->active_version();
1194   old_version->AddControllee(host.get());
1195   RunUnregisterJob(pattern);
1196
1197   EXPECT_EQ(registration, RunRegisterJob(pattern, script2));
1198
1199   EXPECT_EQ(registration, FindRegistrationForPattern(pattern));
1200   scoped_refptr<ServiceWorkerVersion> new_version =
1201       registration->waiting_version();
1202   ASSERT_TRUE(new_version);
1203
1204   // Unregister the registration (but it's still live).
1205   RunUnregisterJob(pattern);
1206   // Now it's not found in the storage.
1207   RunUnregisterJob(pattern, SERVICE_WORKER_ERROR_NOT_FOUND);
1208
1209   FindRegistrationForPattern(pattern, SERVICE_WORKER_ERROR_NOT_FOUND);
1210   EXPECT_TRUE(registration->is_uninstalling());
1211   EXPECT_EQ(old_version, registration->active_version());
1212
1213   EXPECT_EQ(ServiceWorkerVersion::RUNNING, old_version->running_status());
1214   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, old_version->status());
1215   EXPECT_EQ(ServiceWorkerVersion::RUNNING, new_version->running_status());
1216   EXPECT_EQ(ServiceWorkerVersion::INSTALLED, new_version->status());
1217
1218   old_version->RemoveControllee(host.get());
1219   base::RunLoop().RunUntilIdle();
1220
1221   EXPECT_FALSE(registration->is_uninstalling());
1222   EXPECT_TRUE(registration->is_uninstalled());
1223
1224   EXPECT_EQ(ServiceWorkerVersion::STOPPED, old_version->running_status());
1225   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, old_version->status());
1226   EXPECT_EQ(ServiceWorkerVersion::STOPPED, new_version->running_status());
1227   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, new_version->status());
1228 }
1229
1230 TEST_F(ServiceWorkerJobTest, RegisterSameScriptMultipleTimesWhileUninstalling) {
1231   GURL pattern("http://www.example.com/one/");
1232   GURL script1("http://www.example.com/service_worker.js");
1233   GURL script2("http://www.example.com/service_worker.js?new");
1234
1235   scoped_refptr<ServiceWorkerRegistration> registration =
1236       RunRegisterJob(pattern, script1);
1237
1238   // Add a controllee and queue an unregister to force the uninstalling state.
1239   scoped_ptr<ServiceWorkerProviderHost> host = CreateControllee();
1240   scoped_refptr<ServiceWorkerVersion> old_version =
1241       registration->active_version();
1242   old_version->AddControllee(host.get());
1243   RunUnregisterJob(pattern);
1244
1245   EXPECT_EQ(registration, RunRegisterJob(pattern, script2));
1246
1247   scoped_refptr<ServiceWorkerVersion> new_version =
1248       registration->waiting_version();
1249   ASSERT_TRUE(new_version);
1250
1251   RunUnregisterJob(pattern);
1252
1253   EXPECT_TRUE(registration->is_uninstalling());
1254
1255   EXPECT_EQ(registration, RunRegisterJob(pattern, script2));
1256
1257   EXPECT_FALSE(registration->is_uninstalling());
1258   EXPECT_EQ(new_version, registration->waiting_version());
1259
1260   old_version->RemoveControllee(host.get());
1261   base::RunLoop().RunUntilIdle();
1262
1263   EXPECT_FALSE(registration->is_uninstalling());
1264   EXPECT_FALSE(registration->is_uninstalled());
1265
1266   // Verify the new version is activated.
1267   EXPECT_EQ(NULL, registration->installing_version());
1268   EXPECT_EQ(NULL, registration->waiting_version());
1269   EXPECT_EQ(new_version, registration->active_version());
1270   EXPECT_EQ(ServiceWorkerVersion::RUNNING, new_version->running_status());
1271   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, new_version->status());
1272 }
1273
1274 TEST_F(ServiceWorkerJobTest, RegisterMultipleTimesWhileUninstalling) {
1275   GURL pattern("http://www.example.com/one/");
1276   GURL script1("http://www.example.com/service_worker.js?first");
1277   GURL script2("http://www.example.com/service_worker.js?second");
1278   GURL script3("http://www.example.com/service_worker.js?third");
1279
1280   scoped_refptr<ServiceWorkerRegistration> registration =
1281       RunRegisterJob(pattern, script1);
1282
1283   // Add a controllee and queue an unregister to force the uninstalling state.
1284   scoped_ptr<ServiceWorkerProviderHost> host = CreateControllee();
1285   scoped_refptr<ServiceWorkerVersion> first_version =
1286       registration->active_version();
1287   first_version->AddControllee(host.get());
1288   RunUnregisterJob(pattern);
1289
1290   EXPECT_EQ(registration, RunRegisterJob(pattern, script2));
1291
1292   scoped_refptr<ServiceWorkerVersion> second_version =
1293       registration->waiting_version();
1294   ASSERT_TRUE(second_version);
1295
1296   RunUnregisterJob(pattern);
1297
1298   EXPECT_TRUE(registration->is_uninstalling());
1299
1300   EXPECT_EQ(registration, RunRegisterJob(pattern, script3));
1301
1302   scoped_refptr<ServiceWorkerVersion> third_version =
1303       registration->waiting_version();
1304   ASSERT_TRUE(third_version);
1305
1306   EXPECT_FALSE(registration->is_uninstalling());
1307   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, second_version->status());
1308
1309   first_version->RemoveControllee(host.get());
1310   base::RunLoop().RunUntilIdle();
1311
1312   EXPECT_FALSE(registration->is_uninstalling());
1313   EXPECT_FALSE(registration->is_uninstalled());
1314
1315   // Verify the new version is activated.
1316   EXPECT_EQ(NULL, registration->installing_version());
1317   EXPECT_EQ(NULL, registration->waiting_version());
1318   EXPECT_EQ(third_version, registration->active_version());
1319   EXPECT_EQ(ServiceWorkerVersion::RUNNING, third_version->running_status());
1320   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, third_version->status());
1321 }
1322
1323 class EventCallbackHelper : public EmbeddedWorkerTestHelper {
1324  public:
1325   explicit EventCallbackHelper(int mock_render_process_id)
1326       : EmbeddedWorkerTestHelper(base::FilePath(), mock_render_process_id),
1327         install_event_result_(blink::WebServiceWorkerEventResultCompleted),
1328         activate_event_result_(blink::WebServiceWorkerEventResultCompleted) {}
1329
1330   void OnInstallEvent(int embedded_worker_id,
1331                       int request_id) override {
1332     if (!install_callback_.is_null())
1333       install_callback_.Run();
1334     SimulateSend(
1335         new ServiceWorkerHostMsg_InstallEventFinished(
1336             embedded_worker_id, request_id, install_event_result_));
1337   }
1338   void OnActivateEvent(int embedded_worker_id, int request_id) override {
1339     SimulateSend(
1340         new ServiceWorkerHostMsg_ActivateEventFinished(
1341             embedded_worker_id, request_id, activate_event_result_));
1342   }
1343
1344   void set_install_callback(const base::Closure& callback) {
1345     install_callback_ = callback;
1346   }
1347   void set_install_event_result(blink::WebServiceWorkerEventResult result) {
1348     install_event_result_ = result;
1349   }
1350   void set_activate_event_result(blink::WebServiceWorkerEventResult result) {
1351     activate_event_result_ = result;
1352   }
1353 private:
1354   base::Closure install_callback_;
1355   blink::WebServiceWorkerEventResult install_event_result_;
1356   blink::WebServiceWorkerEventResult activate_event_result_;
1357 };
1358
1359 TEST_F(ServiceWorkerJobTest, RemoveControlleeDuringInstall) {
1360   EventCallbackHelper* helper = new EventCallbackHelper(render_process_id_);
1361   helper_.reset(helper);
1362
1363   GURL pattern("http://www.example.com/one/");
1364   GURL script1("http://www.example.com/service_worker.js");
1365   GURL script2("http://www.example.com/service_worker.js?new");
1366
1367   scoped_refptr<ServiceWorkerRegistration> registration =
1368       RunRegisterJob(pattern, script1);
1369
1370   // Add a controllee and queue an unregister to force the uninstalling state.
1371   scoped_ptr<ServiceWorkerProviderHost> host = CreateControllee();
1372   scoped_refptr<ServiceWorkerVersion> old_version =
1373       registration->active_version();
1374   old_version->AddControllee(host.get());
1375   RunUnregisterJob(pattern);
1376
1377   // Register another script. While installing, old_version loses controllee.
1378   helper->set_install_callback(
1379       base::Bind(&ServiceWorkerVersion::RemoveControllee,
1380                  old_version, host.get()));
1381   EXPECT_EQ(registration, RunRegisterJob(pattern, script2));
1382
1383   EXPECT_FALSE(registration->is_uninstalling());
1384   EXPECT_FALSE(registration->is_uninstalled());
1385
1386   // Verify the new version is activated.
1387   scoped_refptr<ServiceWorkerVersion> new_version =
1388       registration->active_version();
1389   EXPECT_NE(old_version, new_version);
1390   EXPECT_EQ(NULL, registration->installing_version());
1391   EXPECT_EQ(NULL, registration->waiting_version());
1392   EXPECT_EQ(new_version, registration->active_version());
1393   EXPECT_EQ(ServiceWorkerVersion::RUNNING, new_version->running_status());
1394   EXPECT_EQ(ServiceWorkerVersion::ACTIVATED, new_version->status());
1395
1396   EXPECT_EQ(registration, FindRegistrationForPattern(pattern));
1397 }
1398
1399 TEST_F(ServiceWorkerJobTest, RemoveControlleeDuringRejectedInstall) {
1400   EventCallbackHelper* helper = new EventCallbackHelper(render_process_id_);
1401   helper_.reset(helper);
1402
1403   GURL pattern("http://www.example.com/one/");
1404   GURL script1("http://www.example.com/service_worker.js");
1405   GURL script2("http://www.example.com/service_worker.js?new");
1406
1407   scoped_refptr<ServiceWorkerRegistration> registration =
1408       RunRegisterJob(pattern, script1);
1409
1410   // Add a controllee and queue an unregister to force the uninstalling state.
1411   scoped_ptr<ServiceWorkerProviderHost> host = CreateControllee();
1412   scoped_refptr<ServiceWorkerVersion> old_version =
1413       registration->active_version();
1414   old_version->AddControllee(host.get());
1415   RunUnregisterJob(pattern);
1416
1417   // Register another script that fails to install. While installing,
1418   // old_version loses controllee.
1419   helper->set_install_callback(
1420       base::Bind(&ServiceWorkerVersion::RemoveControllee,
1421                  old_version, host.get()));
1422   helper->set_install_event_result(blink::WebServiceWorkerEventResultRejected);
1423   EXPECT_EQ(registration, RunRegisterJob(pattern, script2));
1424
1425   // Verify the registration was uninstalled.
1426   EXPECT_FALSE(registration->is_uninstalling());
1427   EXPECT_TRUE(registration->is_uninstalled());
1428
1429   EXPECT_EQ(ServiceWorkerVersion::STOPPED, old_version->running_status());
1430   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, old_version->status());
1431
1432   FindRegistrationForPattern(pattern, SERVICE_WORKER_ERROR_NOT_FOUND);
1433 }
1434
1435 TEST_F(ServiceWorkerJobTest, RemoveControlleeDuringInstall_RejectActivate) {
1436   EventCallbackHelper* helper = new EventCallbackHelper(render_process_id_);
1437   helper_.reset(helper);
1438
1439   GURL pattern("http://www.example.com/one/");
1440   GURL script1("http://www.example.com/service_worker.js");
1441   GURL script2("http://www.example.com/service_worker.js?new");
1442
1443   scoped_refptr<ServiceWorkerRegistration> registration =
1444       RunRegisterJob(pattern, script1);
1445
1446   // Add a controllee and queue an unregister to force the uninstalling state.
1447   scoped_ptr<ServiceWorkerProviderHost> host = CreateControllee();
1448   scoped_refptr<ServiceWorkerVersion> old_version =
1449       registration->active_version();
1450   old_version->AddControllee(host.get());
1451   RunUnregisterJob(pattern);
1452
1453   // Register another script that fails to activate. While installing,
1454   // old_version loses controllee.
1455   helper->set_install_callback(
1456       base::Bind(&ServiceWorkerVersion::RemoveControllee,
1457                  old_version, host.get()));
1458   helper->set_activate_event_result(blink::WebServiceWorkerEventResultRejected);
1459   EXPECT_EQ(registration, RunRegisterJob(pattern, script2));
1460
1461   // Verify the registration remains.
1462   EXPECT_FALSE(registration->is_uninstalling());
1463   EXPECT_FALSE(registration->is_uninstalled());
1464
1465   EXPECT_EQ(ServiceWorkerVersion::STOPPED, old_version->running_status());
1466   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, old_version->status());
1467
1468   FindRegistrationForPattern(pattern, SERVICE_WORKER_OK);
1469 }
1470
1471 }  // namespace content