service worker: Persist NavigationPreloadState

content/browser/service_worker/service_worker_dispatcher_host.cc

 // Copyright 2013 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/service_worker/service_worker_dispatcher_host.h"
 
 #include <utility>
 
 #include "base/debug/crash_logging.h"
 #include "base/logging.h"
@@ skipping 40 matching lines @@
     "The Service Worker system has shutdown.";
 const char kUserDeniedPermissionMessage[] =
     "The user denied permission to use Service Worker.";
 const char kInvalidStateErrorMessage[] = "The object is in an invalid state.";
 const char kEnableNavigationPreloadErrorPrefix[] =
     "Failed to enable or disable navigation preload: ";
 const char kGetNavigationPreloadStateErrorPrefix[] =
     "Failed to get navigation preload state: ";
 const char kSetNavigationPreloadHeaderErrorPrefix[] =
     "Failed to set navigation preload header: ";
+const char kNoActiveWorkerErrorMessage[] =
+    "The registration does not have an active worker.";
+const char kDatabaseErrorMessage[] = "Failed to access storage.";
 
 const uint32_t kFilteredMessageClasses[] = {
     ServiceWorkerMsgStart, EmbeddedWorkerMsgStart,
 };
 
 void RunSoon(const base::Closure& callback) {
   if (!callback.is_null())
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
 }
 
@@ skipping 629 matching lines @@
 
   ServiceWorkerRegistration* registration =
       GetContext()->GetLiveRegistration(registration_id);
   if (!registration) {
     // |registration| must be alive because a renderer retains a registration
     // reference at this point.
     bad_message::ReceivedBadMessage(
         this, bad_message::SWDH_ENABLE_NAVIGATION_PRELOAD_BAD_REGISTRATION_ID);
     return;
   }
+  // The spec discussion consensus is to reject if there is no active worker:
+  // https://github.com/w3c/ServiceWorker/issues/920#issuecomment-262212670
+  // TODO(falken): Remove this comment when the spec is updated.
+  if (!registration->active_version()) {
+    Send(new ServiceWorkerMsg_EnableNavigationPreloadError(
+        thread_id, request_id, WebServiceWorkerError::ErrorTypeState,
+        std::string(kEnableNavigationPreloadErrorPrefix) +
+            std::string(kNoActiveWorkerErrorMessage)));
+    return;
+  }
 
   std::vector<GURL> urls = {provider_host->document_url(),
                             registration->pattern()};
   if (!ServiceWorkerUtils::AllOriginsMatchAndCanAccessServiceWorkers(urls)) {
     bad_message::ReceivedBadMessage(
         this, bad_message::SWDH_ENABLE_NAVIGATION_PRELOAD_INVALID_ORIGIN);
     return;
   }
 
   if (!GetContentClient()->browser()->AllowServiceWorker(
           registration->pattern(), provider_host->topmost_frame_url(),
           resource_context_, render_process_id_, provider_host->frame_id())) {
     Send(new ServiceWorkerMsg_EnableNavigationPreloadError(
         thread_id, request_id, WebServiceWorkerError::ErrorTypeDisabled,
         std::string(kEnableNavigationPreloadErrorPrefix) +
             std::string(kUserDeniedPermissionMessage)));
     return;
   }
 
-  // TODO(falken): Write to disk before resolving the promise.
-  registration->EnableNavigationPreload(enable);
-  Send(new ServiceWorkerMsg_DidEnableNavigationPreload(thread_id, request_id));
+  GetContext()->storage()->UpdateNavigationPreloadEnabled(
+      registration->id(), registration->pattern().GetOrigin(), enable,
+      base::Bind(
+          &ServiceWorkerDispatcherHost::DidUpdateNavigationPreloadEnabled, this,
+          thread_id, request_id, registration->id(), enable));
 }
 
 void ServiceWorkerDispatcherHost::OnGetNavigationPreloadState(
     int thread_id,
     int request_id,
     int provider_id,
     int64_t registration_id) {
   ProviderStatus provider_status;
   ServiceWorkerProviderHost* provider_host =
       GetProviderHostForRequest(&provider_status, provider_id);
@@ skipping 42 matching lines @@
           registration->pattern(), provider_host->topmost_frame_url(),
           resource_context_, render_process_id_, provider_host->frame_id())) {
     Send(new ServiceWorkerMsg_GetNavigationPreloadStateError(
         thread_id, request_id, WebServiceWorkerError::ErrorTypeDisabled,
         std::string(kGetNavigationPreloadStateErrorPrefix) +
             std::string(kUserDeniedPermissionMessage)));
     return;
   }
 
   Send(new ServiceWorkerMsg_DidGetNavigationPreloadState(
-      thread_id, request_id,
-      NavigationPreloadState(registration->is_navigation_preload_enabled(),
-                             registration->navigation_preload_header())));
+      thread_id, request_id, registration->navigation_preload_state()));
 }
 
 void ServiceWorkerDispatcherHost::OnSetNavigationPreloadHeader(
     int thread_id,
     int request_id,
     int provider_id,
     int64_t registration_id,
     const std::string& value) {
   ProviderStatus provider_status;
   ServiceWorkerProviderHost* provider_host =
@@ skipping 23 matching lines @@
   ServiceWorkerRegistration* registration =
       GetContext()->GetLiveRegistration(registration_id);
   if (!registration) {
     // |registration| must be alive because a renderer retains a registration
     // reference at this point.
     bad_message::ReceivedBadMessage(
         this,
         bad_message::SWDH_SET_NAVIGATION_PRELOAD_HEADER_BAD_REGISTRATION_ID);
     return;
   }
+  // The spec discussion consensus is to reject if there is no active worker:
+  // https://github.com/w3c/ServiceWorker/issues/920#issuecomment-262212670
+  // TODO(falken): Remove this comment when the spec is updated.
+  if (!registration->active_version()) {
+    Send(new ServiceWorkerMsg_SetNavigationPreloadHeaderError(
+        thread_id, request_id, WebServiceWorkerError::ErrorTypeState,
+        std::string(kSetNavigationPreloadHeaderErrorPrefix) +
+            std::string(kNoActiveWorkerErrorMessage)));
+    return;
+  }
 
   std::vector<GURL> urls = {provider_host->document_url(),
                             registration->pattern()};
   if (!ServiceWorkerUtils::AllOriginsMatchAndCanAccessServiceWorkers(urls)) {
     bad_message::ReceivedBadMessage(
         this, bad_message::SWDH_SET_NAVIGATION_PRELOAD_HEADER_INVALID_ORIGIN);
     return;
   }
 
   // TODO(falken): Ideally this would match Blink's isValidHTTPHeaderValue.
   // Chrome's check is less restrictive: it allows non-latin1 characters.
   if (!net::HttpUtil::IsValidHeaderValue(value)) {
     bad_message::ReceivedBadMessage(
         this, bad_message::SWDH_SET_NAVIGATION_PRELOAD_HEADER_BAD_VALUE);
     return;
   }
 
   if (!GetContentClient()->browser()->AllowServiceWorker(
           registration->pattern(), provider_host->topmost_frame_url(),
           resource_context_, render_process_id_, provider_host->frame_id())) {
     Send(new ServiceWorkerMsg_SetNavigationPreloadHeaderError(
         thread_id, request_id, WebServiceWorkerError::ErrorTypeDisabled,
         std::string(kSetNavigationPreloadHeaderErrorPrefix) +
             std::string(kUserDeniedPermissionMessage)));
     return;
   }
 
-  // TODO(falken): Write to disk before resolving the promise.
-  registration->SetNavigationPreloadHeader(value);
-  Send(new ServiceWorkerMsg_DidSetNavigationPreloadHeader(thread_id,
-                                                          request_id));
+  GetContext()->storage()->UpdateNavigationPreloadHeader(
+      registration->id(), registration->pattern().GetOrigin(), value,
+      base::Bind(&ServiceWorkerDispatcherHost::DidUpdateNavigationPreloadHeader,
+                 this, thread_id, request_id, registration->id(), value));
 }
 
 void ServiceWorkerDispatcherHost::OnPostMessageToWorker(
     int handle_id,
     int provider_id,
     const base::string16& message,
     const url::Origin& source_origin,
     const std::vector<int>& sent_message_ports) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnPostMessageToWorker");
@@ skipping 763 matching lines @@
   // TODO(falken): This check can be removed once crbug.com/439697 is fixed.
   if (provider_host->document_url().is_empty()) {
     *status = ProviderStatus::NO_URL;
     return nullptr;
   }
 
   *status = ProviderStatus::OK;
   return provider_host;
 }
 
+void ServiceWorkerDispatcherHost::DidUpdateNavigationPreloadEnabled(
+    int thread_id,
+    int request_id,
+    int registration_id,
+    bool enable,
+    ServiceWorkerStatusCode status) {
+  if (status != SERVICE_WORKER_OK) {
+    Send(new ServiceWorkerMsg_EnableNavigationPreloadError(
+        thread_id, request_id, WebServiceWorkerError::ErrorTypeUnknown,
+        std::string(kEnableNavigationPreloadErrorPrefix) +
+            std::string(kDatabaseErrorMessage)));
+    return;
+  }
+  ServiceWorkerRegistration* registration =
+      GetContext()->GetLiveRegistration(registration_id);
+  if (registration)
+    registration->EnableNavigationPreload(enable);
+  Send(new ServiceWorkerMsg_DidEnableNavigationPreload(thread_id, request_id));
+}
+
+void ServiceWorkerDispatcherHost::DidUpdateNavigationPreloadHeader(
+    int thread_id,
+    int request_id,
+    int registration_id,
+    const std::string& value,
+    ServiceWorkerStatusCode status) {
+  if (status != SERVICE_WORKER_OK) {
+    Send(new ServiceWorkerMsg_SetNavigationPreloadHeaderError(
+        thread_id, request_id, WebServiceWorkerError::ErrorTypeUnknown,
+        std::string(kSetNavigationPreloadHeaderErrorPrefix) +
+            std::string(kDatabaseErrorMessage)));
+    return;
+  }
+  ServiceWorkerRegistration* registration =
+      GetContext()->GetLiveRegistration(registration_id);
+  if (registration)
+    registration->SetNavigationPreloadHeader(value);
+  Send(new ServiceWorkerMsg_DidSetNavigationPreloadHeader(thread_id,
+                                                          request_id));
+}
+
 void ServiceWorkerDispatcherHost::OnTerminateWorker(int handle_id) {
   ServiceWorkerHandle* handle = handles_.Lookup(handle_id);
   if (!handle) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::SWDH_TERMINATE_BAD_HANDLE);
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
 }  // namespace content