[BackgroundSync Cleanup] Remove periodic sync code

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 46 matching lines @@
       base::Callback<void(BackgroundSyncStatus, BackgroundSyncState)>;
   using StatusAndRegistrationsCallback = base::Callback<void(
       BackgroundSyncStatus,
       scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>)>;
 
   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. It will overwrite an existing registration with the same tag and
-  // periodicity unless they're identical (save for the id). Calls |callback|
-  // with BACKGROUND_SYNC_STATUS_OK and the accepted registration on success.
+  // queue. It will overwrite an existing registration with the same tag unless
+  // they're identical (save for the id). Calls |callback| with
+  // BACKGROUND_SYNC_STATUS_OK 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(int64_t sw_registration_id,
                 const BackgroundSyncRegistrationOptions& options,
                 bool requested_from_service_worker,
                 const StatusAndRegistrationCallback& callback);
 
   // Finds the background sync registration associated with
-  // |sw_registration_id|, periodicity |periodicity|, and tag
-  // |sync_registration_tag|. Calls |callback| with
-  // BACKGROUND_SYNC_STATUS_NOT_FOUND if it doesn't exist. Calls |callback| with
-  // BACKGROUND_SYNC_STATUS_OK on success. If the callback's status
-  // is not BACKGROUND_SYNC_STATUS_OK then the callback's RegistrationHandle
-  // will be nullptr.
+  // |sw_registration_id|, and tag |sync_registration_tag|. Calls |callback|
+  // with BACKGROUND_SYNC_STATUS_NOT_FOUND if it doesn't exist. Calls |callback|
+  // with BACKGROUND_SYNC_STATUS_OK on success. If the callback's status is not
+  // BACKGROUND_SYNC_STATUS_OK then the callback's RegistrationHandle will be
+  // nullptr.
   void GetRegistration(int64_t sw_registration_id,
                        const std::string& sync_registration_tag,
-                       SyncPeriodicity periodicity,
                        const StatusAndRegistrationCallback& callback);
 
   // Finds the background sync registrations associated with
-  // |sw_registration_id| and periodicity |periodicity|. Calls
-  // |callback| with BACKGROUND_SYNC_STATUS_OK on success.
+  // |sw_registration_id|. Calls |callback| with BACKGROUND_SYNC_STATUS_OK on
+  // success.
   void GetRegistrations(int64_t sw_registration_id,
-                        SyncPeriodicity periodicity,
                         const StatusAndRegistrationsCallback& callback);
 
   // Given a HandleId |handle_id|, return a new handle for the same
   // registration.
   scoped_ptr<BackgroundSyncRegistrationHandle> DuplicateRegistrationHandle(
       BackgroundSyncRegistrationHandle::HandleId handle_id);
 
   // ServiceWorkerContextObserver overrides.
   void OnRegistrationDeleted(int64_t sw_registration_id,
                              const GURL& pattern) override;
@@ skipping 50 matching lines @@
 
  private:
   friend class TestBackgroundSyncManager;
   friend class BackgroundSyncManagerTest;
   friend class BackgroundSyncRegistrationHandle;
 
   class RegistrationKey {
    public:
     explicit RegistrationKey(const BackgroundSyncRegistration& registration);
     explicit RegistrationKey(const BackgroundSyncRegistrationOptions& options);
-    RegistrationKey(const std::string& tag, SyncPeriodicity periodicity);
+    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_;
   };
@@ skipping 83 matching lines @@
       bool has_main_frame_client);
   void RegisterImpl(int64_t sw_registration_id,
                     const BackgroundSyncRegistrationOptions& options,
                     const StatusAndRegistrationCallback& callback);
   void RegisterDidStore(
       int64_t sw_registration_id,
       const scoped_refptr<RefCountedRegistration>& new_registration_ref,
       const StatusAndRegistrationCallback& callback,
       ServiceWorkerStatusCode status);
 
-  // Removes the background sync with periodicity |periodicity| and id
-  // |sync_registration_id|. Calls |callback| with
-  // BACKGROUND_SYNC_STATUS_NOT_FOUND if no match is found. Calls |callback|
-  // with BACKGROUND_SYNC_STATUS_OK on success.
+  // Removes the background sync with id |sync_registration_id|. Calls
+  // |callback| with BACKGROUND_SYNC_STATUS_NOT_FOUND if no match is found.
+  // Calls |callback| with BACKGROUND_SYNC_STATUS_OK on success.
   void Unregister(int64_t sw_registration_id,
                   BackgroundSyncRegistrationHandle::HandleId handle_id,
                   const StatusCallback& callback);
   void UnregisterImpl(
       int64_t sw_registration_id,
       const RegistrationKey& key,
       BackgroundSyncRegistration::RegistrationId sync_registration_id,
-      SyncPeriodicity periodicity,
       const StatusCallback& callback);
   void UnregisterDidStore(int64_t sw_registration_id,
-                          SyncPeriodicity periodicity,
                           const StatusCallback& callback,
                           ServiceWorkerStatusCode status);
 
   // NotifyWhenFinished and its callbacks. See
   // BackgroundSyncRegistrationHandle::NotifyWhenFinished for detailed
   // documentation.
   void NotifyWhenFinished(BackgroundSyncRegistrationHandle::HandleId handle_id,
                           const StatusAndStateCallback& callback);
   void NotifyWhenFinishedImpl(
       scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle,
       const StatusAndStateCallback& callback);
   void NotifyWhenFinishedInvokeCallback(const StatusAndStateCallback& callback,
                                         BackgroundSyncState status);
 
   // GetRegistration callbacks
   void GetRegistrationImpl(int64_t sw_registration_id,
                            const RegistrationKey& registration_key,
                            const StatusAndRegistrationCallback& callback);
 
   // GetRegistrations callbacks
   void GetRegistrationsImpl(int64_t sw_registration_id,
-                            SyncPeriodicity periodicity,
                             const StatusAndRegistrationsCallback& callback);
 
   bool AreOptionConditionsMet(const BackgroundSyncRegistrationOptions& options);
   bool IsRegistrationReadyToFire(
       const BackgroundSyncRegistration& registration);
 
   // Determines if the browser needs to be able to run in the background (e.g.,
   // to run a pending registration or verify that a firing registration
   // completed). If background processing is required it calls out to the
   // BackgroundSyncController to enable it.
@@ skipping 95 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_