[BackgroundSync] Clean up some tests

content/browser/background_sync/background_sync_manager_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/background_sync/background_sync_manager.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/power_monitor/power_monitor_source.h"
@@ skipping 297 matching lines @@
   }
 
  protected:
   void UseTestBackgroundSyncManager() {
     test_background_sync_manager_ =
         new TestBackgroundSyncManager(helper_->context_wrapper());
     test_background_sync_manager_->DoInit();
     background_sync_manager_.reset(test_background_sync_manager_);
   }
 
+  void DeleteBackgroundSyncManager() {
+    background_sync_manager_.reset();
+    test_background_sync_manager_ = nullptr;
+  }
+
   bool Register(const BackgroundSyncManager::BackgroundSyncRegistration&
                     sync_registration) {
     return RegisterWithServiceWorkerId(sw_registration_id_1_,
                                        sync_registration);
   }
 
   bool RegisterWithServiceWorkerId(
       int64 sw_registration_id,
       const BackgroundSyncManager::BackgroundSyncRegistration&
           sync_registration) {
@@ skipping 394 matching lines @@
   EXPECT_TRUE(
       GetRegistrationWithServiceWorkerId(sw_registration_id_1_, sync_reg_1_));
   EXPECT_TRUE(
       GetRegistrationWithServiceWorkerId(sw_registration_id_2_, sync_reg_2_));
 
   EXPECT_TRUE(RegisterWithServiceWorkerId(sw_registration_id_1_, sync_reg_2_));
   EXPECT_TRUE(RegisterWithServiceWorkerId(sw_registration_id_2_, sync_reg_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, InitWithBadBackend) {
-  TestBackgroundSyncManager* manager =
+  DeleteBackgroundSyncManager();
+  test_background_sync_manager_ =
       new TestBackgroundSyncManager(helper_->context_wrapper());
-  background_sync_manager_.reset(manager);
-  manager->set_corrupt_backend(true);
-  manager->DoInit();
+  background_sync_manager_.reset(test_background_sync_manager_);
+  test_background_sync_manager_->set_corrupt_backend(true);
+  test_background_sync_manager_->DoInit();
 
   EXPECT_FALSE(Register(sync_reg_1_));
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, SequentialOperations) {
   // Schedule Init and all of the operations on a delayed backend. Verify that
   // the operations complete sequentially.
-  TestBackgroundSyncManager* manager =
+  DeleteBackgroundSyncManager();
+
+  test_background_sync_manager_ =
       new TestBackgroundSyncManager(helper_->context_wrapper());
-  background_sync_manager_.reset(manager);
-  manager->set_delay_backend(true);
-  manager->DoInit();
+  background_sync_manager_.reset(test_background_sync_manager_);
+
+  test_background_sync_manager_->set_delay_backend(true);
+  test_background_sync_manager_->DoInit();
 
   const int64 kExpectedInitialId =
       BackgroundSyncManager::BackgroundSyncRegistration::kInitialId;
 
   bool register_called = false;
   bool unregister_called = false;
   bool get_registration_called = false;
-  manager->Register(
+  test_background_sync_manager_->Register(
       sw_registration_id_1_, sync_reg_1_,
       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                  base::Unretained(this), &register_called));
-  manager->Unregister(sw_registration_id_1_, sync_reg_1_.tag,
-                      sync_reg_1_.periodicity, kExpectedInitialId,
-                      base::Bind(&BackgroundSyncManagerTest::StatusCallback,
-                                 base::Unretained(this), &unregister_called));
-  manager->GetRegistration(
+  test_background_sync_manager_->Unregister(
+      sw_registration_id_1_, sync_reg_1_.tag, sync_reg_1_.periodicity,
+      kExpectedInitialId,
+      base::Bind(&BackgroundSyncManagerTest::StatusCallback,
+                 base::Unretained(this), &unregister_called));
+  test_background_sync_manager_->GetRegistration(
       sw_registration_id_1_, sync_reg_1_.tag, sync_reg_1_.periodicity,
       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                  base::Unretained(this), &get_registration_called));
 
   base::RunLoop().RunUntilIdle();
   // Init should be blocked while loading from the backend.
   EXPECT_FALSE(register_called);
   EXPECT_FALSE(unregister_called);
   EXPECT_FALSE(get_registration_called);
 
-  manager->Continue();
+  test_background_sync_manager_->Continue();
   base::RunLoop().RunUntilIdle();
   // Register should be blocked while storing to the backend.
   EXPECT_FALSE(register_called);
   EXPECT_FALSE(unregister_called);
   EXPECT_FALSE(get_registration_called);
 
-  manager->Continue();
+  test_background_sync_manager_->Continue();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(register_called);
   EXPECT_EQ(kExpectedInitialId, callback_registration_.id);
   EXPECT_EQ(BackgroundSyncManager::ERROR_TYPE_OK, callback_error_);
   // Unregister should be blocked while storing to the backend.
   EXPECT_FALSE(unregister_called);
   EXPECT_FALSE(get_registration_called);
 
-  manager->Continue();
+  test_background_sync_manager_->Continue();
   base::RunLoop().RunUntilIdle();
   // Unregister should be done and since GetRegistration doesn't require the
   // backend it should be done too.
   EXPECT_EQ(BackgroundSyncManager::ERROR_TYPE_NOT_FOUND, callback_error_);
   EXPECT_TRUE(unregister_called);
   EXPECT_TRUE(get_registration_called);
 }
 
 TEST_F(BackgroundSyncManagerTest, UnregisterServiceWorker) {
   EXPECT_TRUE(Register(sync_reg_1_));
   UnregisterServiceWorker(sw_registration_id_1_);
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest,
        UnregisterServiceWorkerDuringSyncRegistration) {
-  TestBackgroundSyncManager* manager =
-      new TestBackgroundSyncManager(helper_->context_wrapper());
-  background_sync_manager_.reset(manager);
-  manager->DoInit();
+  UseTestBackgroundSyncManager();
 
   EXPECT_TRUE(Register(sync_reg_1_));
 
-  manager->set_delay_backend(true);
+  test_background_sync_manager_->set_delay_backend(true);
   bool callback_called = false;
-  manager->Register(
+  test_background_sync_manager_->Register(
       sw_registration_id_1_, sync_reg_2_,
       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                  base::Unretained(this), &callback_called));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_called);
   UnregisterServiceWorker(sw_registration_id_1_);
 
-  manager->Continue();
+  test_background_sync_manager_->Continue();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback_called);
   EXPECT_EQ(BackgroundSyncManager::ERROR_TYPE_STORAGE, callback_error_);
 
-  manager->set_delay_backend(false);
+  test_background_sync_manager_->set_delay_backend(false);
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, DeleteAndStartOverServiceWorkerContext) {
   EXPECT_TRUE(Register(sync_reg_1_));
   helper_->context()->ScheduleDeleteAndStartOver();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, DisabledManagerWorksAfterBrowserRestart) {
-  TestBackgroundSyncManager* manager =
-      new TestBackgroundSyncManager(helper_->context_wrapper());
-  background_sync_manager_.reset(manager);
-  manager->DoInit();
+  UseTestBackgroundSyncManager();
   EXPECT_TRUE(Register(sync_reg_1_));
-  manager->set_corrupt_backend(true);
+  test_background_sync_manager_->set_corrupt_backend(true);
   EXPECT_FALSE(Register(sync_reg_2_));
 
   // The manager is now disabled and not accepting new requests until browser
   // restart or notification that the storage has been wiped.
-  manager->set_corrupt_backend(false);
+  test_background_sync_manager_->set_corrupt_backend(false);
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
   EXPECT_FALSE(Register(sync_reg_2_));
 
   // Simulate restarting the browser by creating a new BackgroundSyncManager.
-  background_sync_manager_.reset(
-      new TestBackgroundSyncManager(helper_->context_wrapper()));
-  EXPECT_FALSE(GetRegistration(sync_reg_1_));
-  EXPECT_TRUE(Register(sync_reg_1_));
+  UseTestBackgroundSyncManager();
+  EXPECT_TRUE(GetRegistration(sync_reg_1_));
+  EXPECT_TRUE(Register(sync_reg_2_));
 }
 
 TEST_F(BackgroundSyncManagerTest, DisabledManagerWorksAfterDeleteAndStartOver) {
-  TestBackgroundSyncManager* manager =
-      new TestBackgroundSyncManager(helper_->context_wrapper());
-  background_sync_manager_.reset(manager);
-  manager->DoInit();
+  UseTestBackgroundSyncManager();
   EXPECT_TRUE(Register(sync_reg_1_));
-  manager->set_corrupt_backend(true);
+  test_background_sync_manager_->set_corrupt_backend(true);
   EXPECT_FALSE(Register(sync_reg_2_));
 
   // The manager is now disabled and not accepting new requests until browser
   // restart or notification that the storage has been wiped.
-  manager->set_corrupt_backend(false);
+  test_background_sync_manager_->set_corrupt_backend(false);
   helper_->context()->ScheduleDeleteAndStartOver();
   base::RunLoop().RunUntilIdle();
 
   RegisterServiceWorkers();
 
   EXPECT_TRUE(Register(sync_reg_2_));
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
   EXPECT_TRUE(GetRegistration(sync_reg_2_));
 }
 
@@ skipping 169 matching lines @@
   InitSyncEventTest();
 
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
   EXPECT_TRUE(Register(sync_reg_1_));
   EXPECT_TRUE(Register(sync_reg_2_));
   EXPECT_EQ(0, sync_events_called_);
   EXPECT_TRUE(GetRegistration(sync_reg_1_));
   EXPECT_TRUE(GetRegistration(sync_reg_2_));
 
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
-  base::RunLoop().RunUntilIdle();
+
   EXPECT_EQ(2, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
   EXPECT_FALSE(GetRegistration(sync_reg_2_));
 }
 
 TEST_F(BackgroundSyncManagerTest, OneShotFiresOnManagerRestart) {
   InitSyncEventTest();
 
   // Initially the event won't run because there is no network.
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_NONE);
   EXPECT_TRUE(Register(sync_reg_1_));
   EXPECT_EQ(0, sync_events_called_);
   EXPECT_TRUE(GetRegistration(sync_reg_1_));
 
   // Simulate closing the browser.
-  background_sync_manager_.reset();
+  DeleteBackgroundSyncManager();
 
   // The next time the manager is started, the network is good.
   SetNetwork(net::NetworkChangeNotifier::CONNECTION_WIFI);
   InitSyncEventTest();
 
   // The event should have fired.
   EXPECT_EQ(1, sync_events_called_);
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
 }
 
@@ skipping 123 matching lines @@
 
   RegisterAndVerifySyncEventDelayed(sync_reg_1_);
 
   // Create a new manager which should fire the sync again on init.
   InitSyncEventTest();
   EXPECT_FALSE(GetRegistration(sync_reg_1_));
   EXPECT_EQ(2, sync_events_called_);
 }
 
 }  // namespace content