[BackgroundSyncManager] Rename BackgroundSyncRegistration.name to tag

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/run_loop.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 123 matching lines @@
 };
 
 class BackgroundSyncManagerTest : public testing::Test {
  public:
   BackgroundSyncManagerTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         sync_reg_1_(BackgroundSyncManager::BackgroundSyncRegistration()),
         sync_reg_2_(BackgroundSyncManager::BackgroundSyncRegistration()),
         callback_error_(BackgroundSyncManager::ERROR_TYPE_OK),
         callback_sw_status_code_(SERVICE_WORKER_OK) {
-    sync_reg_1_.name = "foo";
-    sync_reg_2_.name = "bar";
+    sync_reg_1_.tag = "foo";
+    sync_reg_2_.tag = "bar";
   }
 
   void SetUp() override {
     helper_.reset(
         new EmbeddedWorkerTestHelper(base::FilePath(), kRenderProcessId));
 
     background_sync_manager_ =
         BackgroundSyncManager::Create(helper_->context_wrapper());
 
     // Wait for storage to finish initializing before registering service
@@ skipping 65 matching lines @@
     return UnregisterWithServiceWorkerId(sw_registration_id_1_,
                                          sync_registration);
   }
 
   bool UnregisterWithServiceWorkerId(
       int64 sw_registration_id,
       const BackgroundSyncManager::BackgroundSyncRegistration&
           sync_registration) {
     bool was_called = false;
     background_sync_manager_->Unregister(
-        GURL(kOrigin), sw_registration_id, sync_registration.name,
+        GURL(kOrigin), sw_registration_id, sync_registration.tag,
         sync_registration.id,
         base::Bind(&BackgroundSyncManagerTest::StatusCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
     return callback_error_ == BackgroundSyncManager::ERROR_TYPE_OK;
   }
 
-  bool GetRegistration(const std::string& sync_registration_name) {
+  bool GetRegistration(const std::string& sync_registration_tag) {
     return GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
-                                              sync_registration_name);
+                                              sync_registration_tag);
   }
 
   bool GetRegistrationWithServiceWorkerId(
       int64 sw_registration_id,
-      const std::string& sync_registration_name) {
+      const std::string& sync_registration_tag) {
     bool was_called = false;
     background_sync_manager_->GetRegistration(
-        GURL(kOrigin), sw_registration_id, sync_registration_name,
+        GURL(kOrigin), sw_registration_id, sync_registration_tag,
         base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                    base::Unretained(this), &was_called));
     base::RunLoop().RunUntilIdle();
     EXPECT_TRUE(was_called);
 
     if (callback_error_ == BackgroundSyncManager::ERROR_TYPE_OK)
-      EXPECT_TRUE(sync_registration_name == callback_registration_.name);
+      EXPECT_TRUE(sync_registration_tag == callback_registration_.tag);
 
     return callback_error_ == BackgroundSyncManager::ERROR_TYPE_OK;
   }
 
   void StorageRegistrationCallback(ServiceWorkerStatusCode result) {
     callback_sw_status_code_ = result;
   }
 
   void UnregisterServiceWorker(uint64 sw_registration_id) {
     bool called = false;
@@ skipping 25 matching lines @@
   BackgroundSyncManager::BackgroundSyncRegistration callback_registration_;
   ServiceWorkerStatusCode callback_sw_status_code_;
 };
 
 TEST_F(BackgroundSyncManagerTest, Register) {
   EXPECT_TRUE(Register(sync_reg_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistractionIntact) {
   EXPECT_TRUE(Register(sync_reg_1_));
-  EXPECT_STREQ(sync_reg_1_.name.c_str(), callback_registration_.name.c_str());
+  EXPECT_STREQ(sync_reg_1_.tag.c_str(), callback_registration_.tag.c_str());
   EXPECT_NE(
       BackgroundSyncManager::BackgroundSyncRegistration::kInvalidRegistrationId,
       callback_registration_.id);
 }
 
 TEST_F(BackgroundSyncManagerTest, RegisterExistingKeepsId) {
   EXPECT_TRUE(Register(sync_reg_1_));
   BackgroundSyncManager::BackgroundSyncRegistration first_registration =
       callback_registration_;
   EXPECT_TRUE(Register(sync_reg_1_));
@@ skipping 11 matching lines @@
   EXPECT_LT(first_registration.id, callback_registration_.id);
   EXPECT_FALSE(callback_registration_.Equals(first_registration));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegisterBadBackend) {
   TestBackgroundSyncManager* manager = UseTestBackgroundSyncManager();
   manager->set_corrupt_backend(true);
   EXPECT_FALSE(Register(sync_reg_1_));
   manager->set_corrupt_backend(false);
   EXPECT_FALSE(Register(sync_reg_1_));
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, TwoRegistrations) {
   EXPECT_TRUE(Register(sync_reg_1_));
   EXPECT_TRUE(Register(sync_reg_2_));
 }
 
 TEST_F(BackgroundSyncManagerTest, GetRegistrationNonExisting) {
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, GetRegistrationExisting) {
   EXPECT_TRUE(Register(sync_reg_1_));
-  EXPECT_TRUE(GetRegistration(sync_reg_1_.name));
-  EXPECT_FALSE(GetRegistration(sync_reg_2_.name));
+  EXPECT_TRUE(GetRegistration(sync_reg_1_.tag));
+  EXPECT_FALSE(GetRegistration(sync_reg_2_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, GetRegistrationBadBackend) {
   TestBackgroundSyncManager* manager = UseTestBackgroundSyncManager();
   EXPECT_TRUE(Register(sync_reg_1_));
   manager->set_corrupt_backend(true);
-  EXPECT_TRUE(GetRegistration(sync_reg_1_.name));
+  EXPECT_TRUE(GetRegistration(sync_reg_1_.tag));
   EXPECT_FALSE(Register(sync_reg_2_));
   // Registration should have discovered the bad backend and disabled the
   // BackgroundSyncManager.
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
   manager->set_corrupt_backend(false);
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, Unregister) {
   EXPECT_TRUE(Register(sync_reg_1_));
   EXPECT_TRUE(Unregister(callback_registration_));
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, UnregisterWrongId) {
   EXPECT_TRUE(Register(sync_reg_1_));
   callback_registration_.id += 1;
   EXPECT_FALSE(Unregister(callback_registration_));
 }
 
 TEST_F(BackgroundSyncManagerTest, Reregister) {
   EXPECT_TRUE(Register(sync_reg_1_));
   EXPECT_TRUE(Unregister(callback_registration_));
   EXPECT_TRUE(Register(sync_reg_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, UnregisterNonExisting) {
   EXPECT_FALSE(Unregister(sync_reg_1_));
   EXPECT_EQ(BackgroundSyncManager::ERROR_TYPE_NOT_FOUND, callback_error_);
 }
 
 TEST_F(BackgroundSyncManagerTest, UnregisterSecond) {
   EXPECT_TRUE(Register(sync_reg_1_));
   EXPECT_TRUE(Register(sync_reg_2_));
   EXPECT_TRUE(Unregister(callback_registration_));
-  EXPECT_TRUE(GetRegistration(sync_reg_1_.name));
+  EXPECT_TRUE(GetRegistration(sync_reg_1_.tag));
   EXPECT_TRUE(Register(sync_reg_2_));
 }
 
 TEST_F(BackgroundSyncManagerTest, UnregisterBadBackend) {
   TestBackgroundSyncManager* manager = UseTestBackgroundSyncManager();
   sync_reg_1_.min_period += 1;
   EXPECT_TRUE(Register(sync_reg_1_));
   EXPECT_TRUE(Register(sync_reg_2_));
   manager->set_corrupt_backend(true);
   EXPECT_FALSE(Unregister(callback_registration_));
   // Unregister should have discovered the bad backend and disabled the
   // BackgroundSyncManager.
   manager->set_corrupt_backend(false);
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
-  EXPECT_FALSE(GetRegistration(sync_reg_2_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
+  EXPECT_FALSE(GetRegistration(sync_reg_2_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistrationIncreasesId) {
   EXPECT_TRUE(Register(sync_reg_1_));
   BackgroundSyncManager::BackgroundSyncRegistration registered_sync =
       callback_registration_;
   BackgroundSyncManager::BackgroundSyncRegistration::RegistrationId cur_id =
       callback_registration_.id;
 
-  EXPECT_TRUE(GetRegistration(sync_reg_1_.name));
+  EXPECT_TRUE(GetRegistration(sync_reg_1_.tag));
   EXPECT_TRUE(Register(sync_reg_2_));
   EXPECT_LT(cur_id, callback_registration_.id);
   cur_id = callback_registration_.id;
 
   EXPECT_TRUE(Unregister(registered_sync));
   EXPECT_TRUE(Register(sync_reg_1_));
   EXPECT_LT(cur_id, callback_registration_.id);
 }
 
 TEST_F(BackgroundSyncManagerTest, RebootRecovery) {
   EXPECT_TRUE(Register(sync_reg_1_));
 
   background_sync_manager_ =
       BackgroundSyncManager::Create(helper_->context_wrapper());
 
-  EXPECT_TRUE(GetRegistration(sync_reg_1_.name));
-  EXPECT_FALSE(GetRegistration(sync_reg_2_.name));
+  EXPECT_TRUE(GetRegistration(sync_reg_1_.tag));
+  EXPECT_FALSE(GetRegistration(sync_reg_2_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, RebootRecoveryTwoServiceWorkers) {
   EXPECT_TRUE(RegisterWithServiceWorkerId(sw_registration_id_1_, sync_reg_1_));
   EXPECT_TRUE(RegisterWithServiceWorkerId(sw_registration_id_2_, sync_reg_2_));
 
   background_sync_manager_ =
       BackgroundSyncManager::Create(helper_->context_wrapper());
 
   EXPECT_TRUE(GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
-                                                 sync_reg_1_.name));
+                                                 sync_reg_1_.tag));
   EXPECT_FALSE(GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
-                                                  sync_reg_2_.name));
+                                                  sync_reg_2_.tag));
   EXPECT_FALSE(GetRegistrationWithServiceWorkerId(sw_registration_id_2_,
-                                                  sync_reg_1_.name));
+                                                  sync_reg_1_.tag));
   EXPECT_TRUE(GetRegistrationWithServiceWorkerId(sw_registration_id_2_,
-                                                 sync_reg_2_.name));
+                                                 sync_reg_2_.tag));
 
   EXPECT_TRUE(GetRegistrationWithServiceWorkerId(sw_registration_id_1_,
-                                                 sync_reg_1_.name));
+                                                 sync_reg_1_.tag));
   EXPECT_TRUE(GetRegistrationWithServiceWorkerId(sw_registration_id_2_,
-                                                 sync_reg_2_.name));
+                                                 sync_reg_2_.tag));
 
   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 =
       new TestBackgroundSyncManager(helper_->context_wrapper());
   background_sync_manager_.reset(manager);
   manager->set_corrupt_backend(true);
   manager->DoInit();
 
   EXPECT_FALSE(Register(sync_reg_1_));
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, SequentialOperations) {
   // Schedule Init and all of the operations on a delayed backend. Verify that
   // the operations complete sequentially.
   TestBackgroundSyncManager* manager =
       new TestBackgroundSyncManager(helper_->context_wrapper());
   background_sync_manager_.reset(manager);
   manager->set_delay_backend(true);
   manager->DoInit();
 
   const int64 kExpectedInitialId =
       BackgroundSyncManager::BackgroundSyncRegistrations::kInitialId;
 
   bool register_called = false;
   bool unregister_called = false;
   bool get_registration_called = false;
   manager->Register(
       GURL(kOrigin), sw_registration_id_1_, sync_reg_1_,
       base::Bind(&BackgroundSyncManagerTest::StatusAndRegistrationCallback,
                  base::Unretained(this), &register_called));
-  manager->Unregister(GURL(kOrigin), sw_registration_id_1_, sync_reg_1_.name,
+  manager->Unregister(GURL(kOrigin), sw_registration_id_1_, sync_reg_1_.tag,
                       kExpectedInitialId,
                       base::Bind(&BackgroundSyncManagerTest::StatusCallback,
                                  base::Unretained(this), &unregister_called));
   manager->GetRegistration(
-      GURL(kOrigin), sw_registration_id_1_, sync_reg_1_.name,
+      GURL(kOrigin), sw_registration_id_1_, sync_reg_1_.tag,
       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();
@@ skipping 17 matching lines @@
   // 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_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest,
        UnregisterServiceWorkerDuringSyncRegistration) {
   TestBackgroundSyncManager* manager =
       new TestBackgroundSyncManager(helper_->context_wrapper());
   background_sync_manager_.reset(manager);
   manager->DoInit();
 
   EXPECT_TRUE(Register(sync_reg_1_));
 
   manager->set_delay_backend(true);
   bool callback_called = false;
   manager->Register(
       GURL(kOrigin), 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();
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(callback_called);
   EXPECT_EQ(BackgroundSyncManager::ERROR_TYPE_STORAGE, callback_error_);
 
   manager->set_delay_backend(false);
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, DeleteAndStartOverServiceWorkerContext) {
   EXPECT_TRUE(Register(sync_reg_1_));
   helper_->context()->ScheduleDeleteAndStartOver();
   base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, DisabledManagerWorksAfterBrowserRestart) {
   TestBackgroundSyncManager* manager =
       new TestBackgroundSyncManager(helper_->context_wrapper());
   background_sync_manager_.reset(manager);
   manager->DoInit();
   EXPECT_TRUE(Register(sync_reg_1_));
   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);
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
   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_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
   EXPECT_TRUE(Register(sync_reg_1_));
 }
 
 TEST_F(BackgroundSyncManagerTest, DisabledManagerWorksAfterDeleteAndStartOver) {
   TestBackgroundSyncManager* manager =
       new TestBackgroundSyncManager(helper_->context_wrapper());
   background_sync_manager_.reset(manager);
   manager->DoInit();
   EXPECT_TRUE(Register(sync_reg_1_));
   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);
   helper_->context()->ScheduleDeleteAndStartOver();
   base::RunLoop().RunUntilIdle();
 
   bool called = false;
   helper_->context()->RegisterServiceWorker(
       GURL(kPattern1), GURL(kScript1), NULL,
       base::Bind(&RegisterServiceWorkerCallback, &called,
                  &sw_registration_id_1_));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(called);
 
   EXPECT_TRUE(Register(sync_reg_2_));
-  EXPECT_FALSE(GetRegistration(sync_reg_1_.name));
-  EXPECT_TRUE(GetRegistration(sync_reg_2_.name));
+  EXPECT_FALSE(GetRegistration(sync_reg_1_.tag));
+  EXPECT_TRUE(GetRegistration(sync_reg_2_.tag));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistrationEqualsId) {
   BackgroundSyncManager::BackgroundSyncRegistration reg_1;
   BackgroundSyncManager::BackgroundSyncRegistration reg_2;
 
   EXPECT_TRUE(reg_1.Equals(reg_2));
   reg_2.id = reg_1.id + 1;
   EXPECT_TRUE(reg_1.Equals(reg_2));
 }
 
-TEST_F(BackgroundSyncManagerTest, RegistrationEqualsName) {
+TEST_F(BackgroundSyncManagerTest, RegistrationEqualsTag) {
   BackgroundSyncManager::BackgroundSyncRegistration reg_1;
   BackgroundSyncManager::BackgroundSyncRegistration reg_2;
   EXPECT_TRUE(reg_1.Equals(reg_2));
-  reg_2.name = "bar";
+  reg_2.tag = "bar";
   EXPECT_FALSE(reg_1.Equals(reg_2));
 }
 
 TEST_F(BackgroundSyncManagerTest, RegistrationEqualsFireOnce) {
   BackgroundSyncManager::BackgroundSyncRegistration reg_1;
   BackgroundSyncManager::BackgroundSyncRegistration reg_2;
   EXPECT_TRUE(reg_1.Equals(reg_2));
   reg_2.fire_once = !reg_1.fire_once;
   EXPECT_FALSE(reg_1.Equals(reg_2));
 }
@@ skipping 20 matching lines @@
   BackgroundSyncManager::BackgroundSyncRegistration reg_2;
   EXPECT_TRUE(reg_1.Equals(reg_2));
   reg_1.power_state = POWER_STATE_AUTO;
   reg_2.power_state = POWER_STATE_AVOID_DRAINING;
   EXPECT_FALSE(reg_1.Equals(reg_2));
 }
 
 TEST_F(BackgroundSyncManagerTest, StoreAndRetrievePreservesValues) {
   BackgroundSyncManager::BackgroundSyncRegistration reg_1;
   // Set non-default values for each field.
-  reg_1.name = "foo";
+  reg_1.tag = "foo";
   reg_1.fire_once = !reg_1.fire_once;
   reg_1.min_period += 1;
   EXPECT_NE(NETWORK_STATE_ANY, reg_1.network_state);
   reg_1.network_state = NETWORK_STATE_ANY;
   EXPECT_NE(POWER_STATE_AUTO, reg_1.power_state);
   reg_1.power_state = POWER_STATE_AUTO;
 
   // Store the registration.
   EXPECT_TRUE(Register(reg_1));
 
   // Simulate restarting the sync manager, forcing the next read to come from
   // disk.
   UseTestBackgroundSyncManager();
 
-  EXPECT_TRUE(GetRegistration(reg_1.name));
+  EXPECT_TRUE(GetRegistration(reg_1.tag));
   EXPECT_TRUE(reg_1.Equals(callback_registration_));
 }
 
 }  // namespace content