[BackgroundSyncManager] Remove origin argument from public BackgroundSyncManager methods

content/browser/background_sync/background_sync_manager.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/barrier_closure.h"
 #include "base/bind.h"
 #include "content/browser/background_sync/background_sync_network_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
@@ skipping 44 matching lines @@
     : RegistrationKey(registration.tag, registration.periodicity) {
 }
 
 BackgroundSyncManager::RegistrationKey::RegistrationKey(
     const std::string& tag,
     SyncPeriodicity periodicity)
     : value_(periodicity == SYNC_ONE_SHOT ? "o_" + tag : "p_" + tag) {
 }
 
 void BackgroundSyncManager::Register(
-    const GURL& origin,
     int64 sw_registration_id,
     const BackgroundSyncRegistration& sync_registration,
     const StatusAndRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(BackgroundSyncRegistration::kInvalidRegistrationId,
             sync_registration.id);
 
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   op_scheduler_.ScheduleOperation(base::Bind(
       &BackgroundSyncManager::RegisterImpl, weak_ptr_factory_.GetWeakPtr(),
-      origin, sw_registration_id, sync_registration,
+      sw_registration_id, sync_registration,
       MakeStatusAndRegistrationCompletion(callback)));
 }
 
 void BackgroundSyncManager::Unregister(
-    const GURL& origin,
     int64 sw_registration_id,
     const std::string& sync_registration_tag,
     SyncPeriodicity periodicity,
     BackgroundSyncRegistration::RegistrationId sync_registration_id,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_STORAGE));
     return;
   }
 
   RegistrationKey registration_key(sync_registration_tag, periodicity);
 
   op_scheduler_.ScheduleOperation(base::Bind(
       &BackgroundSyncManager::UnregisterImpl, weak_ptr_factory_.GetWeakPtr(),
-      origin, sw_registration_id, registration_key, sync_registration_id,
+      sw_registration_id, registration_key, sync_registration_id,
       MakeStatusCompletion(callback)));
 }
 
 void BackgroundSyncManager::GetRegistration(
-    const GURL& origin,
     int64 sw_registration_id,
     const std::string sync_registration_tag,
     SyncPeriodicity periodicity,
     const StatusAndRegistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   RegistrationKey registration_key(sync_registration_tag, periodicity);
 
   op_scheduler_.ScheduleOperation(base::Bind(
       &BackgroundSyncManager::GetRegistrationImpl,
-      weak_ptr_factory_.GetWeakPtr(), origin, sw_registration_id,
-      registration_key, MakeStatusAndRegistrationCompletion(callback)));
+      weak_ptr_factory_.GetWeakPtr(), sw_registration_id, registration_key,
+      MakeStatusAndRegistrationCompletion(callback)));
 }
 
 void BackgroundSyncManager::OnRegistrationDeleted(int64 registration_id,
                                                   const GURL& pattern) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Operations already in the queue will either fail when they write to storage
   // or return stale results based on registrations loaded in memory. This is
   // inconsequential since the service worker is gone.
   op_scheduler_.ScheduleOperation(base::Bind(
@@ skipping 101 matching lines @@
     DisableAndClearManager(base::Bind(callback));
     return;
   }
 
   // TODO(jkarlin): Call the scheduling algorithm here.
 
   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
 }
 
 void BackgroundSyncManager::RegisterImpl(
-    const GURL& origin,
     int64 sw_registration_id,
     const BackgroundSyncRegistration& sync_registration,
     const StatusAndRegistrationCallback& callback) {
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
   const BackgroundSyncRegistration* existing_registration = LookupRegistration(
       sw_registration_id, RegistrationKey(sync_registration));
   if (existing_registration &&
       existing_registration->Equals(sync_registration)) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_OK, *existing_registration));
     return;
   }
 
   BackgroundSyncRegistration new_registration = sync_registration;
   BackgroundSyncRegistrations* registrations =
       &sw_to_registrations_map_[sw_registration_id];
   new_registration.id = registrations->next_id++;
 
-  AddRegistrationToMap(sw_registration_id, origin, new_registration);
+  ServiceWorkerRegistration* sw_registration =
+      service_worker_context_->GetLiveRegistration(sw_registration_id);
+  if (!sw_registration || !sw_registration->active_version()) {
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE, base::Bind(callback, ERROR_TYPE_NO_SERVICE_WORKER,
+                              BackgroundSyncRegistration()));
+    return;
+  }
+
+  AddRegistrationToMap(sw_registration_id,
+                       sw_registration->pattern().GetOrigin(),

[jsbell, 2015/04/28 20:52:33]

It seems to me we should probably have ServiceWorkerRegistration expose origin
directly rather than requiring to extract it from the pattern in case we support
multiple patterns, but that should be a different CL.

+                       new_registration);
 
   StoreRegistrations(
       sw_registration_id,
       base::Bind(&BackgroundSyncManager::RegisterDidStore,
                  weak_ptr_factory_.GetWeakPtr(), sw_registration_id,
                  new_registration, callback));
 }
 
 void BackgroundSyncManager::DisableAndClearManager(
     const base::Closure& callback) {
@@ skipping 160 matching lines @@
     const std::string& backend_key,
     const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
         callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->GetUserDataForAllRegistrations(backend_key,
                                                           callback);
 }
 
 void BackgroundSyncManager::UnregisterImpl(
-    const GURL& origin,
     int64 sw_registration_id,
     const RegistrationKey& registration_key,
     BackgroundSyncRegistration::RegistrationId sync_registration_id,
     const StatusCallback& callback) {
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, ERROR_TYPE_STORAGE));
     return;
   }
 
@@ skipping 31 matching lines @@
     DisableAndClearManager(base::Bind(callback, ERROR_TYPE_STORAGE));
     return;
   }
 
   // TODO(jkarlin): Run the registration algorithm.
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::Bind(callback, ERROR_TYPE_OK));
 }
 
 void BackgroundSyncManager::GetRegistrationImpl(
-    const GURL& origin,
     int64 sw_registration_id,
     const RegistrationKey& registration_key,
     const StatusAndRegistrationCallback& callback) {
   if (disabled_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, ERROR_TYPE_STORAGE, BackgroundSyncRegistration()));
     return;
   }
 
@@ skipping 73 matching lines @@
       weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 BackgroundSyncManager::StatusCallback
 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) {
   return base::Bind(&BackgroundSyncManager::PendingStatusCallback,
                     weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace content