ServiceWorker: Stop exposing ServiceWorkerContextCore

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/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_storage.h"
@@ skipping 290 matching lines @@
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK || user_data.empty()) {
     base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback));
     return;
   }
 
   base::Closure barrier_closure =
       base::BarrierClosure(user_data.size(), base::Bind(callback));
 
   for (const auto& sw_id_and_regs : user_data) {
-    service_worker_context_->context()->storage()->ClearUserData(
+    service_worker_context_->ClearRegistrationUserData(
         sw_id_and_regs.first, kBackgroundSyncUserDataKey,
         base::Bind(&BackgroundSyncManager::DisableAndClearManagerClearedOne,
                    weak_ptr_factory_.GetWeakPtr(), barrier_closure));
   }
 }
 
 void BackgroundSyncManager::DisableAndClearManagerClearedOne(
     const base::Closure& barrier_closure,
     ServiceWorkerStatusCode status) {
   // The status doesn't matter at this point, there is nothing else to be done.
@@ skipping 102 matching lines @@
   RegistrationKey registration_key(sync_registration);
   registrations->registration_map[registration_key] = sync_registration;
 }
 
 void BackgroundSyncManager::StoreDataInBackend(
     int64 sw_registration_id,
     const GURL& origin,
     const std::string& backend_key,
     const std::string& data,
     const ServiceWorkerStorage::StatusCallback& callback) {
-  service_worker_context_->context()->storage()->StoreUserData(
+  service_worker_context_->StoreRegistrationUserData(
       sw_registration_id, origin, backend_key, data, callback);
 }
 
 void BackgroundSyncManager::GetDataFromBackend(
     const std::string& backend_key,
     const ServiceWorkerStorage::GetUserDataForAllRegistrationsCallback&
         callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  service_worker_context_->context()->storage()->GetUserDataForAllRegistrations(
-      backend_key, callback);
+  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(
@@ skipping 124 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