ServiceWorker: Stop exposing ServiceWorkerContextCore

content/browser/push_messaging/push_messaging_message_filter.cc

 // Copyright 2014 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/push_messaging/push_messaging_message_filter.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 207 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(mvanouwerkerk): Validate arguments?
   // TODO(peter): Persist |user_visible| in Service Worker storage.
   RegisterData data;
   data.request_id = request_id;
   data.service_worker_registration_id = service_worker_registration_id;
   data.render_frame_id = render_frame_id;
   data.user_visible = user_visible;
 
   ServiceWorkerRegistration* service_worker_registration =
-      service_worker_context_->context()->GetLiveRegistration(
+      service_worker_context_->GetLiveRegistration(
           service_worker_registration_id);
   if (!service_worker_registration ||
       !service_worker_registration->active_version()) {
     SendRegisterError(data, PUSH_REGISTRATION_STATUS_NO_SERVICE_WORKER);
     return;
   }
   data.requesting_origin = service_worker_registration->pattern().GetOrigin();
 
-  service_worker_context_->context()->storage()->StoreUserData(
+  service_worker_context_->StoreRegistrationUserData(
       service_worker_registration_id,
       data.requesting_origin,
       kPushSenderIdServiceWorkerKey,
       sender_id,
       base::Bind(&PushMessagingMessageFilter::DidPersistSenderId,
                  weak_factory_io_to_io_.GetWeakPtr(),
                  data, sender_id));
 }
 
 void PushMessagingMessageFilter::OnRegisterFromWorker(
     int request_id,
     int64_t service_worker_registration_id,
     bool user_visible) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   RegisterData data;
   data.request_id = request_id;
   data.service_worker_registration_id = service_worker_registration_id;
   data.user_visible = user_visible;
 
   ServiceWorkerRegistration* service_worker_registration =
-      service_worker_context_->context()->GetLiveRegistration(
+      service_worker_context_->GetLiveRegistration(
           service_worker_registration_id);
   if (!service_worker_registration) {
     SendRegisterError(data, PUSH_REGISTRATION_STATUS_NO_SERVICE_WORKER);
     return;
   }
   data.requesting_origin = service_worker_registration->pattern().GetOrigin();
 
   // This sender_id will be ignored; instead it will be fetched from storage.
   CheckForExistingRegistration(data, std::string() /* sender_id */);
 }
 
 void PushMessagingMessageFilter::DidPersistSenderId(
     const RegisterData& data,
     const std::string& sender_id,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (service_worker_status != SERVICE_WORKER_OK)
     SendRegisterError(data, PUSH_REGISTRATION_STATUS_STORAGE_ERROR);
   else
     CheckForExistingRegistration(data, sender_id);
 }
 
 void PushMessagingMessageFilter::CheckForExistingRegistration(
     const RegisterData& data,
     const std::string& sender_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  service_worker_context_->context()->storage()->GetUserData(
+  service_worker_context_->GetRegistrationUserData(
       data.service_worker_registration_id,
       kPushRegistrationIdServiceWorkerKey,
       base::Bind(&PushMessagingMessageFilter::DidCheckForExistingRegistration,
                  weak_factory_io_to_io_.GetWeakPtr(), data, sender_id));
 }
 
 void PushMessagingMessageFilter::DidCheckForExistingRegistration(
     const RegisterData& data,
     const std::string& sender_id,
     const std::string& push_registration_id,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (service_worker_status == SERVICE_WORKER_OK) {
     SendRegisterSuccess(data, PUSH_REGISTRATION_STATUS_SUCCESS_FROM_CACHE,
                         push_registration_id);
     return;
   }
   // TODO(johnme): The spec allows the register algorithm to reject with an
   // AbortError when accessing storage fails. Perhaps we should do that if
   // service_worker_status != SERVICE_WORKER_ERROR_NOT_FOUND instead of
   // attempting to do a fresh registration?
   // https://w3c.github.io/push-api/#widl-PushRegistrationManager-register-Promise-PushRegistration
   if (data.FromDocument()) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&Core::RegisterOnUI, base::Unretained(ui_core_.get()),
                    data, sender_id));
   } else {
-    service_worker_context_->context()->storage()->GetUserData(
+    service_worker_context_->GetRegistrationUserData(
         data.service_worker_registration_id,
         kPushSenderIdServiceWorkerKey,
         base::Bind(&PushMessagingMessageFilter::DidGetSenderIdFromStorage,
                    weak_factory_io_to_io_.GetWeakPtr(), data));
   }
 }
 
 void PushMessagingMessageFilter::DidGetSenderIdFromStorage(
     const RegisterData& data,
     const std::string& sender_id,
@@ skipping 71 matching lines @@
         BrowserThread::IO, FROM_HERE,
         base::Bind(&PushMessagingMessageFilter::SendRegisterError, io_parent_,
                    data, status));
   }
 }
 
 void PushMessagingMessageFilter::PersistRegistrationOnIO(
     const RegisterData& data,
     const std::string& push_registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  service_worker_context_->context()->storage()->StoreUserData(
+  service_worker_context_->StoreRegistrationUserData(
       data.service_worker_registration_id,
       data.requesting_origin,
       kPushRegistrationIdServiceWorkerKey,
       push_registration_id,
       base::Bind(&PushMessagingMessageFilter::DidPersistRegistrationOnIO,
                  weak_factory_io_to_io_.GetWeakPtr(),
                  data, push_registration_id));
 }
 
 void PushMessagingMessageFilter::DidPersistRegistrationOnIO(
@@ skipping 50 matching lines @@
 }
 
 // Unregister methods on both IO and UI threads, merged in order of use from
 // PushMessagingMessageFilter and Core.
 // -----------------------------------------------------------------------------
 
 void PushMessagingMessageFilter::OnUnregister(
     int request_id, int64_t service_worker_registration_id) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ServiceWorkerRegistration* service_worker_registration =
-      service_worker_context_->context()->GetLiveRegistration(
+      service_worker_context_->GetLiveRegistration(
           service_worker_registration_id);
   if (!service_worker_registration) {
     DidUnregister(request_id, PUSH_UNREGISTRATION_STATUS_NO_SERVICE_WORKER);
     return;
   }
 
-  service_worker_context_->context()->storage()->GetUserData(
+  service_worker_context_->GetRegistrationUserData(
       service_worker_registration_id,
       kPushRegistrationIdServiceWorkerKey,
       base::Bind(
           &PushMessagingMessageFilter::UnregisterHavingGottenPushRegistrationId,
           weak_factory_io_to_io_.GetWeakPtr(), request_id,
           service_worker_registration_id,
           service_worker_registration->pattern().GetOrigin()));
 }
 
 void PushMessagingMessageFilter::UnregisterHavingGottenPushRegistrationId(
     int request_id,
     int64_t service_worker_registration_id,
     const GURL& requesting_origin,
     const std::string& push_registration_id,  // Unused, we just want the status
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (service_worker_status == SERVICE_WORKER_OK) {
-    service_worker_context_->context()->storage()->GetUserData(
+    service_worker_context_->GetRegistrationUserData(
         service_worker_registration_id,
         kPushSenderIdServiceWorkerKey,
         base::Bind(
             &PushMessagingMessageFilter::UnregisterHavingGottenSenderId,
             weak_factory_io_to_io_.GetWeakPtr(),
             request_id,
             service_worker_registration_id,
             requesting_origin));
   } else {
     // Errors are handled the same, whether we were trying to get the
@@ skipping 104 matching lines @@
       break;
   }
 }
 
 void PushMessagingMessageFilter::ClearRegistrationData(
     int request_id,
     int64_t service_worker_registration_id,
     PushUnregistrationStatus unregistration_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  service_worker_context_->context()->storage()->ClearUserData(
+  service_worker_context_->ClearRegistrationUserData(
       service_worker_registration_id,
       kPushRegistrationIdServiceWorkerKey,
       base::Bind(&PushMessagingMessageFilter::DidClearRegistrationData,
                  weak_factory_io_to_io_.GetWeakPtr(),
                  request_id, unregistration_status));
 }
 
 void PushMessagingMessageFilter::DidClearRegistrationData(
     int request_id,
     PushUnregistrationStatus unregistration_status,
@@ skipping 40 matching lines @@
 
 // GetRegistration methods on both IO and UI threads, merged in order of use
 // from PushMessagingMessageFilter and Core.
 // -----------------------------------------------------------------------------
 
 void PushMessagingMessageFilter::OnGetRegistration(
     int request_id,
     int64_t service_worker_registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(johnme): Validate arguments?
-  service_worker_context_->context()->storage()->GetUserData(
+  service_worker_context_->GetRegistrationUserData(
       service_worker_registration_id,
       kPushRegistrationIdServiceWorkerKey,
       base::Bind(&PushMessagingMessageFilter::DidGetRegistration,
                  weak_factory_io_to_io_.GetWeakPtr(), request_id));
 }
 
 void PushMessagingMessageFilter::DidGetRegistration(
     int request_id,
     const std::string& push_registration_id,
     ServiceWorkerStatusCode service_worker_status) {
@@ skipping 47 matching lines @@
 // GetPermission methods on both IO and UI threads, merged in order of use from
 // PushMessagingMessageFilter and Core.
 // -----------------------------------------------------------------------------
 
 void PushMessagingMessageFilter::OnGetPermissionStatus(
     int request_id,
     int64_t service_worker_registration_id,
     bool user_visible) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ServiceWorkerRegistration* service_worker_registration =
-      service_worker_context_->context()->GetLiveRegistration(
+      service_worker_context_->GetLiveRegistration(
           service_worker_registration_id);
   if (!service_worker_registration) {
     Send(new PushMessagingMsg_GetPermissionStatusError(request_id));
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&Core::GetPermissionStatusOnUI,
                  base::Unretained(ui_core_.get()),
@@ skipping 40 matching lines @@
 PushMessagingService* PushMessagingMessageFilter::Core::service() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RenderProcessHost* process_host =
       RenderProcessHost::FromID(render_process_id_);
   return process_host
          ? process_host->GetBrowserContext()->GetPushMessagingService()
          : nullptr;
 }
 
 }  // namespace content