[BackgroundSyncManager] Rename BackgroundSyncRegistration.name to tag

content/browser/background_sync/background_sync_manager.h

 // 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.
 
 #ifndef CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_
 #define CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_
 
 #include <list>
 #include <map>
 
@@ skipping 37 matching lines @@
   };
 
   // TODO(jkarlin): Remove this and use the struct from IPC messages once it
   // lands.
   struct CONTENT_EXPORT BackgroundSyncRegistration {
     using RegistrationId = int64;
     static const RegistrationId kInvalidRegistrationId;
     BackgroundSyncRegistration() {}
 
     bool Equals(const BackgroundSyncRegistration& other) {
-      return this->name == other.name && this->fire_once == other.fire_once &&
+      return this->tag == other.tag && this->fire_once == other.fire_once &&
              this->min_period == other.min_period &&
              network_state == other.network_state &&
              power_state == other.power_state;
     }
 
     RegistrationId id = kInvalidRegistrationId;
-    std::string name;
+    std::string tag;
     bool fire_once = true;
     int64 min_period = 0;
     SyncNetworkState network_state = NETWORK_STATE_ONLINE;
     SyncPowerState power_state = POWER_STATE_AVOID_DRAINING;
   };
 
   struct CONTENT_EXPORT BackgroundSyncRegistrations {
-    using NameToRegistrationMap =
+    using TagToRegistrationMap =
         std::map<std::string, BackgroundSyncRegistration>;
     static const BackgroundSyncRegistration::RegistrationId kInitialId;
 
     BackgroundSyncRegistrations();
     explicit BackgroundSyncRegistrations(
         BackgroundSyncRegistration::RegistrationId next_id);
     ~BackgroundSyncRegistrations();
 
-    NameToRegistrationMap name_to_registration_map;
+    TagToRegistrationMap tag_to_registration_map;
     BackgroundSyncRegistration::RegistrationId next_id;
   };
 
   using StatusCallback = base::Callback<void(ErrorType)>;
   using StatusAndRegistrationCallback =
       base::Callback<void(ErrorType, const BackgroundSyncRegistration&)>;
 
   static scoped_ptr<BackgroundSyncManager> Create(
       const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context);
   ~BackgroundSyncManager() override;
 
   // Stores the given background sync registration and adds it to the scheduling
-  // queue. Overwrites any existing registration with the same name but
+  // queue. Overwrites any existing registration with the same tag but
   // different parameters (other than the id). Calls |callback| with ErrorTypeOK
   // and the accepted registration on success. The accepted registration will
   // have a unique id. It may also have altered parameters if the user or UA
   // chose different parameters than those supplied.
   void Register(const GURL& origin,
                 int64 sw_registration_id,
                 const BackgroundSyncRegistration& sync_registration,
                 const StatusAndRegistrationCallback& callback);
 
-  // Removes the background sync registration with |sync_registration_name| if
+  // Removes the background sync registration with |sync_registration_tag| if
   // the |sync_registration_id| matches. |sync_registration_id| will not match
-  // if, for instance, a new registration with the same name has replaced it.
+  // if, for instance, a new registration with the same tag has replaced it.
   // Calls |callback| with ErrorTypeNotFound if no match is found. Calls
   // |callback| with ErrorTypeOK on success.
   void Unregister(
       const GURL& origin,
       int64 sw_registration_id,
-      const std::string& sync_registration_name,
+      const std::string& sync_registration_tag,
       BackgroundSyncRegistration::RegistrationId sync_registration_id,
       const StatusCallback& callback);
 
   // Finds the background sync registration associated with
   // |sw_registration_id|. Calls |callback| with ErrorTypeNotFound if it doesn't
   // exist. Calls |callback| with ErrorTypeOK on success.
   void GetRegistration(const GURL& origin,
                        int64 sw_registration_id,
-                       const std::string sync_registration_name,
+                       const std::string sync_registration_tag,
                        const StatusAndRegistrationCallback& callback);
 
   // ServiceWorkerContextObserver overrides.
   void OnRegistrationDeleted(int64 registration_id,
                              const GURL& pattern) override;
   void OnStorageWiped() override;
 
  protected:
   explicit BackgroundSyncManager(
       const scoped_refptr<ServiceWorkerContextWrapper>& context);
@@ skipping 26 matching lines @@
   void DisableAndClearDidGetRegistrations(
       const base::Closure& callback,
       const std::vector<std::pair<int64, std::string>>& user_data,
       ServiceWorkerStatusCode status);
   void DisableAndClearManagerClearedOne(const base::Closure& barrier_closure,
                                         ServiceWorkerStatusCode status);
 
   // Returns the existing registration in |existing_registration| if it is not
   // null.
   bool LookupRegistration(int64 sw_registration_id,
-                          const std::string& sync_registration_name,
+                          const std::string& sync_registration_tag,
                           BackgroundSyncRegistration* existing_registration);
 
   // Store all registrations for a given |sw_registration_id|.
   void StoreRegistrations(const GURL& origin,
                           int64 sw_registration_id,
                           const ServiceWorkerStorage::StatusCallback& callback);
 
   // Removes the registration if it is in the map.
   void RemoveRegistrationFromMap(int64 sw_registration_id,
-                                 const std::string& sync_registration_name);
+                                 const std::string& sync_registration_tag);
 
   void AddRegistrationToMap(
       int64 sw_registration_id,
       const BackgroundSyncRegistration& sync_registration);
 
   void InitImpl(const base::Closure& callback);
   void InitDidGetDataFromBackend(
       const base::Closure& callback,
       const std::vector<std::pair<int64, std::string>>& user_data,
       ServiceWorkerStatusCode status);
 
   // Register callbacks
   void RegisterImpl(const GURL& origin,
                     int64 sw_registration_id,
                     const BackgroundSyncRegistration& sync_registration,
                     const StatusAndRegistrationCallback& callback);
   void RegisterDidStore(int64 sw_registration_id,
                         const BackgroundSyncRegistration& sync_registration,
                         const StatusAndRegistrationCallback& callback,
                         ServiceWorkerStatusCode status);
 
   // Unregister callbacks
   void UnregisterImpl(
       const GURL& origin,
       int64 sw_registration_id,
-      const std::string& sync_registration_name,
+      const std::string& sync_registration_tag,
       BackgroundSyncRegistration::RegistrationId sync_registration_id,
       const StatusCallback& callback);
   void UnregisterDidStore(
       int64 sw_registration_id,
       const StatusCallback& callback,
       ServiceWorkerStatusCode status);
 
   // GetRegistration callbacks
   void GetRegistrationImpl(const GURL& origin,
                            int64 sw_registration_id,
-                           const std::string sync_registration_name,
+                           const std::string sync_registration_tag,
                            const StatusAndRegistrationCallback& callback);
 
   // OnRegistrationDeleted callbacks
   void OnRegistrationDeletedImpl(int64 registration_id,
                                  const base::Closure& callback);
 
   // OnStorageWiped callbacks
   void OnStorageWipedImpl(const base::Closure& callback);
 
   // Operation Scheduling callbacks
@@ skipping 16 matching lines @@
   bool disabled_;
 
   base::WeakPtrFactory<BackgroundSyncManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_