Implement updateViaCache flag and no-cache by default for main service worker scripts

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 258 matching lines @@
     case ServiceWorkerDatabase::STATUS_ERROR_MAX:
       NOTREACHED();
       return "Database unknown error";
   }
   NOTREACHED();
   return "Database unknown error";
 }
 
 ServiceWorkerDatabase::RegistrationData::RegistrationData()
     : registration_id(kInvalidServiceWorkerRegistrationId),
+      update_via_cache(blink::WebServiceWorkerUpdateViaCache::kImports),
       version_id(kInvalidServiceWorkerVersionId),
       is_active(false),
       has_fetch_handler(false),
-      resources_total_size_bytes(0) {
-}
+      resources_total_size_bytes(0) {}
 
 ServiceWorkerDatabase::RegistrationData::RegistrationData(
     const RegistrationData& other) = default;
 
 ServiceWorkerDatabase::RegistrationData::~RegistrationData() {
 }
 
 ServiceWorkerDatabase::ServiceWorkerDatabase(const base::FilePath& path)
     : path_(path),
       next_avail_registration_id_(0),
@@ skipping 1101 matching lines @@
     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();
   }
 
   for (uint32_t feature : data.used_features())
     out->used_features.insert(feature);
 
+  if (data.has_update_via_cache()) {
+    auto value = data.update_via_cache();
+    if (ServiceWorkerRegistrationData_ServiceWorkerUpdateViaCacheType_IsValid(
+            value)) {
+      DLOG(ERROR) << "Update via cache mode  '" << value << "' is not valid.";
+      return ServiceWorkerDatabase::STATUS_ERROR_CORRUPTED;
+    }
+    out->update_via_cache =
+        static_cast<blink::WebServiceWorkerUpdateViaCache>(value);
+  }
+
   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.
   DCHECK_GT(next_avail_registration_id_, registration.registration_id);
@@ skipping 29 matching lines @@
     }
   }
   ServiceWorkerNavigationPreloadState* state =
       data.mutable_navigation_preload_state();
   state->set_enabled(registration.navigation_preload_state.enabled);
   state->set_header(registration.navigation_preload_state.header);
 
   for (uint32_t feature : registration.used_features)
     data.add_used_features(feature);
 
+  data.set_update_via_cache(
+      static_cast<
+          ServiceWorkerRegistrationData_ServiceWorkerUpdateViaCacheType>(
+          registration.update_via_cache));
+
   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,
     std::vector<ResourceRecord>* resources) {
@@ skipping 364 matching lines @@
   if (status != STATUS_OK)
     Disable(from_here, status);
   ServiceWorkerMetrics::CountWriteDatabaseResult(status);
 }
 
 bool ServiceWorkerDatabase::IsDatabaseInMemory() const {
   return path_.empty();
 }
 
 }  // namespace content