service worker: Implement NavigationPreloadManager.setHeaderValue

content/browser/service_worker/service_worker_registration.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_registration.h"
 
 #include <vector>
 
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
@@ skipping 20 matching lines @@
 ServiceWorkerRegistration::ServiceWorkerRegistration(
     const GURL& pattern,
     int64_t registration_id,
     base::WeakPtr<ServiceWorkerContextCore> context)
     : pattern_(pattern),
       registration_id_(registration_id),
       is_deleted_(false),
       is_uninstalling_(false),
       is_uninstalled_(false),
       should_activate_when_ready_(false),
-      is_navigation_preload_enabled_(false),
       resources_total_size_bytes_(0),
       context_(context),
       task_runner_(base::ThreadTaskRunnerHandle::Get()) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_NE(kInvalidServiceWorkerRegistrationId, registration_id);
   DCHECK(context_);
   context_->AddLiveRegistration(this);
 }
 
 ServiceWorkerRegistration::~ServiceWorkerRegistration() {
@@ skipping 64 matching lines @@
   should_activate_when_ready_ = false;
 
   ChangedVersionAttributesMask mask;
   if (version)
     UnsetVersionInternal(version.get(), &mask);
   if (active_version_)
     active_version_->RemoveListener(this);
   active_version_ = version;
   if (active_version_) {
     active_version_->AddListener(this);
-    active_version_->set_navigation_preload_enabled(
-        is_navigation_preload_enabled_);
+    active_version_->SetNavigationPreloadState(navigation_preload_state_);
   }
   mask.add(ChangedVersionAttributesMask::ACTIVE_VERSION);
 
   NotifyVersionAttributesChanged(mask);
 }
 
 void ServiceWorkerRegistration::SetWaitingVersion(
     const scoped_refptr<ServiceWorkerVersion>& version) {
   if (waiting_version_ == version)
     return;
@@ skipping 254 matching lines @@
   for (const auto& callback : callbacks)
     callback.Run();
 }
 
 void ServiceWorkerRegistration::SetTaskRunnerForTest(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   task_runner_ = task_runner;
 }
 
 void ServiceWorkerRegistration::EnableNavigationPreload(bool enable) {
-  if (is_navigation_preload_enabled_ == enable)
+  if (navigation_preload_state_.enabled == enable)
     return;
-  is_navigation_preload_enabled_ = enable;
+  navigation_preload_state_.enabled = enable;
   if (active_version_)
-    active_version_->set_navigation_preload_enabled(enable);
+    active_version_->SetNavigationPreloadState(navigation_preload_state_);
+}
+
+void ServiceWorkerRegistration::SetNavigationPreloadHeader(
+    const std::string& header) {
+  if (navigation_preload_state_.header == header)
+    return;
+  navigation_preload_state_.header = header;
+  if (active_version_)
+    active_version_->SetNavigationPreloadState(navigation_preload_state_);
 }
 
 void ServiceWorkerRegistration::RegisterRegistrationFinishedCallback(
     const base::Closure& callback) {
   // This should only be called if the registration is in progress.
   DCHECK(!active_version() && !waiting_version() && !is_uninstalled() &&
          !is_uninstalling());
   registration_finished_callbacks_.push_back(callback);
 }
 
@@ skipping 98 matching lines @@
   if (!context_) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
   context_->storage()->NotifyDoneInstallingRegistration(
       this, version.get(), status);
   callback.Run(status);
 }
 
 }  // namespace content