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

content/browser/service_worker/service_worker_storage.cc

Index: content/browser/service_worker/service_worker_storage.cc
diff --git a/content/browser/service_worker/service_worker_storage.cc b/content/browser/service_worker/service_worker_storage.cc
index b0cfe30899555d00f5ab85e8ded16a9d3d163346..92c491343bdad3ae86f9229088c23c9c8c8386a5 100644
--- a/content/browser/service_worker/service_worker_storage.cc
+++ b/content/browser/service_worker/service_worker_storage.cc
@@ -440,6 +440,23 @@ void ServiceWorkerStorage::GetAllRegistrations(
                  base::Owned(registrations)));
 }
 
+void ServiceWorkerStorage::GetAllUsageByOrigin(
+    const OriginUsageCallback& callback) {
+  DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
+
+  RegistrationList* registrations = new RegistrationList;
+  PostTaskAndReplyWithResult(
+      database_task_manager_->GetTaskRunner(),
+      FROM_HERE,
+      base::Bind(&ServiceWorkerDatabase::GetAllRegistrations,
+                 base::Unretained(database_.get()),
+                 base::Unretained(registrations)),
+      base::Bind(&ServiceWorkerStorage::DidGetRegistrationsForUsage,
+                 weak_factory_.GetWeakPtr(),
+                 callback,
+                 base::Owned(registrations)));
+}
+
 void ServiceWorkerStorage::StoreRegistration(
     ServiceWorkerRegistration* registration,
     ServiceWorkerVersion* version,
@@ -479,22 +496,14 @@ void ServiceWorkerStorage::StoreRegistration(
       base::Bind(&WriteRegistrationInDB,
                  database_.get(),
                  base::MessageLoopProxy::current(),
-                 data, resources,
+                 data,
+                 resources,
                  base::Bind(&ServiceWorkerStorage::DidStoreRegistration,
                             weak_factory_.GetWeakPtr(),
-                            callback)));
+                            callback,
+                            data)));
 
   registration->set_is_deleted(false);
-
-  // TODO(dmurph): Add correct byte delta.
-  if (quota_manager_proxy_.get()) {
-    // Can be nullptr in tests.
-    quota_manager_proxy_->NotifyStorageModified(
-        storage::QuotaClient::kServiceWorker,
-        registration->pattern().GetOrigin(),
-        storage::StorageType::kStorageTypeTemporary,
-        0);
-  }
 }
 
 void ServiceWorkerStorage::UpdateToActiveState(
@@ -976,10 +985,31 @@ void ServiceWorkerStorage::DidGetAllRegistrations(
   callback.Run(infos);
 }
 
+void ServiceWorkerStorage::DidGetRegistrationsForUsage(
+    const OriginUsageCallback& callback,
+    RegistrationList* registrations,
+    ServiceWorkerDatabase::Status status) {
+  DCHECK(registrations);
+  if (status != ServiceWorkerDatabase::STATUS_OK &&
+      status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
+    ScheduleDeleteAndStartOver();
+    callback.Run(std::map<GURL, int64>());
+    return;
+  }
+
+  std::map<GURL, int64> usage_map;
+  for (const auto& registration : *registrations) {
+    usage_map[registration.scope.GetOrigin()] +=
+        registration.resources_total_size_bytes;
+  }
+  callback.Run(usage_map);
+}
+
 void ServiceWorkerStorage::DidStoreRegistration(
     const StatusCallback& callback,
+    const ServiceWorkerDatabase::RegistrationData& new_version,
     const GURL& origin,
-    int64 deleted_version_id,
+    ServiceWorkerDatabase::RegistrationData* deleted_version,
     const std::vector<int64>& newly_purgeable_resources,
     ServiceWorkerDatabase::Status status) {
   if (status != ServiceWorkerDatabase::STATUS_OK) {
@@ -987,10 +1017,19 @@ void ServiceWorkerStorage::DidStoreRegistration(
     callback.Run(DatabaseStatusToStatusCode(status));
     return;
   }
+  if (quota_manager_proxy_.get()) {
+    // Can be nullptr in tests.
+    quota_manager_proxy_->NotifyStorageModified(
+        storage::QuotaClient::kServiceWorker,
+        origin,
+        storage::StorageType::kStorageTypeTemporary,
+        new_version.resources_total_size_bytes -
+            deleted_version->resources_total_size_bytes);
+  }
   registered_origins_.insert(origin);
   callback.Run(SERVICE_WORKER_OK);
 
-  if (!context_ || !context_->GetLiveVersion(deleted_version_id))
+  if (!context_ || !context_->GetLiveVersion(deleted_version->version_id))
     StartPurgingResources(newly_purgeable_resources);
 }
 
@@ -1007,20 +1046,29 @@ void ServiceWorkerStorage::DidUpdateToActiveState(
 void ServiceWorkerStorage::DidDeleteRegistration(
     const DidDeleteRegistrationParams& params,
     bool origin_is_deletable,
-    int64 version_id,
+    ServiceWorkerDatabase::RegistrationData* deleted_version,
     const std::vector<int64>& newly_purgeable_resources,
     ServiceWorkerDatabase::Status status) {
+  DCHECK(deleted_version);
   pending_deletions_.erase(params.registration_id);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     ScheduleDeleteAndStartOver();
     params.callback.Run(DatabaseStatusToStatusCode(status));
     return;
   }
+  if (quota_manager_proxy_.get()) {
+    // Can be nullptr in tests.
+    quota_manager_proxy_->NotifyStorageModified(
+        storage::QuotaClient::kServiceWorker,
+        params.origin,
+        storage::StorageType::kStorageTypeTemporary,
+        -deleted_version->resources_total_size_bytes);
+  }
   if (origin_is_deletable)
     registered_origins_.erase(params.origin);
   params.callback.Run(SERVICE_WORKER_OK);
 
-  if (!context_ || !context_->GetLiveVersion(version_id))
+  if (!context_ || !context_->GetLiveVersion(deleted_version->version_id))
     StartPurgingResources(newly_purgeable_resources);
 }
 
@@ -1294,17 +1342,23 @@ void ServiceWorkerStorage::DeleteRegistrationFromDB(
     const DeleteRegistrationCallback& callback) {
   DCHECK(database);
 
-  int64 version_id = kInvalidServiceWorkerVersionId;
+  auto deleted_version =
+      make_scoped_ptr(new ServiceWorkerDatabase::RegistrationData());
+  deleted_version->version_id = kInvalidServiceWorkerVersionId;

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

this assignement isn't needed since its constructed with versions_id having this
value

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

Done.

   std::vector<int64> newly_purgeable_resources;
-  ServiceWorkerDatabase::Status status = database->DeleteRegistration(
-      registration_id, origin, &version_id, &newly_purgeable_resources);
+  ServiceWorkerDatabase::Status status =
+      database->DeleteRegistration(registration_id,
+                                   origin,
+                                   deleted_version.get(),
+                                   &newly_purgeable_resources);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
-    original_task_runner->PostTask(FROM_HERE,
-                                   base::Bind(callback,
-                                              false,
-                                              kInvalidServiceWorkerVersionId,
-                                              std::vector<int64>(),
-                                              status));
+    original_task_runner->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   false,
+                   base::Owned(deleted_version.release()),

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

when working with scoped_ptrs<> we usually used base::Passed(&scopedptr) to
transfer ownership, and the sig of the bound function accepts a scoped_ptr<T> as
input

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

Acknowledged.

+                   std::vector<int64>(),
+                   status));
     return;
   }
 
@@ -1313,20 +1367,24 @@ void ServiceWorkerStorage::DeleteRegistrationFromDB(
   std::vector<ServiceWorkerDatabase::RegistrationData> registrations;
   status = database->GetRegistrationsForOrigin(origin, &registrations);
   if (status != ServiceWorkerDatabase::STATUS_OK) {
-    original_task_runner->PostTask(FROM_HERE,
-                                   base::Bind(callback,
-                                              false,
-                                              kInvalidServiceWorkerVersionId,
-                                              std::vector<int64>(),
-                                              status));
+    original_task_runner->PostTask(
+        FROM_HERE,
+        base::Bind(callback,
+                   false,
+                   base::Owned(deleted_version.release()),
+                   std::vector<int64>(),
+                   status));
     return;
   }
 
   bool deletable = registrations.empty();
   original_task_runner->PostTask(
       FROM_HERE,
-      base::Bind(
-          callback, deletable, version_id, newly_purgeable_resources, status));
+      base::Bind(callback,
+                 deletable,
+                 base::Owned(deleted_version.release()),
+                 newly_purgeable_resources,
+                 status));
 }
 
 void ServiceWorkerStorage::WriteRegistrationInDB(
@@ -1336,16 +1394,19 @@ void ServiceWorkerStorage::WriteRegistrationInDB(
     const ResourceList& resources,
     const WriteRegistrationCallback& callback) {
   DCHECK(database);
-  int64 deleted_version_id = kInvalidServiceWorkerVersionId;
+  auto deleted_version =
+      make_scoped_ptr(new ServiceWorkerDatabase::RegistrationData());
+  deleted_version->registration_id = kInvalidServiceWorkerVersionId;
   std::vector<int64> newly_purgeable_resources;
   ServiceWorkerDatabase::Status status = database->WriteRegistration(
-      data, resources, &deleted_version_id, &newly_purgeable_resources);
-  original_task_runner->PostTask(FROM_HERE,
-                                 base::Bind(callback,
-                                            data.script.GetOrigin(),
-                                            deleted_version_id,
-                                            newly_purgeable_resources,
-                                            status));
+      data, resources, deleted_version.get(), &newly_purgeable_resources);
+  original_task_runner->PostTask(
+      FROM_HERE,
+      base::Bind(callback,
+                 data.script.GetOrigin(),
+                 base::Owned(deleted_version.release()),
+                 newly_purgeable_resources,
+                 status));
 }
 
 void ServiceWorkerStorage::FindForDocumentInDB(