service worker: Persist NavigationPreloadState

content/browser/service_worker/service_worker_database.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/optional.h"
 #include "base/sequence_checker.h"
 #include "base/time/time.h"
 #include "content/common/content_export.h"
 #include "content/common/origin_trials/trial_token_validator.h"
 #include "content/common/service_worker/service_worker_status_code.h"
+#include "content/common/service_worker/service_worker_types.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace leveldb {
 class DB;
 class Env;
 class Status;
 class WriteBatch;
 }
 
@@ skipping 31 matching lines @@
     // the waiting version. Then transition to the active version. The stored
     // version may be in the ACTIVATED state or in the INSTALLED state.
     GURL script;
     int64_t version_id;
     bool is_active;
     bool has_fetch_handler;
     base::Time last_update_check;
     std::vector<GURL> foreign_fetch_scopes;
     std::vector<url::Origin> foreign_fetch_origins;
     base::Optional<TrialTokenValidator::FeatureToTokensMap> origin_trial_tokens;
+    NavigationPreloadState navigation_preload_state;
 
     // Not populated until ServiceWorkerStorage::StoreRegistration is called.
     int64_t resources_total_size_bytes;
 
     RegistrationData();
     RegistrationData(const RegistrationData& other);
     ~RegistrationData();
   };
 
   struct ResourceRecord {
@@ skipping 71 matching lines @@
   // Updates a registration for |registration_id| to an active state. Returns OK
   // if it's successfully updated. Otherwise, returns an error.
   Status UpdateVersionToActive(int64_t registration_id, const GURL& origin);
 
   // Updates last check time of a registration for |registration_id| by |time|.
   // Returns OK if it's successfully updated. Otherwise, returns an error.
   Status UpdateLastCheckTime(int64_t registration_id,
                              const GURL& origin,
                              const base::Time& time);
 
+  // Updates the navigation preload state for the specified registration.
+  // Returns OK if it's successfully updated. Otherwise, returns an error.
+  Status UpdateNavigationPreloadEnabled(int64_t registration_id,
+                                        const GURL& origin,
+                                        bool enable);
+  Status UpdateNavigationPreloadHeader(int64_t registration_id,
+                                       const GURL& origin,
+                                       const std::string& value);
+
   // Deletes a registration for |registration_id| and moves resource records
   // associated with it into the purgeable list. If deletion occurred, sets
   // |version_id| to the id of the version that was deleted and
   // |newly_purgeable_resources| to its resources; otherwise, sets |version_id|
   // to -1. Returns OK if it's successfully deleted or not found in the
   // database. Otherwise, returns an error.
   Status DeleteRegistration(int64_t registration_id,
                             const GURL& origin,
                             RegistrationData* deleted_version,
                             std::vector<int64_t>* newly_purgeable_resources);
@@ skipping 87 matching lines @@
   // if successfully reads. Otherwise, returns an error.
   Status ReadRegistrationData(int64_t registration_id,
                               const GURL& origin,
                               RegistrationData* registration);
 
   // Parses |serialized| as a RegistrationData object and pushes it into |out|.
   ServiceWorkerDatabase::Status ParseRegistrationData(
       const std::string& serialized,
       RegistrationData* out);
 
+  // Populates |batch| with operations to write |registration|. It does not
+  // actually write to db yet.
   void WriteRegistrationDataInBatch(const RegistrationData& registration,
                                     leveldb::WriteBatch* batch);
 
   // Reads resource records for |registration| from the database. Returns OK if
   // it's successfully read or not found in the database. Otherwise, returns an
   // error.
   Status ReadResourceRecords(const RegistrationData& registration,
                              std::vector<ResourceRecord>* resources);
 
   // Parses |serialized| as a ResourceRecord object and pushes it into |out|.
@@ skipping 99 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest,
                            UserData_UninitializedDatabase);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, DestroyDatabase);
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDatabase);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_H_