[BackgroundSyncManager] Remove origin argument from public BackgroundSyncManager methods

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 27 matching lines @@
 // TODO(jkarlin): Create a background sync scheduler to actually run the
 // registered events.
 // TODO(jkarlin): Keep the browser alive if "Let Google Chrome Run in the
 // Background" is true and a sync is registered.
 class CONTENT_EXPORT BackgroundSyncManager
     : NON_EXPORTED_BASE(public ServiceWorkerContextObserver) {
  public:
   enum ErrorType {
     ERROR_TYPE_OK = 0,
     ERROR_TYPE_STORAGE,
-    ERROR_TYPE_NOT_FOUND
+    ERROR_TYPE_NOT_FOUND,
+    ERROR_TYPE_NO_SERVICE_WORKER
   };
 
   // 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;
     static const RegistrationId kInitialId;
     BackgroundSyncRegistration() {}
 
@@ skipping 19 matching lines @@
   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 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,
+  void Register(int64 sw_registration_id,
                 const BackgroundSyncRegistration& sync_registration,
                 const StatusAndRegistrationCallback& callback);
 
   // Removes the background sync with tag |sync_registration_tag|, periodicity
   // |periodicity|, and id |sync_registration_id|. 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_tag,
       SyncPeriodicity periodicity,
       BackgroundSyncRegistration::RegistrationId sync_registration_id,
       const StatusCallback& callback);
 
   // Finds the background sync registration associated with
   // |sw_registration_id| with periodicity |periodicity|. Calls
   // |callback| with ErrorTypeNotFound if it doesn't exist. Calls |callback|
   // with ErrorTypeOK on success.
-  void GetRegistration(const GURL& origin,
-                       int64 sw_registration_id,
+  void GetRegistration(int64 sw_registration_id,
                        const std::string sync_registration_tag,
                        SyncPeriodicity periodicity,
                        const StatusAndRegistrationCallback& callback);
 
   // ServiceWorkerContextObserver overrides.
   void OnRegistrationDeleted(int64 registration_id,
                              const GURL& pattern) override;
   void OnStorageWiped() override;
 
  protected:
@@ skipping 78 matching lines @@
       const GURL& origin,
       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,
+  void RegisterImpl(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 RegistrationKey& registration_key,
       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,
+  void GetRegistrationImpl(int64 sw_registration_id,
                            const RegistrationKey& registration_key,
                            const StatusAndRegistrationCallback& callback);
 
   // OnRegistrationDeleted callbacks
   void OnRegistrationDeletedImpl(int64 registration_id,
                                  const base::Closure& callback);
 
   // OnStorageWiped callbacks
   void OnStorageWipedImpl(const base::Closure& callback);
 
@@ skipping 21 matching lines @@
   scoped_ptr<BackgroundSyncNetworkObserver> network_observer_;
 
   base::WeakPtrFactory<BackgroundSyncManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundSyncManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BACKGROUND_SYNC_BACKGROUND_SYNC_MANAGER_H_