[ServiceWorker] Added size deltas and total size computation for QuotaM.

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 <vector>
@@ skipping 47 matching lines @@
     // 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;
     bool is_active;
     bool has_fetch_handler;
     base::Time last_update_check;
 
     // Not populated until ServiceWorkerStorage::StoreRegistration is called.
-    uint64 resources_total_size_bytes;
+    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.
@@ skipping 37 matching lines @@
   // Otherwise, returns an error.
   Status ReadRegistration(
       int64 registration_id,
       const GURL& origin,
       RegistrationData* registration,
       std::vector<ResourceRecord>* resources);
 
   // 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_id| to the old version id and
+  //   |deleted_version| to the old version registration data object
   //   |newly_purgeable_resources| to its resources. Otherwise, sets
-  //   |deleted_version_id| to -1.
+  //   |deleted_version->version_id| 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,
-                           int64* deleted_version_id,
+                           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|
   // 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,
-                            int64* version_id,
+                            RegistrationData* deleted_version,
                             std::vector<int64>* newly_purgeable_resources);
 
   // As new resources are put into the diskcache, they go into an uncommitted
   // list. When a registration is saved that refers to those ids, they're
   // removed from that list. When a resource no longer has any registrations or
   // caches referring to it, it's added to the purgeable list. Periodically,
   // the purgeable list can be purged from the diskcache. At system startup, all
   // uncommitted ids are moved to the purgeable list.
 
   // Reads uncommitted resource ids from the database. Returns OK on success.
@@ skipping 162 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, DatabaseVersion);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, GetNextAvailableIds);
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerDatabaseTest, DestroyDatabase);
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerDatabase);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_DATABASE_H_