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

content/browser/service_worker/service_worker_storage.h

 // Copyright 2013 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_STORAGE_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORAGE_H_
 
+#include <algorithm>
 #include <deque>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 32 matching lines @@
   typedef base::Callback<void(ServiceWorkerStatusCode status)> StatusCallback;
   typedef base::Callback<void(ServiceWorkerStatusCode status,
                               const scoped_refptr<ServiceWorkerRegistration>&
                                   registration)> FindRegistrationCallback;
   typedef base::Callback<
       void(const std::vector<ServiceWorkerRegistrationInfo>& registrations)>
           GetAllRegistrationInfosCallback;
   typedef base::Callback<
       void(ServiceWorkerStatusCode status, bool are_equal)>
           CompareCallback;
+  typedef base::Callback<void(const std::map<GURL, int64>& origin_usage)>
+      OriginUsageCallback;
 
   ~ServiceWorkerStorage() override;
 
   static scoped_ptr<ServiceWorkerStorage> Create(
       const base::FilePath& path,
       base::WeakPtr<ServiceWorkerContextCore> context,
       scoped_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
       const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
       storage::QuotaManagerProxy* quota_manager_proxy,
       storage::SpecialStoragePolicy* special_storage_policy);
@@ skipping 18 matching lines @@
                                   const FindRegistrationCallback& callback);
   void FindRegistrationForId(int64 registration_id,
                              const GURL& origin,
                              const FindRegistrationCallback& callback);
 
   ServiceWorkerRegistration* GetUninstallingRegistration(const GURL& scope);
 
   // Returns info about all stored and initially installing registrations.
   void GetAllRegistrations(const GetAllRegistrationInfosCallback& callback);
 
+  void GetAllUsageByOrigin(const OriginUsageCallback& callback);
+
   // Commits |registration| with the installed but not activated |version|
   // to storage, overwritting any pre-existing registration data for the scope.
   // A pre-existing version's script resources remain available if that version
   // is live. PurgeResources should be called when it's OK to delete them.
-  void StoreRegistration(
-      ServiceWorkerRegistration* registration,
-      ServiceWorkerVersion* version,
-      const StatusCallback& callback);
+  void StoreRegistration(ServiceWorkerRegistration* registration,
+                         ServiceWorkerVersion* version,
+                         const StatusCallback& callback);
 
   // Updates the state of the registration's stored version to active.
   void UpdateToActiveState(
       ServiceWorkerRegistration* registration,
       const StatusCallback& callback);
 
   // Updates the stored time to match the value of
   // registration->last_update_check().
   void UpdateLastUpdateCheckTime(ServiceWorkerRegistration* registration);
 
@@ skipping 85 matching lines @@
     DidDeleteRegistrationParams();
     ~DidDeleteRegistrationParams();
   };
 
   typedef std::vector<ServiceWorkerDatabase::RegistrationData> RegistrationList;
   typedef std::map<int64, scoped_refptr<ServiceWorkerRegistration> >
       RegistrationRefsById;
   typedef base::Callback<void(
       InitialData* data,
       ServiceWorkerDatabase::Status status)> InitializeCallback;
-  typedef base::Callback<
-      void(const GURL& origin,
-           int64 deleted_version_id,
-           const std::vector<int64>& newly_purgeable_resources,
-           ServiceWorkerDatabase::Status status)> WriteRegistrationCallback;
-  typedef base::Callback<
-      void(bool origin_is_deletable,
-           int64 version_id,
-           const std::vector<int64>& newly_purgeable_resources,
-           ServiceWorkerDatabase::Status status)> DeleteRegistrationCallback;
+  // The registration data is owned by the callback.
+  typedef base::Callback<void(
+      const GURL& origin,
+      ServiceWorkerDatabase::RegistrationData* deleted_version_data,
+      const std::vector<int64>& newly_purgeable_resources,
+      ServiceWorkerDatabase::Status status)> WriteRegistrationCallback;
+  // The registration data is owned by the callback.
+  typedef base::Callback<void(
+      bool origin_is_deletable,
+      ServiceWorkerDatabase::RegistrationData* deleted_version_data,
+      const std::vector<int64>& newly_purgeable_resources,
+      ServiceWorkerDatabase::Status status)> DeleteRegistrationCallback;
   typedef base::Callback<void(
       const ServiceWorkerDatabase::RegistrationData& data,
       const ResourceList& resources,
       ServiceWorkerDatabase::Status status)> FindInDBCallback;
   typedef base::Callback<void(const std::vector<int64>& resource_ids,
                               ServiceWorkerDatabase::Status status)>
       GetResourcesCallback;
 
   ServiceWorkerStorage(
       const base::FilePath& path,
@@ skipping 26 matching lines @@
       ServiceWorkerDatabase::Status status);
   void DidFindRegistrationForId(
       const FindRegistrationCallback& callback,
       const ServiceWorkerDatabase::RegistrationData& data,
       const ResourceList& resources,
       ServiceWorkerDatabase::Status status);
   void DidGetAllRegistrations(
       const GetAllRegistrationInfosCallback& callback,
       RegistrationList* registrations,
       ServiceWorkerDatabase::Status status);
-  void DidStoreRegistration(const StatusCallback& callback,
-                            const GURL& origin,
-                            int64 deleted_version_id,
-                            const std::vector<int64>& newly_purgeable_resources,
-                            ServiceWorkerDatabase::Status status);
+  void DidGetRegistrationsForUsage(const OriginUsageCallback& callback,
+                                   RegistrationList* registrations,
+                                   ServiceWorkerDatabase::Status status);
+  void DidStoreRegistration(
+      const StatusCallback& callback,
+      const ServiceWorkerDatabase::RegistrationData& new_version,
+      const GURL& origin,
+      ServiceWorkerDatabase::RegistrationData* deleted_version,

[michaeln, 2014/10/28 22:00:40]

or maybe use a const T& for this arg to simplify the ownership?

[dmurph, 2014/10/29 22:18:25]

Done.

+      const std::vector<int64>& newly_purgeable_resources,
+      ServiceWorkerDatabase::Status status);
   void DidUpdateToActiveState(
       const StatusCallback& callback,
       ServiceWorkerDatabase::Status status);
   void DidDeleteRegistration(
       const DidDeleteRegistrationParams& params,
       bool origin_is_deletable,
-      int64 version_id,
+      ServiceWorkerDatabase::RegistrationData* version,
       const std::vector<int64>& newly_purgeable_resources,
       ServiceWorkerDatabase::Status status);
   void ReturnFoundRegistration(
       const FindRegistrationCallback& callback,
       const ServiceWorkerDatabase::RegistrationData& data,
       const ResourceList& resources);
 
   scoped_refptr<ServiceWorkerRegistration> GetOrCreateRegistration(
       const ServiceWorkerDatabase::RegistrationData& data,
       const ResourceList& resources);
@@ skipping 111 matching lines @@
   std::set<int64> pending_deletions_;
 
   base::WeakPtrFactory<ServiceWorkerStorage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_STORAGE_H_