Service Worker: Migrate to version_uuid and surface ServiceWorker.id. (Chromium 2/3)

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 <map>
 #include <set>
 #include <string>
@@ skipping 42 matching lines @@
 
   struct CONTENT_EXPORT RegistrationData {
     // These values are immutable for the life of a registration.
     int64 registration_id;
     GURL scope;
 
     // Versions are first stored once they successfully install and become
     // 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 version_id;
+    std::string version_uuid;
     bool is_active;
     bool has_fetch_handler;
     base::Time last_update_check;
 
     // Not populated until ServiceWorkerStorage::StoreRegistration is called.
     int64_t resources_total_size_bytes;
 
     RegistrationData();
     ~RegistrationData();
   };
 
   struct ResourceRecord {
     int64 resource_id;
     GURL url;
     // Signed so we can store -1 to specify an unknown or error state.  When
     // stored to the database, this value should always be >= 0.
     int64 size_bytes;
 
     ResourceRecord() : resource_id(-1), size_bytes(0) {}
     ResourceRecord(int64 id, GURL url, int64 size_bytes)
         : resource_id(id), url(url), size_bytes(size_bytes) {}
   };
 
   // Reads next available ids from the database. Returns OK if they are
   // successfully read. Fills the arguments with an initial value and returns
   // OK if they are not found in the database. Otherwise, returns an error.
   Status GetNextAvailableIds(
       int64* next_avail_registration_id,
-      int64* next_avail_version_id,
       int64* next_avail_resource_id);
 
   // Used for diskcache migration (http://crbug.com/487482). Returns true if the
   // storage needs to migrate a disk cache.
   Status IsDiskCacheMigrationNeeded(bool* migration_needed);
   Status SetDiskCacheMigrationNotNeeded();
 
   // Used for diskcache migration (http://crbug.com/487482). Returns true if the
   // storage needs to delete an old disk cache.
   Status IsOldDiskCacheDeletionNeeded(bool* deletion_needed);
@@ skipping 32 matching lines @@
   // Looks up the origin for the registration with |registration_id|. Returns OK
   // if a registration was found and read successfully. Otherwise, returns an
   // error.
   Status ReadRegistrationOrigin(int64 registration_id, GURL* origin);
 
   // Writes |registration| and |resources| into the database and does following
   // things:
   //   - If an old version of the registration exists, deletes it and sets
   //   |deleted_version| to the old version registration data object
   //   |newly_purgeable_resources| to its resources. Otherwise, sets
-  //   |deleted_version->version_id| to -1.
+  //   |deleted_version->version_uuid| to -1.
   //   - Bumps the next registration id and the next version id if needed.
   //   - Removes |resources| from the uncommitted list if exist.
   // Returns OK they are successfully written. Otherwise, returns an error.
   Status WriteRegistration(const RegistrationData& registration,
                            const std::vector<ResourceRecord>& resources,
                            RegistrationData* deleted_version,
                            std::vector<int64>* newly_purgeable_resources);
 
   // Updates a registration for |registration_id| to an active state. Returns OK
   // if it's successfully updated. Otherwise, returns an error.
   Status UpdateVersionToActive(
       int64 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 registration_id,
       const GURL& origin,
       const base::Time& time);
 
   // 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|
+  // |version_uuid| to the id of the version that was deleted and
+  // |newly_purgeable_resources| to its resources; otherwise, sets
+  // |version_uuid|
   // to -1. Returns OK if it's successfully deleted or not found in the
   // database. Otherwise, returns an error.
   Status DeleteRegistration(int64 registration_id,
                             const GURL& origin,
                             RegistrationData* deleted_version,
                             std::vector<int64>* newly_purgeable_resources);
 
   // Reads user data for |registration_id| and |user_data_name| from the
   // database.
   Status ReadUserData(int64 registration_id,
@@ skipping 88 matching lines @@
       const char* id_key,
       int64* next_avail_id);
 
   // Reads registration data for |registration_id| from the database. Returns OK
   // if successfully reads. Otherwise, returns an error.
   Status ReadRegistrationData(
       int64 registration_id,
       const GURL& origin,
       RegistrationData* registration);
 
-  // Reads resource records for |version_id| from the database. Returns OK if
+  // Reads resource records for |version_uuid| from the database. Returns OK if
   // it's successfully read or not found in the database. Otherwise, returns an
   // error.
-  Status ReadResourceRecords(
-      int64 version_id,
-      std::vector<ResourceRecord>* resources);
+  Status ReadResourceRecords(std::string version_uuid,
+                             std::vector<ResourceRecord>* resources);
 
-  // Deletes resource records for |version_id| from the database. Returns OK if
+  // Deletes resource records for |version_uuid| from the database. Returns OK
+  // if
   // they are successfully deleted or not found in the database. Otherwise,
   // returns an error.
-  Status DeleteResourceRecords(
-      int64 version_id,
-      std::vector<int64>* newly_purgeable_resources,
-      leveldb::WriteBatch* batch);
+  Status DeleteResourceRecords(std::string version_uuid,
+                               std::vector<int64>* newly_purgeable_resources,
+                               leveldb::WriteBatch* batch);
 
   // Reads resource ids for |id_key_prefix| from the database. Returns OK if
   // it's successfully read or not found in the database. Otherwise, returns an
   // error.
   Status ReadResourceIds(
       const char* id_key_prefix,
       std::set<int64>* ids);
 
   // Write resource ids for |id_key_prefix| into the database. Returns OK on
   // success. Otherwise, returns writes nothing and returns an error.
@@ skipping 32 matching lines @@
   Status WriteBatch(leveldb::WriteBatch* batch);
 
   // Bumps the next available id if |used_id| is greater than or equal to the
   // cached one.
   void BumpNextRegistrationIdIfNeeded(
       int64 used_id,
       leveldb::WriteBatch* batch);
   void BumpNextResourceIdIfNeeded(
       int64 used_id,
       leveldb::WriteBatch* batch);
-  void BumpNextVersionIdIfNeeded(
-      int64 used_id,
-      leveldb::WriteBatch* batch);
 
   bool IsOpen();
 
   void Disable(
       const tracked_objects::Location& from_here,
       Status status);
   void HandleOpenResult(
       const tracked_objects::Location& from_here,
       Status status);
   void HandleReadResult(
       const tracked_objects::Location& from_here,
       Status status);
   void HandleWriteResult(
       const tracked_objects::Location& from_here,
       Status status);
 
   const base::FilePath path_;
   scoped_ptr<leveldb::Env> env_;
   scoped_ptr<leveldb::DB> db_;
 
   int64 next_avail_registration_id_;
   int64 next_avail_resource_id_;
-  int64 next_avail_version_id_;
 
   enum State {
     UNINITIALIZED,
     INITIALIZED,
     DISABLED,
   };
   State state_;
 
   bool IsDatabaseInMemory() const;
 
@@ skipping 19 matching lines @@
                            MigrateOnDiskCacheAccess);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDiskCacheMigratorTest,
                            NotMigrateOnDatabaseAccess);
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDatabase);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_H_