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

content/browser/service_worker/service_worker_storage.cc

 // 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.
 
 #include "content/browser/service_worker/service_worker_storage.h"
 
 #include <string>
 
 #include "base/bind_helpers.h"
 #include "base/debug/trace_event.h"
@@ skipping 452 matching lines @@
   data.is_active = (version == registration->active_version());
 
   ResourceList resources;
   version->script_cache_map()->GetResources(&resources);
 
   uint64 resources_total_size_bytes = 0;
   for (const auto& resource : resources) {
     resources_total_size_bytes += resource.size_bytes;
   }
   data.resources_total_size_bytes = resources_total_size_bytes;
+  registration->set_resources_total_size_bytes(resources_total_size_bytes);

[michaeln, 2014/10/30 01:32:27]

I think this should happen in DidStoreRegistration next to where
NotifyStorageModified is called. Otherwise i think there's can be an
inconsistency in the numbers given to the QM (espcially if StoreRegistration
fails for some reason).

[dmurph, 2014/10/30 22:06:16]

Done.

+  version->set_resources_total_size_bytes(resources_total_size_bytes);
 
   if (!has_checked_for_stale_resources_)
     DeleteStaleResources();
 
   database_task_manager_->GetTaskRunner()->PostTask(
       FROM_HERE,
       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(
     ServiceWorkerRegistration* registration,
     const StatusCallback& callback) {
   DCHECK(registration);
 
   DCHECK(state_ == INITIALIZED || state_ == DISABLED) << state_;
   if (IsDisabled() || !context_) {
     RunSoon(FROM_HERE, base::Bind(callback, SERVICE_WORKER_ERROR_FAILED));
@@ skipping 463 matching lines @@
        it != installing_registrations_.end(); ++it) {
     if (pushed_registrations.insert(it->first).second)
       infos.push_back(it->second->GetInfo());
   }
 
   callback.Run(infos);
 }
 
 void ServiceWorkerStorage::DidStoreRegistration(
     const StatusCallback& callback,
+    const ServiceWorkerDatabase::RegistrationData& new_version,
     const GURL& origin,
-    int64 deleted_version_id,
+    const ServiceWorkerDatabase::RegistrationData& deleted_version,
     const std::vector<int64>& newly_purgeable_resources,
     ServiceWorkerDatabase::Status status) {
   if (status != ServiceWorkerDatabase::STATUS_OK) {
     ScheduleDeleteAndStartOver();
     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);
 }
 
 void ServiceWorkerStorage::DidUpdateToActiveState(
     const StatusCallback& callback,
     ServiceWorkerDatabase::Status status) {
   if (status != ServiceWorkerDatabase::STATUS_OK &&
       status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
     ScheduleDeleteAndStartOver();
   }
   callback.Run(DatabaseStatusToStatusCode(status));
 }
 
 void ServiceWorkerStorage::DidDeleteRegistration(
     const DidDeleteRegistrationParams& params,
     bool origin_is_deletable,
-    int64 version_id,
+    const ServiceWorkerDatabase::RegistrationData& deleted_version,
     const std::vector<int64>& newly_purgeable_resources,
     ServiceWorkerDatabase::Status status) {
   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);
 }
 
 scoped_refptr<ServiceWorkerRegistration>
 ServiceWorkerStorage::GetOrCreateRegistration(
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources) {
   scoped_refptr<ServiceWorkerRegistration> registration =
       context_->GetLiveRegistration(data.registration_id);
   if (registration.get())
     return registration;
 
   registration = new ServiceWorkerRegistration(
       data.scope, data.registration_id, context_);
+  registration->set_resources_total_size_bytes(data.resources_total_size_bytes);
   registration->set_last_update_check(data.last_update_check);
   if (pending_deletions_.find(data.registration_id) !=
       pending_deletions_.end()) {
     registration->set_is_deleted(true);
   }
   scoped_refptr<ServiceWorkerVersion> version =
       context_->GetLiveVersion(data.version_id);
   if (!version.get()) {
     version = new ServiceWorkerVersion(
         registration.get(), data.script, data.version_id, context_);
@@ skipping 239 matching lines @@
 }
 
 void ServiceWorkerStorage::DeleteRegistrationFromDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     int64 registration_id,
     const GURL& origin,
     const DeleteRegistrationCallback& callback) {
   DCHECK(database);
 
-  int64 version_id = kInvalidServiceWorkerVersionId;
+  ServiceWorkerDatabase::RegistrationData deleted_version;
+  deleted_version.version_id = kInvalidServiceWorkerVersionId;
   std::vector<int64> newly_purgeable_resources;
   ServiceWorkerDatabase::Status status = database->DeleteRegistration(
-      registration_id, origin, &version_id, &newly_purgeable_resources);
+      registration_id, origin, &deleted_version, &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, deleted_version, std::vector<int64>(), status));
     return;
   }
 
   // TODO(nhiroki): Add convenient method to ServiceWorkerDatabase to check the
   // unique origin list.
   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, deleted_version, 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));
+  original_task_runner->PostTask(FROM_HERE,
+                                 base::Bind(callback,
+                                            deletable,
+                                            deleted_version,
+                                            newly_purgeable_resources,
+                                            status));
 }
 
 void ServiceWorkerStorage::WriteRegistrationInDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const ServiceWorkerDatabase::RegistrationData& data,
     const ResourceList& resources,
     const WriteRegistrationCallback& callback) {
   DCHECK(database);
-  int64 deleted_version_id = kInvalidServiceWorkerVersionId;
+  ServiceWorkerDatabase::RegistrationData deleted_version;
+  deleted_version.registration_id = kInvalidServiceWorkerVersionId;
   std::vector<int64> newly_purgeable_resources;
   ServiceWorkerDatabase::Status status = database->WriteRegistration(
-      data, resources, &deleted_version_id, &newly_purgeable_resources);
+      data, resources, &deleted_version, &newly_purgeable_resources);
   original_task_runner->PostTask(FROM_HERE,
                                  base::Bind(callback,
                                             data.script.GetOrigin(),
-                                            deleted_version_id,
+                                            deleted_version,
                                             newly_purgeable_resources,
                                             status));
 }
 
 void ServiceWorkerStorage::FindForDocumentInDB(
     ServiceWorkerDatabase* database,
     scoped_refptr<base::SequencedTaskRunner> original_task_runner,
     const GURL& document_url,
     const FindInDBCallback& callback) {
   GURL origin = document_url.GetOrigin();
@@ skipping 138 matching lines @@
     // Give up the corruption recovery until the browser restarts.
     LOG(ERROR) << "Failed to delete the diskcache.";
     callback.Run(SERVICE_WORKER_ERROR_FAILED);
     return;
   }
   DVLOG(1) << "Deleted ServiceWorkerDiskCache successfully.";
   callback.Run(SERVICE_WORKER_OK);
 }
 
 }  // namespace content