content/browser/background_sync/background_sync_manager_unittest.cc

   1 // Copyright 2015 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 "content/browser/background_sync/background_sync_manager.h"
   6
   7 #include "base/files/scoped_temp_dir.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "base/power_monitor/power_monitor.h"
  11 #include "base/power_monitor/power_monitor_source.h"
  12 #include "base/run_loop.h"
  13 #include "base/single_thread_task_runner.h"
  14 #include "base/thread_task_runner_handle.h"
  15 #include "content/browser/background_sync/background_sync_status.h"
  16 #include "content/browser/browser_thread_impl.h"
  17 #include "content/browser/service_worker/embedded_worker_test_helper.h"
  18 #include "content/browser/service_worker/service_worker_context_core.h"
  19 #include "content/browser/service_worker/service_worker_context_wrapper.h"
  20 #include "content/browser/service_worker/service_worker_storage.h"
  21 #include "content/public/test/test_browser_thread_bundle.h"
  22 #include "net/base/network_change_notifier.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 namespace content {
  26
  27 namespace {
  28
  29 const char kPattern1[] = "https://example.com/a";
  30 const char kPattern2[] = "https://example.com/b";
  31 const char kScript1[] = "https://example.com/a/script.js";
  32 const char kScript2[] = "https://example.com/b/script.js";
  33 const int kRenderProcessId = 99;
  34
  35 void RegisterServiceWorkerCallback(bool* called,
  36                                    int64* store_registration_id,
  37                                    ServiceWorkerStatusCode status,
  38                                    const std::string& status_message,
  39                                    int64 registration_id) {
  40   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
  41   *called = true;
  42   *store_registration_id = registration_id;
  43 }
  44
  45 void FindServiceWorkerRegistrationCallback(
  46     scoped_refptr<ServiceWorkerRegistration>* out_registration,
  47     ServiceWorkerStatusCode status,
  48     const scoped_refptr<ServiceWorkerRegistration>& registration) {
  49   EXPECT_EQ(SERVICE_WORKER_OK, status) << ServiceWorkerStatusToString(status);
  50   *out_registration = registration;
  51 }
  52
  53 void UnregisterServiceWorkerCallback(bool* called,
  54                                      ServiceWorkerStatusCode code) {
  55   EXPECT_EQ(SERVICE_WORKER_OK, code);
  56   *called = true;
  57 }
  58
  59 void OneShotSuccessfulCallback(
  60     int* count,
  61     const scoped_refptr<ServiceWorkerVersion>& active_version,
  62     const ServiceWorkerVersion::StatusCallback& callback) {
  63   *count += 1;
  64   callback.Run(SERVICE_WORKER_OK);
  65 }
  66
  67 void OneShotFailedCallback(
  68     int* count,
  69     const scoped_refptr<ServiceWorkerVersion>& active_version,
  70     const ServiceWorkerVersion::StatusCallback& callback) {
  71   *count += 1;
  72   callback.Run(SERVICE_WORKER_ERROR_FAILED);
  73 }
  74
  75 void OneShotDelayedCallback(
  76     int* count,
  77     ServiceWorkerVersion::StatusCallback* out_callback,
  78     const scoped_refptr<ServiceWorkerVersion>& active_version,
  79     const ServiceWorkerVersion::StatusCallback& callback) {
  80   *count += 1;
  81   *out_callback = callback;
  82 }
  83
  84 class TestPowerSource : public base::PowerMonitorSource {
  85  public:
  86   void GeneratePowerStateEvent(bool on_battery_power) {
  87     test_on_battery_power_ = on_battery_power;
  88     ProcessPowerEvent(POWER_STATE_EVENT);
  89   }
  90
  91  private:
  92   bool IsOnBatteryPowerImpl() final { return test_on_battery_power_; }
  93   bool test_on_battery_power_ = false;
  94 };
  95
  96 }  // namespace
  97
  98 // A BackgroundSyncManager that can simulate delaying and corrupting the backend
  99 // storage and service worker onsync events.
 100 class TestBackgroundSyncManager : public BackgroundSyncManager {
 101  public:
 102   using OneShotCallback =
 103       base::Callback<void(const scoped_refptr<ServiceWorkerVersion>&,
 104                           const ServiceWorkerVersion::StatusCallback&)>;
 105
 106   explicit TestBackgroundSyncManager(
 107       const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context)
 108       : BackgroundSyncManager(service_worker_context) {}
 109
 110   void DoInit() { Init(); }
 111
 112   void StoreDataInBackendContinue(
 113       int64 sw_registration_id,
 114       const GURL& origin,
 115       const std::string& key,
 116       const std::string& data,
 117       const ServiceWorkerStorage::StatusCallback& callback) {
 118     BackgroundSyncManager::StoreDataInBackend(sw_registration_id, origin, key,
 119                                               data, callback);
 120   }
 121
 122   void GetDataFromBackendContinue(
 123       const std::string& key,
 124       const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
 125           callback) {
 126     BackgroundSyncManager::GetDataFromBackend(key, callback);
 127   }
 128
 129   void Continue() {
 130     continuation_.Run();
 131     continuation_.Reset();
 132   }
 133
 134   void set_corrupt_backend(bool corrupt_backend) {
 135     corrupt_backend_ = corrupt_backend;
 136   }
 137   void set_delay_backend(bool delay_backend) { delay_backend_ = delay_backend; }
 138   void set_one_shot_callback(const OneShotCallback& callback) {
 139     one_shot_callback_ = callback;
 140   }
 141
 142  protected:
 143   void StoreDataInBackend(
 144       int64 sw_registration_id,
 145       const GURL& origin,
 146       const std::string& key,
 147       const std::string& data,
 148       const ServiceWorkerStorage::StatusCallback& callback) override {
 149     EXPECT_TRUE(continuation_.is_null());
 150     if (corrupt_backend_) {
 151       base::ThreadTaskRunnerHandle::Get()->PostTask(
 152           FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
 153       return;
 154     }
 155     continuation_ =
 156         base::Bind(&TestBackgroundSyncManager::StoreDataInBackendContinue,
 157                    base::Unretained(this), sw_registration_id, origin, key,
 158                    data, callback);
 159     if (delay_backend_)
 160       return;
 161
 162     Continue();
 163   }
 164
 165   void GetDataFromBackend(
 166       const std::string& key,
 167       const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
 168           callback) override {
 169     EXPECT_TRUE(continuation_.is_null());
 170     if (corrupt_backend_) {
 171       base::ThreadTaskRunnerHandle::Get()->PostTask(
 172           FROM_HERE,
 173           base::Bind(callback, std::vector<std::pair<int64, std::string>>(),
 174                      SERVICE_WORKER_ERROR_FAILED));
 175       return;
 176     }
 177     continuation_ =
 178         base::Bind(&TestBackgroundSyncManager::GetDataFromBackendContinue,
 179                    base::Unretained(this), key, callback);
 180     if (delay_backend_)
 181       return;
 182
 183     Continue();
 184   }
 185
 186   void FireOneShotSync(
 187       const BackgroundSyncRegistration& registration,
 188       const scoped_refptr<ServiceWorkerVersion>& active_version,
 189       const ServiceWorkerVersion::StatusCallback& callback) override {
 190     if (one_shot_callback_.is_null()) {
 191       BackgroundSyncManager::FireOneShotSync(registration, active_version,
 192                                              callback);
 193     } else {
 194       one_shot_callback_.Run(active_version, callback);
 195     }
 196   }
 197
 198  private:
 199   bool corrupt_backend_ = false;
 200   bool delay_backend_ = false;
 201   base::Closure continuation_;
 202   OneShotCallback one_shot_callback_;
 203 };
 204
 205 class BackgroundSyncManagerTest : public testing::Test {
 206  public:
 207   BackgroundSyncManagerTest()
 208       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
 209         network_change_notifier_(net::NetworkChangeNotifier::CreateMock()),
 210         test_background_sync_manager_(nullptr),
 211         callback_status_(BACKGROUND_SYNC_STATUS_OK),
 212         callback_sw_status_code_(SERVICE_WORKER_OK),
 213         sync_events_called_(0) {
 214     sync_options_1_.tag = "foo";
 215     sync_options_1_.periodicity = SYNC_ONE_SHOT;
 216     sync_options_1_.network_state = NETWORK_STATE_ONLINE;
 217     sync_options_1_.power_state = POWER_STATE_AUTO;
 218
 219     sync_options_2_.tag = "bar";
 220     sync_options_2_.periodicity = SYNC_ONE_SHOT;
 221     sync_options_2_.network_state = NETWORK_STATE_ONLINE;
 222     sync_options_2_.power_state = POWER_STATE_AUTO;
 223   }
 224
 225   void SetUp() override {
 226     helper_.reset(
 227         new EmbeddedWorkerTestHelper(base::FilePath(), kRenderProcessId));
 228
 229     power_monitor_source_ = new TestPowerSource();
 230     // power_monitor_ takes ownership of power_monitor_source.
 231     power_monitor_.reset(new base::PowerMonitor(
 232         scoped_ptr<base::PowerMonitorSource>(power_monitor_source_)));
 233
 234     SetOnBatteryPower(false);
 235
 236     SetupBackgroundSyncManager();
 237
 238     // Wait for storage to finish initializing before registering service
 239     // workers.
 240     base::RunLoop().RunUntilIdle();
 241     RegisterServiceWorkers();
 242   }
 243
 244   void RegisterServiceWorkers() {
 245     bool called_1 = false;
 246     bool called_2 = false;
 247     helper_->context()->RegisterServiceWorker(
 248         GURL(kPattern1), GURL(kScript1), NULL,
 249         base::Bind(&RegisterServiceWorkerCallback, &called_1,
 250                    &sw_registration_id_1_));
 251
 252     helper_->context()->RegisterServiceWorker(
 253         GURL(kPattern2), GURL(kScript2), NULL,
 254         base::Bind(&RegisterServiceWorkerCallback, &called_2,
 255                    &sw_registration_id_2_));
 256     base::RunLoop().RunUntilIdle();
 257     EXPECT_TRUE(called_1);
 258     EXPECT_TRUE(called_2);
 259
 260     // Register window clients for the service workers
 261     host_1_.reset(new ServiceWorkerProviderHost(
 262         34 /* dummy render proces id */, MSG_ROUTING_NONE /* render_frame_id */,
 263         1 /* dummy provider id */, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
 264         helper_->context()->AsWeakPtr(), nullptr));
 265     host_1_->SetDocumentUrl(GURL(kPattern1));
 266     host_2_.reset(new ServiceWorkerProviderHost(
 267         34 /* dummy render proces id */, MSG_ROUTING_NONE /* render_frame_id */,
 268         1 /* dummy provider id */, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
 269         helper_->context()->AsWeakPtr(), nullptr));
 270     host_2_->SetDocumentUrl(GURL(kPattern2));
 271
 272     // Hang onto the registrations as they need to be "live" when
 273     // calling BackgroundSyncManager::Register.
 274     helper_->context_wrapper()->FindRegistrationForId(
 275         sw_registration_id_1_, GURL(kPattern1).GetOrigin(),
 276         base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_1_));
 277
 278     helper_->context_wrapper()->FindRegistrationForId(
 279         sw_registration_id_2_, GURL(kPattern1).GetOrigin(),
 280         base::Bind(FindServiceWorkerRegistrationCallback, &sw_registration_2_));
 281     base::RunLoop().RunUntilIdle();
 282     EXPECT_TRUE(sw_registration_1_);
 283     EXPECT_TRUE(sw_registration_2_);
 284
 285     sw_registration_1_->active_version()->AddControllee(host_1_.get());
 286     sw_registration_2_->active_version()->AddControllee(host_2_.get());
 287   }
 288
 289   void RemoveWindowClients() {
 290     sw_registration_1_->active_version()->RemoveControllee(host_1_.get());
 291     sw_registration_2_->active_version()->RemoveControllee(host_2_.get());
 292   }
 293
 294   void SetNetwork(net::NetworkChangeNotifier::ConnectionType connection_type) {
 295     net::NetworkChangeNotifier::NotifyObserversOfNetworkChangeForTests(
 296         connection_type);
 297     base::RunLoop().RunUntilIdle();
 298   }
 299
 300   void SetOnBatteryPower(bool on_battery_power) {
 301     power_monitor_source_->GeneratePowerStateEvent(on_battery_power);
 302     base::RunLoop().RunUntilIdle();
 303   }
 304
 305   void StatusAndRegistrationCallback(
 306       bool* was_called,
 307       BackgroundSyncStatus status,
 308       const BackgroundSyncRegistration& registration) {
 309     *was_called = true;
 310     callback_status_ = status;
 311     callback_registration_ = registration;
 312   }
 313
 314   void StatusAndRegistrationsCallback(
 315       bool* was_called,
 316       BackgroundSyncStatus status,
 317       const std::vector<BackgroundSyncRegistration>& registrations) {
 318     *was_called = true;
 319     callback_status_ = status;
 320     callback_registrations_ = registrations;
 321   }
 322
 323   void StatusCallback(bool* was_called, BackgroundSyncStatus status) {
 324     *was_called = true;
 325     callback_status_ = status;
 326   }
 327
 328  protected:
 329   void CreateBackgroundSyncManager() {
 330     test_background_sync_manager_ =
 331         new TestBackgroundSyncManager(helper_->context_wrapper());
 332     background_sync_manager_.reset(test_background_sync_manager_);
 333   }
 334
 335   void InitBackgroundSyncManager() {
 336     test_background_sync_manager_->DoInit();
 337
 338     // Many tests do not expect the sync event to fire immediately after
 339     // register (and cleanup up the sync registrations).  Tests can control when
 340     // the sync event fires by manipulating the network state as needed.
 341     // NOTE: The setup of the network connection must happen after the
 342     //       BackgroundSyncManager has been setup.
 343     SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
 344   }
 345
 346   void SetupBackgroundSyncManager() {
 347     CreateBackgroundSyncManager();
 348     InitBackgroundSyncManager();
 349   }
 350
 351   void SetupCorruptBackgroundSyncManager() {
 352     CreateBackgroundSyncManager();
 353     test_background_sync_manager_->set_corrupt_backend(true);
 354     InitBackgroundSyncManager();
 355   }
 356
 357   void SetupDelayedBackgroundSyncManager() {
 358     CreateBackgroundSyncManager();
 359     test_background_sync_manager_->set_delay_backend(true);
 360     InitBackgroundSyncManager();
 361   }
 362
 363   void DeleteBackgroundSyncManager() {
 364     background_sync_manager_.reset();
 365     test_background_sync_manager_ = nullptr;
 366   }
 367
 368   bool Register(const BackgroundSyncRegistrationOptions& sync_options) {
 369     return RegisterWithServiceWorkerId(sw_registration_id_1_, sync_options);
 370   }
 371
 372   bool RegisterWithServiceWorkerId(
 373       int64 sw_registration_id,
 374       const BackgroundSyncRegistrationOptions& options) {
 375     bool was_called = false;
 376     background_sync_manager_->Register(
 377         sw_registration_id, options, true /* requested_from_service_worker */,
 378         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
 379                    base::Unretained(this), &was_called));
 380     base::RunLoop().RunUntilIdle();
 381     EXPECT_TRUE(was_called);
 382     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
 383   }
 384
 385   bool RegisterFromDocumentWithServiceWorkerId(
 386       int64 sw_registration_id,
 387       const BackgroundSyncRegistrationOptions& options) {
 388     bool was_called = false;
 389     background_sync_manager_->Register(
 390         sw_registration_id, options, false /* requested_from_service_worker */,
 391         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
 392                    base::Unretained(this), &was_called));
 393     base::RunLoop().RunUntilIdle();
 394     EXPECT_TRUE(was_called);
 395     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
 396   }
 397
 398   bool Unregister(const BackgroundSyncRegistration& sync_registration) {
 399     return UnregisterWithServiceWorkerId(sw_registration_id_1_,
 400                                          sync_registration);
 401   }
 402
 403   bool UnregisterWithServiceWorkerId(
 404       int64 sw_registration_id,
 405       const BackgroundSyncRegistration& sync_registration) {
 406     bool was_called = false;
 407     background_sync_manager_->Unregister(
 408         sw_registration_id, sync_registration.options()->tag,
 409         sync_registration.options()->periodicity, sync_registration.id(),
 410         base::Bind(&BackgroundSyncManagerTest::StatusCallback,
 411                    base::Unretained(this), &was_called));
 412     base::RunLoop().RunUntilIdle();
 413     EXPECT_TRUE(was_called);
 414     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
 415   }
 416
 417   bool GetRegistration(const BackgroundSyncRegistrationOptions& sync_options) {
 418     return GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
 419                                               sync_options);
 420   }
 421
 422   bool GetRegistrationWithServiceWorkerId(
 423       int64 sw_registration_id,
 424       const BackgroundSyncRegistrationOptions& sync_options) {
 425     bool was_called = false;
 426     background_sync_manager_->GetRegistration(
 427         sw_registration_id, sync_options.tag, sync_options.periodicity,
 428         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
 429                    base::Unretained(this), &was_called));
 430     base::RunLoop().RunUntilIdle();
 431     EXPECT_TRUE(was_called);
 432
 433     if (callback_status_ == BACKGROUND_SYNC_STATUS_OK) {
 434       EXPECT_STREQ(sync_options.tag.c_str(),
 435                    callback_registration_.options()->tag.c_str());
 436     }
 437
 438     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
 439   }
 440
 441   bool GetRegistrations(SyncPeriodicity periodicity) {
 442     return GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
 443                                               periodicity);
 444   }
 445
 446   bool GetRegistrationWithServiceWorkerId(int64 sw_registration_id,
 447                                           SyncPeriodicity periodicity) {
 448     bool was_called = false;
 449     background_sync_manager_->GetRegistrations(
 450         sw_registration_id, periodicity,
 451         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationsCallback,
 452                    base::Unretained(this), &was_called));
 453     base::RunLoop().RunUntilIdle();
 454     EXPECT_TRUE(was_called);
 455
 456     return callback_status_ == BACKGROUND_SYNC_STATUS_OK;
 457   }
 458
 459   void StorageRegistrationCallback(ServiceWorkerStatusCode result) {
 460     callback_sw_status_code_ = result;
 461   }
 462
 463   void UnregisterServiceWorker(uint64 sw_registration_id) {
 464     bool called = false;
 465     helper_->context()->UnregisterServiceWorker(
 466         PatternForSWId(sw_registration_id),
 467         base::Bind(&UnregisterServiceWorkerCallback, &called));
 468     base::RunLoop().RunUntilIdle();
 469     EXPECT_TRUE(called);
 470   }
 471
 472   GURL PatternForSWId(int64 sw_id) {
 473     EXPECT_TRUE(sw_id == sw_registration_id_1_ ||
 474                 sw_id == sw_registration_id_2_);
 475     return sw_id == sw_registration_id_1_ ? GURL(kPattern1) : GURL(kPattern2);
 476   }
 477
 478   void SetupForSyncEvent(
 479       const TestBackgroundSyncManager::OneShotCallback& callback) {
 480     test_background_sync_manager_->set_one_shot_callback(callback);
 481     SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
 482   }
 483
 484   void InitSyncEventTest() {
 485     SetupForSyncEvent(
 486         base::Bind(OneShotSuccessfulCallback, &sync_events_called_));
 487   }
 488
 489   void InitFailedSyncEventTest() {
 490     SetupForSyncEvent(base::Bind(OneShotFailedCallback, &sync_events_called_));
 491   }
 492
 493   void InitDelayedSyncEventTest() {
 494     SetupForSyncEvent(base::Bind(OneShotDelayedCallback, &sync_events_called_,
 495                                  &sync_fired_callback_));
 496   }
 497
 498   void RegisterAndVerifySyncEventDelayed(
 499       const BackgroundSyncRegistrationOptions& sync_options) {
 500     int sync_events_called = sync_events_called_;
 501     EXPECT_TRUE(sync_fired_callback_.is_null());
 502
 503     EXPECT_TRUE(Register(sync_options));
 504
 505     EXPECT_EQ(sync_events_called + 1, sync_events_called_);
 506     EXPECT_TRUE(GetRegistration(sync_options_1_));
 507     EXPECT_FALSE(sync_fired_callback_.is_null());
 508   }
 509
 510   TestBrowserThreadBundle browser_thread_bundle_;
 511   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
 512   TestPowerSource* power_monitor_source_;  // owned by power_monitor_
 513   scoped_ptr<base::PowerMonitor> power_monitor_;
 514   scoped_ptr<EmbeddedWorkerTestHelper> helper_;
 515   scoped_ptr<BackgroundSyncManager> background_sync_manager_;
 516   TestBackgroundSyncManager* test_background_sync_manager_;
 517
 518   scoped_ptr<ServiceWorkerProviderHost> host_1_;
 519   scoped_ptr<ServiceWorkerProviderHost> host_2_;
 520   int64 sw_registration_id_1_;
 521   int64 sw_registration_id_2_;
 522   scoped_refptr<ServiceWorkerRegistration> sw_registration_1_;
 523   scoped_refptr<ServiceWorkerRegistration> sw_registration_2_;
 524
 525   BackgroundSyncRegistrationOptions sync_options_1_;
 526   BackgroundSyncRegistrationOptions sync_options_2_;
 527
 528   // Callback values.
 529   BackgroundSyncStatus callback_status_;
 530   BackgroundSyncRegistration callback_registration_;
 531   std::vector<BackgroundSyncRegistration> callback_registrations_;
 532   ServiceWorkerStatusCode callback_sw_status_code_;
 533   int sync_events_called_;
 534   ServiceWorkerVersion::StatusCallback sync_fired_callback_;
 535 };
 536
 537 TEST_F(BackgroundSyncManagerTest, Register) {
 538   EXPECT_TRUE(Register(sync_options_1_));
 539 }
 540
 541 TEST_F(BackgroundSyncManagerTest, RegistractionIntact) {
 542   EXPECT_TRUE(Register(sync_options_1_));
 543   EXPECT_STREQ(sync_options_1_.tag.c_str(),
 544                callback_registration_.options()->tag.c_str());
 545   EXPECT_TRUE(callback_registration_.IsValid());
 546 }
 547
 548 TEST_F(BackgroundSyncManagerTest, RegisterWithoutLiveSWRegistration) {
 549   sw_registration_1_ = nullptr;
 550   EXPECT_FALSE(Register(sync_options_1_));
 551   EXPECT_EQ(BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER, callback_status_);
 552 }
 553
 554 TEST_F(BackgroundSyncManagerTest, RegisterWithoutActiveSWRegistration) {
 555   sw_registration_1_->UnsetVersion(sw_registration_1_->active_version());
 556   EXPECT_FALSE(Register(sync_options_1_));
 557   EXPECT_EQ(BACKGROUND_SYNC_STATUS_NO_SERVICE_WORKER, callback_status_);
 558 }
 559
 560 TEST_F(BackgroundSyncManagerTest, RegisterExistingKeepsId) {
 561   EXPECT_TRUE(Register(sync_options_1_));
 562   BackgroundSyncRegistration first_registration = callback_registration_;
 563   EXPECT_TRUE(Register(sync_options_1_));
 564   EXPECT_TRUE(callback_registration_.Equals(first_registration));
 565   EXPECT_EQ(first_registration.id(), callback_registration_.id());
 566 }
 567
 568 TEST_F(BackgroundSyncManagerTest, RegisterOverwrites) {
 569   EXPECT_TRUE(Register(sync_options_1_));
 570   BackgroundSyncRegistration first_registration = callback_registration_;
 571
 572   sync_options_1_.min_period = 100;
 573   EXPECT_TRUE(Register(sync_options_1_));
 574   EXPECT_LT(first_registration.id(), callback_registration_.id());
 575   EXPECT_FALSE(callback_registration_.Equals(first_registration));
 576 }
 577
 578 TEST_F(BackgroundSyncManagerTest, RegisterOverlappingPeriodicAndOneShotTags) {
 579   // Registrations with the same tags but different periodicities should not
 580   // collide.
 581   sync_options_1_.tag = "";
 582   sync_options_2_.tag = "";
 583   sync_options_1_.periodicity = SYNC_PERIODIC;
 584   sync_options_2_.periodicity = SYNC_ONE_SHOT;
 585   EXPECT_TRUE(Register(sync_options_1_));
 586   EXPECT_TRUE(Register(sync_options_2_));
 587   EXPECT_TRUE(GetRegistration(sync_options_1_));
 588   EXPECT_EQ(SYNC_PERIODIC, callback_registration_.options()->periodicity);
 589   EXPECT_TRUE(GetRegistration(sync_options_2_));
 590   EXPECT_EQ(SYNC_ONE_SHOT, callback_registration_.options()->periodicity);
 591 }
 592
 593 TEST_F(BackgroundSyncManagerTest, RegisterBadBackend) {
 594   test_background_sync_manager_->set_corrupt_backend(true);
 595   EXPECT_FALSE(Register(sync_options_1_));
 596   test_background_sync_manager_->set_corrupt_backend(false);
 597   EXPECT_FALSE(Register(sync_options_1_));
 598   EXPECT_FALSE(GetRegistration(sync_options_1_));
 599 }
 600
 601 TEST_F(BackgroundSyncManagerTest, TwoRegistrations) {
 602   EXPECT_TRUE(Register(sync_options_1_));
 603   EXPECT_TRUE(Register(sync_options_2_));
 604 }
 605
 606 TEST_F(BackgroundSyncManagerTest, GetRegistrationNonExisting) {
 607   EXPECT_FALSE(GetRegistration(sync_options_1_));
 608 }
 609
 610 TEST_F(BackgroundSyncManagerTest, GetRegistrationExisting) {
 611   EXPECT_TRUE(Register(sync_options_1_));
 612   EXPECT_TRUE(GetRegistration(sync_options_1_));
 613   EXPECT_FALSE(GetRegistration(sync_options_2_));
 614 }
 615
 616 TEST_F(BackgroundSyncManagerTest, GetRegistrationBadBackend) {
 617   EXPECT_TRUE(Register(sync_options_1_));
 618   test_background_sync_manager_->set_corrupt_backend(true);
 619   EXPECT_TRUE(GetRegistration(sync_options_1_));
 620   EXPECT_FALSE(Register(sync_options_2_));
 621   // Registration should have discovered the bad backend and disabled the
 622   // BackgroundSyncManager.
 623   EXPECT_FALSE(GetRegistration(sync_options_1_));
 624   test_background_sync_manager_->set_corrupt_backend(false);
 625   EXPECT_FALSE(GetRegistration(sync_options_1_));
 626 }
 627
 628 TEST_F(BackgroundSyncManagerTest, GetRegistrationsZero) {
 629   EXPECT_TRUE(GetRegistrations(SYNC_ONE_SHOT));
 630   EXPECT_EQ(0u, callback_registrations_.size());
 631 }
 632
 633 TEST_F(BackgroundSyncManagerTest, GetRegistrationsOne) {
 634   EXPECT_TRUE(Register(sync_options_1_));
 635   EXPECT_TRUE(GetRegistrations(sync_options_1_.periodicity));
 636
 637   EXPECT_EQ(1u, callback_registrations_.size());
 638   sync_options_1_.Equals(*callback_registrations_[0].options());
 639 }
 640
 641 TEST_F(BackgroundSyncManagerTest, GetRegistrationsTwo) {
 642   EXPECT_EQ(sync_options_1_.periodicity, sync_options_2_.periodicity);
 643
 644   EXPECT_TRUE(Register(sync_options_1_));
 645   EXPECT_TRUE(Register(sync_options_2_));
 646   EXPECT_TRUE(GetRegistrations(sync_options_1_.periodicity));
 647
 648   EXPECT_EQ(2u, callback_registrations_.size());
 649   sync_options_1_.Equals(*callback_registrations_[0].options());
 650   sync_options_2_.Equals(*callback_registrations_[1].options());
 651 }
 652
 653 TEST_F(BackgroundSyncManagerTest, GetRegistrationsPeriodicity) {
 654   sync_options_1_.periodicity = SYNC_ONE_SHOT;
 655   sync_options_2_.periodicity = SYNC_PERIODIC;
 656   EXPECT_TRUE(Register(sync_options_1_));
 657   EXPECT_TRUE(Register(sync_options_2_));
 658
 659   EXPECT_TRUE(GetRegistrations(SYNC_ONE_SHOT));
 660   EXPECT_EQ(1u, callback_registrations_.size());
 661   sync_options_1_.Equals(*callback_registrations_[0].options());
 662
 663   EXPECT_TRUE(GetRegistrations(SYNC_PERIODIC));
 664   EXPECT_EQ(1u, callback_registrations_.size());
 665   sync_options_2_.Equals(*callback_registrations_[0].options());
 666 }
 667
 668 TEST_F(BackgroundSyncManagerTest, GetRegistrationsBadBackend) {
 669   EXPECT_TRUE(Register(sync_options_1_));
 670   test_background_sync_manager_->set_corrupt_backend(true);
 671   EXPECT_TRUE(GetRegistrations(sync_options_1_.periodicity));
 672   EXPECT_FALSE(Register(sync_options_2_));
 673   // Registration should have discovered the bad backend and disabled the
 674   // BackgroundSyncManager.
 675   EXPECT_FALSE(GetRegistrations(sync_options_1_.periodicity));
 676   test_background_sync_manager_->set_corrupt_backend(false);
 677   EXPECT_FALSE(GetRegistrations(sync_options_1_.periodicity));
 678 }
 679
 680 TEST_F(BackgroundSyncManagerTest, Unregister) {
 681   EXPECT_TRUE(Register(sync_options_1_));
 682   EXPECT_TRUE(Unregister(callback_registration_));
 683   EXPECT_FALSE(GetRegistration(sync_options_1_));
 684 }
 685
 686 TEST_F(BackgroundSyncManagerTest, UnregisterWrongId) {
 687   EXPECT_TRUE(Register(sync_options_1_));
 688   callback_registration_.set_id(callback_registration_.id() + 1);
 689   EXPECT_FALSE(Unregister(callback_registration_));
 690 }
 691
 692 TEST_F(BackgroundSyncManagerTest, Reregister) {
 693   EXPECT_TRUE(Register(sync_options_1_));
 694   EXPECT_TRUE(Unregister(callback_registration_));
 695   EXPECT_TRUE(Register(sync_options_1_));
 696 }
 697
 698 TEST_F(BackgroundSyncManagerTest, UnregisterNonExisting) {
 699   BackgroundSyncRegistration nonexistant_registration;
 700   nonexistant_registration.set_id(1);
 701   EXPECT_FALSE(Unregister(nonexistant_registration));
 702   EXPECT_EQ(BACKGROUND_SYNC_STATUS_NOT_FOUND, callback_status_);
 703 }
 704
 705 TEST_F(BackgroundSyncManagerTest, UnregisterSecond) {
 706   EXPECT_TRUE(Register(sync_options_1_));
 707   EXPECT_TRUE(Register(sync_options_2_));
 708   EXPECT_TRUE(Unregister(callback_registration_));
 709   EXPECT_TRUE(GetRegistration(sync_options_1_));
 710   EXPECT_TRUE(Register(sync_options_2_));
 711 }
 712
 713 TEST_F(BackgroundSyncManagerTest, UnregisterBadBackend) {
 714   sync_options_1_.min_period += 1;
 715   EXPECT_TRUE(Register(sync_options_1_));
 716   EXPECT_TRUE(Register(sync_options_2_));
 717   test_background_sync_manager_->set_corrupt_backend(true);
 718   EXPECT_FALSE(Unregister(callback_registration_));
 719   // Unregister should have discovered the bad backend and disabled the
 720   // BackgroundSyncManager.
 721   test_background_sync_manager_->set_corrupt_backend(false);
 722   EXPECT_FALSE(GetRegistration(sync_options_1_));
 723   EXPECT_FALSE(GetRegistration(sync_options_2_));
 724 }
 725
 726 TEST_F(BackgroundSyncManagerTest, RegistrationIncreasesId) {
 727   EXPECT_TRUE(Register(sync_options_1_));
 728   BackgroundSyncRegistration registered_sync = callback_registration_;
 729   BackgroundSyncRegistration::RegistrationId cur_id =
 730       callback_registration_.id();
 731
 732   EXPECT_TRUE(GetRegistration(sync_options_1_));
 733   EXPECT_TRUE(Register(sync_options_2_));
 734   EXPECT_LT(cur_id, callback_registration_.id());
 735   cur_id = callback_registration_.id();
 736
 737   EXPECT_TRUE(Unregister(registered_sync));
 738   EXPECT_TRUE(Register(sync_options_1_));
 739   EXPECT_LT(cur_id, callback_registration_.id());
 740 }
 741
 742 TEST_F(BackgroundSyncManagerTest, RebootRecovery) {
 743   EXPECT_TRUE(Register(sync_options_1_));
 744
 745   SetupBackgroundSyncManager();
 746
 747   EXPECT_TRUE(GetRegistration(sync_options_1_));
 748   EXPECT_FALSE(GetRegistration(sync_options_2_));
 749 }
 750
 751 TEST_F(BackgroundSyncManagerTest, RebootRecoveryTwoServiceWorkers) {
 752   EXPECT_TRUE(
 753       RegisterWithServiceWorkerId(sw_registration_id_1_, sync_options_1_));
 754   EXPECT_TRUE(
 755       RegisterWithServiceWorkerId(sw_registration_id_2_, sync_options_2_));
 756
 757   SetupBackgroundSyncManager();
 758
 759   EXPECT_TRUE(GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
 760                                                  sync_options_1_));
 761   EXPECT_FALSE(GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
 762                                                   sync_options_2_));
 763   EXPECT_FALSE(GetRegistrationWithServiceWorkerId(sw_registration_id_2_,
 764                                                   sync_options_1_));
 765   EXPECT_TRUE(GetRegistrationWithServiceWorkerId(sw_registration_id_2_,
 766                                                  sync_options_2_));
 767
 768   EXPECT_TRUE(GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
 769                                                  sync_options_1_));
 770   EXPECT_TRUE(GetRegistrationWithServiceWorkerId(sw_registration_id_2_,
 771                                                  sync_options_2_));
 772
 773   EXPECT_TRUE(
 774       RegisterWithServiceWorkerId(sw_registration_id_1_, sync_options_2_));
 775   EXPECT_TRUE(
 776       RegisterWithServiceWorkerId(sw_registration_id_2_, sync_options_1_));
 777 }
 778
 779 TEST_F(BackgroundSyncManagerTest, InitWithBadBackend) {
 780   SetupCorruptBackgroundSyncManager();
 781
 782   EXPECT_FALSE(Register(sync_options_1_));
 783   EXPECT_FALSE(GetRegistration(sync_options_1_));
 784 }
 785
 786 TEST_F(BackgroundSyncManagerTest, SequentialOperations) {
 787   // Schedule Init and all of the operations on a delayed backend. Verify that
 788   // the operations complete sequentially.
 789   SetupDelayedBackgroundSyncManager();
 790
 791   const int64 kExpectedInitialId = BackgroundSyncRegistration::kInitialId;
 792
 793   bool register_called = false;
 794   bool unregister_called = false;
 795   bool get_registration_called = false;
 796   test_background_sync_manager_->Register(
 797       sw_registration_id_1_, sync_options_1_,
 798       true /* requested_from_service_worker */,
 799       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
 800                  base::Unretained(this), &register_called));
 801   test_background_sync_manager_->Unregister(
 802       sw_registration_id_1_, sync_options_1_.tag, sync_options_1_.periodicity,
 803       kExpectedInitialId,
 804       base::Bind(&BackgroundSyncManagerTest::StatusCallback,
 805                  base::Unretained(this), &unregister_called));
 806   test_background_sync_manager_->GetRegistration(
 807       sw_registration_id_1_, sync_options_1_.tag, sync_options_1_.periodicity,
 808       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
 809                  base::Unretained(this), &get_registration_called));
 810
 811   base::RunLoop().RunUntilIdle();
 812   // Init should be blocked while loading from the backend.
 813   EXPECT_FALSE(register_called);
 814   EXPECT_FALSE(unregister_called);
 815   EXPECT_FALSE(get_registration_called);
 816
 817   test_background_sync_manager_->Continue();
 818   base::RunLoop().RunUntilIdle();
 819   // Register should be blocked while storing to the backend.
 820   EXPECT_FALSE(register_called);
 821   EXPECT_FALSE(unregister_called);
 822   EXPECT_FALSE(get_registration_called);
 823
 824   test_background_sync_manager_->Continue();
 825   base::RunLoop().RunUntilIdle();
 826   EXPECT_TRUE(register_called);
 827   EXPECT_EQ(kExpectedInitialId, callback_registration_.id());
 828   EXPECT_EQ(BACKGROUND_SYNC_STATUS_OK, callback_status_);
 829   // Unregister should be blocked while storing to the backend.
 830   EXPECT_FALSE(unregister_called);
 831   EXPECT_FALSE(get_registration_called);
 832
 833   test_background_sync_manager_->Continue();
 834   base::RunLoop().RunUntilIdle();
 835   // Unregister should be done and since GetRegistration doesn't require the
 836   // backend it should be done too.
 837   EXPECT_EQ(BACKGROUND_SYNC_STATUS_NOT_FOUND, callback_status_);
 838   EXPECT_TRUE(unregister_called);
 839   EXPECT_TRUE(get_registration_called);
 840 }
 841
 842 TEST_F(BackgroundSyncManagerTest, UnregisterServiceWorker) {
 843   EXPECT_TRUE(Register(sync_options_1_));
 844   UnregisterServiceWorker(sw_registration_id_1_);
 845   EXPECT_FALSE(GetRegistration(sync_options_1_));
 846 }
 847
 848 TEST_F(BackgroundSyncManagerTest,
 849        UnregisterServiceWorkerDuringSyncRegistration) {
 850   EXPECT_TRUE(Register(sync_options_1_));
 851
 852   test_background_sync_manager_->set_delay_backend(true);
 853   bool callback_called = false;
 854   test_background_sync_manager_->Register(
 855       sw_registration_id_1_, sync_options_2_,
 856       true /* requested_from_service_worker */,
 857       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
 858                  base::Unretained(this), &callback_called));
 859
 860   base::RunLoop().RunUntilIdle();
 861   EXPECT_FALSE(callback_called);
 862   UnregisterServiceWorker(sw_registration_id_1_);
 863
 864   test_background_sync_manager_->Continue();
 865   base::RunLoop().RunUntilIdle();
 866   EXPECT_TRUE(callback_called);
 867   EXPECT_EQ(BACKGROUND_SYNC_STATUS_STORAGE_ERROR, callback_status_);
 868
 869   test_background_sync_manager_->set_delay_backend(false);
 870   EXPECT_FALSE(GetRegistration(sync_options_1_));
 871 }
 872
 873 TEST_F(BackgroundSyncManagerTest, DeleteAndStartOverServiceWorkerContext) {
 874   EXPECT_TRUE(Register(sync_options_1_));
 875   helper_->context()->ScheduleDeleteAndStartOver();
 876   base::RunLoop().RunUntilIdle();
 877   EXPECT_FALSE(GetRegistration(sync_options_1_));
 878 }
 879
 880 TEST_F(BackgroundSyncManagerTest, DisabledManagerWorksAfterBrowserRestart) {
 881   EXPECT_TRUE(Register(sync_options_1_));
 882   test_background_sync_manager_->set_corrupt_backend(true);
 883   EXPECT_FALSE(Register(sync_options_2_));
 884
 885   // The manager is now disabled and not accepting new requests until browser
 886   // restart or notification that the storage has been wiped.
 887   test_background_sync_manager_->set_corrupt_backend(false);
 888   EXPECT_FALSE(GetRegistration(sync_options_1_));
 889   EXPECT_FALSE(Register(sync_options_2_));
 890
 891   // Simulate restarting the browser by creating a new BackgroundSyncManager.
 892   SetupBackgroundSyncManager();
 893   EXPECT_TRUE(GetRegistration(sync_options_1_));
 894   EXPECT_TRUE(Register(sync_options_2_));
 895 }
 896
 897 TEST_F(BackgroundSyncManagerTest, DisabledManagerWorksAfterDeleteAndStartOver) {
 898   EXPECT_TRUE(Register(sync_options_1_));
 899   test_background_sync_manager_->set_corrupt_backend(true);
 900   EXPECT_FALSE(Register(sync_options_2_));
 901
 902   // The manager is now disabled and not accepting new requests until browser
 903   // restart or notification that the storage has been wiped.
 904   test_background_sync_manager_->set_corrupt_backend(false);
 905   helper_->context()->ScheduleDeleteAndStartOver();
 906   base::RunLoop().RunUntilIdle();
 907
 908   RegisterServiceWorkers();
 909
 910   EXPECT_TRUE(Register(sync_options_2_));
 911   EXPECT_FALSE(GetRegistration(sync_options_1_));
 912   EXPECT_TRUE(GetRegistration(sync_options_2_));
 913 }
 914
 915 TEST_F(BackgroundSyncManagerTest, RegistrationEqualsId) {
 916   BackgroundSyncRegistration reg_1;
 917   BackgroundSyncRegistration reg_2;
 918
 919   EXPECT_TRUE(reg_1.Equals(reg_2));
 920   reg_2.set_id(reg_1.id() + 1);
 921   EXPECT_TRUE(reg_1.Equals(reg_2));
 922 }
 923
 924 TEST_F(BackgroundSyncManagerTest, RegistrationEqualsTag) {
 925   BackgroundSyncRegistration reg_1;
 926   BackgroundSyncRegistration reg_2;
 927   EXPECT_TRUE(reg_1.Equals(reg_2));
 928   reg_2.options()->tag = "bar";
 929   EXPECT_FALSE(reg_1.Equals(reg_2));
 930 }
 931
 932 TEST_F(BackgroundSyncManagerTest, RegistrationEqualsPeriodicity) {
 933   BackgroundSyncRegistration reg_1;
 934   BackgroundSyncRegistration reg_2;
 935   EXPECT_TRUE(reg_1.Equals(reg_2));
 936   reg_1.options()->periodicity = SYNC_PERIODIC;
 937   reg_2.options()->periodicity = SYNC_ONE_SHOT;
 938   EXPECT_FALSE(reg_1.Equals(reg_2));
 939 }
 940
 941 TEST_F(BackgroundSyncManagerTest, RegistrationEqualsMinPeriod) {
 942   BackgroundSyncRegistration reg_1;
 943   BackgroundSyncRegistration reg_2;
 944   EXPECT_TRUE(reg_1.Equals(reg_2));
 945   reg_2.options()->min_period = reg_1.options()->min_period + 1;
 946   EXPECT_FALSE(reg_1.Equals(reg_2));
 947 }
 948
 949 TEST_F(BackgroundSyncManagerTest, RegistrationEqualsNetworkState) {
 950   BackgroundSyncRegistration reg_1;
 951   BackgroundSyncRegistration reg_2;
 952   EXPECT_TRUE(reg_1.Equals(reg_2));
 953   reg_1.options()->network_state = NETWORK_STATE_ANY;
 954   reg_2.options()->network_state = NETWORK_STATE_ONLINE;
 955   EXPECT_FALSE(reg_1.Equals(reg_2));
 956 }
 957
 958 TEST_F(BackgroundSyncManagerTest, RegistrationEqualsPowerState) {
 959   BackgroundSyncRegistration reg_1;
 960   BackgroundSyncRegistration reg_2;
 961   EXPECT_TRUE(reg_1.Equals(reg_2));
 962   reg_1.options()->power_state = POWER_STATE_AUTO;
 963   reg_2.options()->power_state = POWER_STATE_AVOID_DRAINING;
 964   EXPECT_FALSE(reg_1.Equals(reg_2));
 965 }
 966
 967 TEST_F(BackgroundSyncManagerTest, StoreAndRetrievePreservesValues) {
 968   BackgroundSyncRegistrationOptions options;
 969   // Set non-default values for each field.
 970   options.tag = "foo";
 971   EXPECT_NE(SYNC_PERIODIC, options.periodicity);
 972   options.periodicity = SYNC_PERIODIC;
 973   options.min_period += 1;
 974   EXPECT_NE(NETWORK_STATE_ANY, options.network_state);
 975   options.network_state = NETWORK_STATE_ANY;
 976   EXPECT_NE(POWER_STATE_AUTO, options.power_state);
 977   options.power_state = POWER_STATE_AUTO;
 978
 979   // Store the registration.
 980   EXPECT_TRUE(Register(options));
 981
 982   // Simulate restarting the sync manager, forcing the next read to come from
 983   // disk.
 984   SetupBackgroundSyncManager();
 985
 986   EXPECT_TRUE(GetRegistration(options));
 987   EXPECT_TRUE(options.Equals(*callback_registration_.options()));
 988 }
 989
 990 TEST_F(BackgroundSyncManagerTest, EmptyTagSupported) {
 991   sync_options_1_.tag = "a";
 992   EXPECT_TRUE(Register(sync_options_1_));
 993   EXPECT_TRUE(GetRegistration(sync_options_1_));
 994   EXPECT_TRUE(sync_options_1_.Equals(*callback_registration_.options()));
 995   EXPECT_TRUE(Unregister(callback_registration_));
 996   EXPECT_FALSE(GetRegistration(sync_options_1_));
 997 }
 998
 999 TEST_F(BackgroundSyncManagerTest, OverlappingPeriodicAndOneShotTags) {
1000   // Registrations with the same tags but different periodicities should not
1001   // collide.
1002   sync_options_1_.tag = "";
1003   sync_options_2_.tag = "";
1004   sync_options_1_.periodicity = SYNC_PERIODIC;
1005   sync_options_2_.periodicity = SYNC_ONE_SHOT;
1006
1007   EXPECT_TRUE(Register(sync_options_1_));
1008   EXPECT_TRUE(Register(sync_options_2_));
1009
1010   EXPECT_TRUE(GetRegistration(sync_options_1_));
1011   EXPECT_EQ(SYNC_PERIODIC, callback_registration_.options()->periodicity);
1012   EXPECT_TRUE(GetRegistration(sync_options_2_));
1013   EXPECT_EQ(SYNC_ONE_SHOT, callback_registration_.options()->periodicity);
1014
1015   EXPECT_TRUE(GetRegistration(sync_options_1_));
1016   EXPECT_TRUE(Unregister(callback_registration_));
1017   EXPECT_FALSE(GetRegistration(sync_options_1_));
1018   EXPECT_TRUE(GetRegistration(sync_options_2_));
1019   EXPECT_EQ(SYNC_ONE_SHOT, callback_registration_.options()->periodicity);
1020
1021   EXPECT_TRUE(Unregister(callback_registration_));
1022   EXPECT_FALSE(GetRegistration(sync_options_2_));
1023 }
1024
1025 TEST_F(BackgroundSyncManagerTest, OneShotFiresOnRegistration) {
1026   InitSyncEventTest();
1027
1028   EXPECT_TRUE(Register(sync_options_1_));
1029   EXPECT_EQ(1, sync_events_called_);
1030   EXPECT_FALSE(GetRegistration(sync_options_1_));
1031 }
1032
1033 // TODO(jkarlin): Change this to a periodic test as one-shots can't be power
1034 // dependent according to spec.
1035 TEST_F(BackgroundSyncManagerTest, OneShotFiresOnPowerChange) {
1036   InitSyncEventTest();
1037   sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
1038
1039   SetOnBatteryPower(true);
1040   EXPECT_TRUE(Register(sync_options_1_));
1041   EXPECT_EQ(0, sync_events_called_);
1042   EXPECT_TRUE(GetRegistration(sync_options_1_));
1043
1044   SetOnBatteryPower(false);
1045   EXPECT_EQ(1, sync_events_called_);
1046   EXPECT_FALSE(GetRegistration(sync_options_1_));
1047 }
1048
1049 // TODO(jkarlin): Change this to a periodic test as one-shots can't be power
1050 // dependent according to spec.
1051 TEST_F(BackgroundSyncManagerTest, MultipleOneShotsFireOnPowerChange) {
1052   InitSyncEventTest();
1053   sync_options_1_.power_state = POWER_STATE_AVOID_DRAINING;
1054   sync_options_2_.power_state = POWER_STATE_AVOID_DRAINING;
1055
1056   SetOnBatteryPower(true);
1057   EXPECT_TRUE(Register(sync_options_1_));
1058   EXPECT_TRUE(Register(sync_options_2_));
1059   EXPECT_EQ(0, sync_events_called_);
1060   EXPECT_TRUE(GetRegistration(sync_options_1_));
1061   EXPECT_TRUE(GetRegistration(sync_options_2_));
1062
1063   SetOnBatteryPower(false);
1064   EXPECT_EQ(2, sync_events_called_);
1065   EXPECT_FALSE(GetRegistration(sync_options_1_));
1066   EXPECT_FALSE(GetRegistration(sync_options_2_));
1067 }
1068
1069 TEST_F(BackgroundSyncManagerTest, OneShotFiresOnNetworkChange) {
1070   InitSyncEventTest();
1071
1072   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
1073   EXPECT_TRUE(Register(sync_options_1_));
1074   EXPECT_EQ(0, sync_events_called_);
1075   EXPECT_TRUE(GetRegistration(sync_options_1_));
1076
1077   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
1078   base::RunLoop().RunUntilIdle();
1079   EXPECT_EQ(1, sync_events_called_);
1080   EXPECT_FALSE(GetRegistration(sync_options_1_));
1081 }
1082
1083 TEST_F(BackgroundSyncManagerTest, MultipleOneShotsFireOnNetworkChange) {
1084   InitSyncEventTest();
1085
1086   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
1087   EXPECT_TRUE(Register(sync_options_1_));
1088   EXPECT_TRUE(Register(sync_options_2_));
1089   EXPECT_EQ(0, sync_events_called_);
1090   EXPECT_TRUE(GetRegistration(sync_options_1_));
1091   EXPECT_TRUE(GetRegistration(sync_options_2_));
1092
1093   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
1094
1095   EXPECT_EQ(2, sync_events_called_);
1096   EXPECT_FALSE(GetRegistration(sync_options_1_));
1097   EXPECT_FALSE(GetRegistration(sync_options_2_));
1098 }
1099
1100 TEST_F(BackgroundSyncManagerTest, OneShotFiresOnManagerRestart) {
1101   InitSyncEventTest();
1102
1103   // Initially the event won't run because there is no network.
1104   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
1105   EXPECT_TRUE(Register(sync_options_1_));
1106   EXPECT_EQ(0, sync_events_called_);
1107   EXPECT_TRUE(GetRegistration(sync_options_1_));
1108
1109   // Simulate closing the browser.
1110   DeleteBackgroundSyncManager();
1111
1112   // The next time the manager is started, the network is good.
1113   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
1114   SetupBackgroundSyncManager();
1115   InitSyncEventTest();
1116
1117   // The event should have fired.
1118   EXPECT_EQ(1, sync_events_called_);
1119   EXPECT_FALSE(GetRegistration(sync_options_1_));
1120 }
1121
1122 TEST_F(BackgroundSyncManagerTest, FailedOneShotStillExists) {
1123   InitFailedSyncEventTest();
1124
1125   EXPECT_TRUE(Register(sync_options_1_));
1126   EXPECT_EQ(1, sync_events_called_);
1127   EXPECT_TRUE(GetRegistration(sync_options_1_));
1128
1129   // The failed one-shot should stay registered but not fire until the
1130   // ServiceWorker is reloaded with an active client. Therefore, changing the
1131   // network should not cause the event to run again.
1132   SetNetwork(net::NetworkChangeNotifier::CONNECTION_2G);
1133   EXPECT_EQ(1, sync_events_called_);
1134   EXPECT_TRUE(GetRegistration(sync_options_1_));
1135 }
1136
1137 TEST_F(BackgroundSyncManagerTest, FailedOneShotReregisteredAndFires) {
1138   InitFailedSyncEventTest();
1139
1140   // The initial sync event fails.
1141   EXPECT_TRUE(Register(sync_options_1_));
1142   EXPECT_EQ(1, sync_events_called_);
1143   EXPECT_TRUE(GetRegistration(sync_options_1_));
1144   BackgroundSyncRegistration first_registration = callback_registration_;
1145
1146   InitSyncEventTest();
1147
1148   // Reregistering should cause the sync event to fire again, this time
1149   // succeeding.
1150   EXPECT_TRUE(Register(sync_options_1_));
1151   EXPECT_EQ(first_registration.id(), callback_registration_.id());
1152   EXPECT_EQ(2, sync_events_called_);
1153   EXPECT_FALSE(GetRegistration(sync_options_1_));
1154 }
1155
1156 TEST_F(BackgroundSyncManagerTest, DelayOneShotMidSync) {
1157   InitDelayedSyncEventTest();
1158
1159   RegisterAndVerifySyncEventDelayed(sync_options_1_);
1160
1161   // Finish firing the event and verify that the registration is removed.
1162   sync_fired_callback_.Run(SERVICE_WORKER_OK);
1163   base::RunLoop().RunUntilIdle();
1164   EXPECT_EQ(1, sync_events_called_);
1165   EXPECT_FALSE(GetRegistration(sync_options_1_));
1166 }
1167
1168 TEST_F(BackgroundSyncManagerTest, OverwriteRegistrationMidSync) {
1169   InitDelayedSyncEventTest();
1170
1171   sync_options_1_.network_state = NETWORK_STATE_ANY;
1172   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
1173
1174   RegisterAndVerifySyncEventDelayed(sync_options_1_);
1175
1176   // Don't delay the next sync.
1177   test_background_sync_manager_->set_one_shot_callback(
1178       base::Bind(OneShotSuccessfulCallback, &sync_events_called_));
1179
1180   // Register a different sync event with the same tag, overwriting the first.
1181   sync_options_1_.network_state = NETWORK_STATE_ONLINE;
1182   EXPECT_TRUE(Register(sync_options_1_));
1183
1184   // The new sync event won't run as the network requirements aren't met.
1185   EXPECT_EQ(1, sync_events_called_);
1186   EXPECT_TRUE(GetRegistration(sync_options_1_));
1187
1188   // Finish the first event, note that the second is still registered.
1189   sync_fired_callback_.Run(SERVICE_WORKER_OK);
1190   EXPECT_EQ(1, sync_events_called_);
1191   EXPECT_TRUE(GetRegistration(sync_options_1_));
1192
1193   // Change the network and the second should run.
1194   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
1195   base::RunLoop().RunUntilIdle();
1196   EXPECT_EQ(2, sync_events_called_);
1197   EXPECT_FALSE(GetRegistration(sync_options_1_));
1198 }
1199
1200 TEST_F(BackgroundSyncManagerTest, ReregisterOneShotMidSync) {
1201   InitDelayedSyncEventTest();
1202
1203   RegisterAndVerifySyncEventDelayed(sync_options_1_);
1204
1205   // Register the same sync, but don't delay it. It shouldn't run as it's
1206   // already firing.
1207   test_background_sync_manager_->set_one_shot_callback(
1208       base::Bind(OneShotSuccessfulCallback, &sync_events_called_));
1209   EXPECT_TRUE(Register(sync_options_1_));
1210   EXPECT_EQ(1, sync_events_called_);
1211   EXPECT_TRUE(GetRegistration(sync_options_1_));
1212
1213   // Finish the original event, note that the second never runs.
1214   sync_fired_callback_.Run(SERVICE_WORKER_OK);
1215   base::RunLoop().RunUntilIdle();
1216   EXPECT_EQ(1, sync_events_called_);
1217   EXPECT_FALSE(GetRegistration(sync_options_1_));
1218 }
1219
1220 TEST_F(BackgroundSyncManagerTest, UnregisterOneShotMidSync) {
1221   InitDelayedSyncEventTest();
1222
1223   RegisterAndVerifySyncEventDelayed(sync_options_1_);
1224
1225   EXPECT_TRUE(Unregister(callback_registration_));
1226   EXPECT_FALSE(GetRegistration(sync_options_1_));
1227
1228   sync_fired_callback_.Run(SERVICE_WORKER_OK);
1229   EXPECT_FALSE(GetRegistration(sync_options_1_));
1230 }
1231
1232 TEST_F(BackgroundSyncManagerTest, BadBackendMidSync) {
1233   InitDelayedSyncEventTest();
1234
1235   RegisterAndVerifySyncEventDelayed(sync_options_1_);
1236
1237   test_background_sync_manager_->set_corrupt_backend(true);
1238   sync_fired_callback_.Run(SERVICE_WORKER_OK);
1239   base::RunLoop().RunUntilIdle();
1240
1241   // The backend should now be disabled because it couldn't unregister the
1242   // one-shot.
1243   EXPECT_FALSE(Register(sync_options_2_));
1244   EXPECT_FALSE(
1245       RegisterWithServiceWorkerId(sw_registration_id_2_, sync_options_2_));
1246 }
1247
1248 TEST_F(BackgroundSyncManagerTest, UnregisterServiceWorkerMidSync) {
1249   InitDelayedSyncEventTest();
1250
1251   RegisterAndVerifySyncEventDelayed(sync_options_1_);
1252   UnregisterServiceWorker(sw_registration_id_1_);
1253
1254   sync_fired_callback_.Run(SERVICE_WORKER_OK);
1255
1256   // The backend isn't disabled, but the first service worker registration is
1257   // gone.
1258   EXPECT_FALSE(GetRegistration(sync_options_1_));
1259   EXPECT_FALSE(Register(sync_options_1_));
1260   EXPECT_TRUE(
1261       RegisterWithServiceWorkerId(sw_registration_id_2_, sync_options_1_));
1262 }
1263
1264 TEST_F(BackgroundSyncManagerTest, KillManagerMidSync) {
1265   InitDelayedSyncEventTest();
1266
1267   RegisterAndVerifySyncEventDelayed(sync_options_1_);
1268
1269   // Create a new manager which should fire the sync again on init.
1270   SetupBackgroundSyncManager();
1271   InitSyncEventTest();
1272   EXPECT_FALSE(GetRegistration(sync_options_1_));
1273   EXPECT_EQ(2, sync_events_called_);
1274 }
1275
1276 TEST_F(BackgroundSyncManagerTest, RegisterFailsWithoutWindow) {
1277   RemoveWindowClients();
1278   EXPECT_FALSE(Register(sync_options_1_));
1279 }
1280
1281 TEST_F(BackgroundSyncManagerTest, RegisterExistingFailsWithoutWindow) {
1282   EXPECT_TRUE(Register(sync_options_1_));
1283   RemoveWindowClients();
1284   EXPECT_FALSE(Register(sync_options_1_));
1285 }
1286
1287 TEST_F(BackgroundSyncManagerTest, RegisterSucceedsFromUncontrolledWindow) {
1288   RemoveWindowClients();
1289   EXPECT_TRUE(RegisterFromDocumentWithServiceWorkerId(sw_registration_id_1_,
1290                                                       sync_options_1_));
1291 }
1292
1293 TEST_F(BackgroundSyncManagerTest, UnregisterSucceedsWithoutWindow) {
1294   EXPECT_TRUE(Register(sync_options_1_));
1295   RemoveWindowClients();
1296   EXPECT_TRUE(Unregister(callback_registration_));
1297   EXPECT_FALSE(GetRegistration(sync_options_1_));
1298 }
1299
1300 }  // namespace content