service worker: Persist NavigationPreloadState

content/browser/service_worker/service_worker_database.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/service_worker/service_worker_database.h"
 
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
@@ skipping 715 matching lines @@
   if (status != STATUS_OK)
     return status;
 
   registration.last_update_check = time;
 
   leveldb::WriteBatch batch;
   WriteRegistrationDataInBatch(registration, &batch);
   return WriteBatch(&batch);
 }
 
+ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::UpdateNavigationPreloadEnabled(int64_t registration_id,
+                                                      const GURL& origin,
+                                                      bool enable) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+  Status status = LazyOpen(false);
+  if (IsNewOrNonexistentDatabase(status))
+    return STATUS_ERROR_NOT_FOUND;
+  if (status != STATUS_OK)
+    return status;
+  if (!origin.is_valid())
+    return STATUS_ERROR_FAILED;
+
+  RegistrationData registration;
+  status = ReadRegistrationData(registration_id, origin, &registration);
+  if (status != STATUS_OK)
+    return status;
+
+  registration.navigation_preload_state.enabled = enable;
+
+  leveldb::WriteBatch batch;
+  WriteRegistrationDataInBatch(registration, &batch);
+  return WriteBatch(&batch);
+}
+
+ServiceWorkerDatabase::Status
+ServiceWorkerDatabase::UpdateNavigationPreloadHeader(int64_t registration_id,
+                                                     const GURL& origin,
+                                                     const std::string& value) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+  Status status = LazyOpen(false);
+  if (IsNewOrNonexistentDatabase(status))
+    return STATUS_ERROR_NOT_FOUND;
+  if (status != STATUS_OK)
+    return status;
+  if (!origin.is_valid())
+    return STATUS_ERROR_FAILED;
+
+  RegistrationData registration;
+  status = ReadRegistrationData(registration_id, origin, &registration);
+  if (status != STATUS_OK)
+    return status;
+
+  registration.navigation_preload_state.header = value;
+
+  leveldb::WriteBatch batch;
+  WriteRegistrationDataInBatch(registration, &batch);
+  return WriteBatch(&batch);
+}
+
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::DeleteRegistration(
     int64_t registration_id,
     const GURL& origin,
     RegistrationData* deleted_version,
     std::vector<int64_t>* newly_purgeable_resources) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   DCHECK(deleted_version);
   deleted_version->version_id = kInvalidServiceWorkerVersionId;
   Status status = LazyOpen(false);
   if (IsNewOrNonexistentDatabase(status))
@@ skipping 480 matching lines @@
   if (data.has_origin_trial_tokens()) {
     const ServiceWorkerOriginTrialInfo& info = data.origin_trial_tokens();
     TrialTokenValidator::FeatureToTokensMap origin_trial_tokens;
     for (int i = 0; i < info.features_size(); ++i) {
       const auto& feature = info.features(i);
       for (int j = 0; j < feature.tokens_size(); ++j)
         origin_trial_tokens[feature.name()].push_back(feature.tokens(j));
     }
     out->origin_trial_tokens = origin_trial_tokens;
   }
+  if (data.has_navigation_preload_state()) {
+    const ServiceWorkerNavigationPreloadState& state =
+        data.navigation_preload_state();
+    out->navigation_preload_state.enabled = state.enabled();
+    if (state.has_header())
+      out->navigation_preload_state.header = state.header();
+  }
 
   return ServiceWorkerDatabase::STATUS_OK;
 }
 
 void ServiceWorkerDatabase::WriteRegistrationDataInBatch(
     const RegistrationData& registration,
     leveldb::WriteBatch* batch) {
   DCHECK(batch);
 
   // The registration id and version id should be bumped before this.
@@ skipping 22 matching lines @@
     data.add_foreign_fetch_origin(origin.Serialize());
   if (registration.origin_trial_tokens) {
     ServiceWorkerOriginTrialInfo* info = data.mutable_origin_trial_tokens();
     for (const auto& feature : *registration.origin_trial_tokens) {
       ServiceWorkerOriginTrialFeature* feature_out = info->add_features();
       feature_out->set_name(feature.first);
       for (const auto& token : feature.second)
         feature_out->add_tokens(token);
     }
   }
+  ServiceWorkerNavigationPreloadState* state =
+      data.mutable_navigation_preload_state();
+  state->set_enabled(registration.navigation_preload_state.enabled);
+  state->set_header(registration.navigation_preload_state.header);
 
   std::string value;
   bool success = data.SerializeToString(&value);
   DCHECK(success);
   GURL origin = registration.scope.GetOrigin();
   batch->Put(CreateRegistrationKey(data.registration_id(), origin), value);
 }
 
 ServiceWorkerDatabase::Status ServiceWorkerDatabase::ReadResourceRecords(
     const RegistrationData& registration,
@@ skipping 365 matching lines @@
   if (status != STATUS_OK)
     Disable(from_here, status);
   ServiceWorkerMetrics::CountWriteDatabaseResult(status);
 }
 
 bool ServiceWorkerDatabase::IsDatabaseInMemory() const {
   return path_.empty();
 }
 
 }  // namespace content