[BackgroundSync] Remove RegistrationKey

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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 110 matching lines @@
       const ServiceWorkerVersion::StatusCallback& callback);
   virtual void ScheduleDelayedTask(const base::Closure& callback,
                                    base::TimeDelta delay);
   virtual void HasMainFrameProviderHost(const GURL& origin,
                                         const BoolCallback& callback);
 
  private:
   friend class TestBackgroundSyncManager;
   friend class BackgroundSyncManagerTest;
 
-  class RegistrationKey {
-   public:
-    explicit RegistrationKey(const BackgroundSyncRegistration& registration);
-    explicit RegistrationKey(const BackgroundSyncRegistrationOptions& options);
-    RegistrationKey(const std::string& tag);
-    RegistrationKey(const RegistrationKey& other) = default;
-    RegistrationKey& operator=(const RegistrationKey& other) = default;
-
-    bool operator<(const RegistrationKey& rhs) const {
-      return value_ < rhs.value_;
-    }
-
-   private:
-    std::string value_;
-  };
-
   struct BackgroundSyncRegistrations {
-    using RegistrationMap =
-        std::map<RegistrationKey, BackgroundSyncRegistration>;
+    using RegistrationMap = std::map<std::string, BackgroundSyncRegistration>;
 
     BackgroundSyncRegistrations();
     BackgroundSyncRegistrations(const BackgroundSyncRegistrations& other);
     ~BackgroundSyncRegistrations();
 
     RegistrationMap registration_map;
     BackgroundSyncRegistration::RegistrationId next_id;
     GURL origin;
   };
 
@@ skipping 11 matching lines @@
   void DisableAndClearDidGetRegistrations(
       const base::Closure& callback,
       const std::vector<std::pair<int64_t, std::string>>& user_data,
       ServiceWorkerStatusCode status);
   void DisableAndClearManagerClearedOne(const base::Closure& barrier_closure,
                                         ServiceWorkerStatusCode status);
 
   // Returns the existing registration or nullptr if it cannot be found.
   BackgroundSyncRegistration* LookupActiveRegistration(
       int64_t sw_registration_id,
-      const RegistrationKey& registration_key);
+      const std::string& tag);
 
   // Write all registrations for a given |sw_registration_id| to persistent
   // storage.
   void StoreRegistrations(int64_t sw_registration_id,
                           const ServiceWorkerStorage::StatusCallback& callback);
 
   // Removes the active registration if it is in the map.
   void RemoveActiveRegistration(int64_t sw_registration_id,
-                                const RegistrationKey& registration_key);
+                                const std::string& tag);
 
   void AddActiveRegistration(
       int64_t sw_registration_id,
       const GURL& origin,
       const BackgroundSyncRegistration& sync_registration);
 
   void InitImpl(const base::Closure& callback);
   void InitDidGetControllerParameters(
       const base::Closure& callback,
       scoped_ptr<BackgroundSyncParameters> parameters);
@@ skipping 35 matching lines @@
   // Assumes that all registrations in the pending state are not currently ready
   // to fire. Therefore this should not be called directly and should only be
   // called by FireReadyEvents.
   void RunInBackgroundIfNecessary();
 
   // FireReadyEvents scans the list of available events and fires those that are
   // ready to fire. For those that can't yet be fired, wakeup alarms are set.
   void FireReadyEvents();
   void FireReadyEventsImpl(const base::Closure& callback);
   void FireReadyEventsDidFindRegistration(
-      const RegistrationKey& registration_key,
+      const std::string& tag,
       BackgroundSyncRegistration::RegistrationId registration_id,
       const base::Closure& event_fired_callback,
       const base::Closure& event_completed_callback,
       ServiceWorkerStatusCode service_worker_status,
       const scoped_refptr<ServiceWorkerRegistration>&
           service_worker_registration);
   void FireReadyEventsAllEventsFiring(const base::Closure& callback);
 
   // Called when a sync event has completed.
   void EventComplete(const scoped_refptr<ServiceWorkerRegistration>&
                          service_worker_registration,
                      int64_t service_worker_id,
-                     const RegistrationKey& registration_key,
+                     const std::string& tag,
                      const base::Closure& callback,
                      ServiceWorkerStatusCode status_code);
   void EventCompleteImpl(int64_t service_worker_id,
-                         const RegistrationKey& registration_key,
+                         const std::string& tag,
                          ServiceWorkerStatusCode status_code,
                          const base::Closure& callback);
   void EventCompleteDidStore(int64_t service_worker_id,
                              const base::Closure& callback,
                              ServiceWorkerStatusCode status_code);
 
   // Called when all sync events have completed.
   static void OnAllSyncEventsCompleted(const base::TimeTicks& start_time,
                                        int number_of_batched_sync_events);
 
@@ skipping 50 matching lines @@
   scoped_ptr<base::Clock> clock_;
 
   base::WeakPtrFactory<BackgroundSyncManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_