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

content/browser/service_worker/service_worker_context_wrapper.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_context_wrapper.h"
 
 #include <map>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
 #include "content/browser/service_worker/service_worker_quota_client.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace content {
+namespace {
+
+size_t GetUsageIfValid(const ServiceWorkerVersionInfo& version_info) {
+  return version_info.version_id != kInvalidServiceWorkerVersionId
+             ? version_info.resources_total_size_bytes
+             : 0;
+}
+
+size_t GetTotalUsageForRegistrationInfo(
+    const ServiceWorkerRegistrationInfo& registration_info) {
+  return GetUsageIfValid(registration_info.active_version) +
+         GetUsageIfValid(registration_info.waiting_version) +
+         GetUsageIfValid(registration_info.installing_version);

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

Like we chatted about, going with a model where there is one version stored for
a given registration at any given moment simplifies things. I'd vote to put the
size data member in the ServiceWorkerRegistrationInfo struct and have that value
reflect the space used by that one version that is stored. The size on disk
value we'll be reporting only ever changes upon completion of the
StoreRegistration() method.

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

Done.

+}
+
+}  // namespace
 
 ServiceWorkerContextWrapper::ServiceWorkerContextWrapper(
     BrowserContext* browser_context)
     : observer_list_(
           new ObserverListThreadSafe<ServiceWorkerContextObserver>()),
       process_manager_(new ServiceWorkerProcessManager(browser_context)),
       is_incognito_(false) {
 }
 
 ServiceWorkerContextWrapper::~ServiceWorkerContextWrapper() {
@@ skipping 141 matching lines @@
       callback));
 }
 
 void ServiceWorkerContextWrapper::DidGetAllRegistrationsForGetAllOrigins(
     const GetUsageInfoCallback& callback,
     const std::vector<ServiceWorkerRegistrationInfo>& registrations) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   std::vector<ServiceWorkerUsageInfo> usage_infos;
 
   std::map<GURL, ServiceWorkerUsageInfo> origins;
-  for (std::vector<ServiceWorkerRegistrationInfo>::const_iterator it =
-           registrations.begin();
-       it != registrations.end();
-       ++it) {
-    const ServiceWorkerRegistrationInfo& registration_info = *it;
+  for (const auto& registration_info : registrations) {
     GURL origin = registration_info.pattern.GetOrigin();
 
     ServiceWorkerUsageInfo& usage_info = origins[origin];
     if (usage_info.origin.is_empty())
       usage_info.origin = origin;
     usage_info.scopes.push_back(registration_info.pattern);
+    usage_info.total_size_bytes +=
+        GetTotalUsageForRegistrationInfo(registration_info);
   }
 
-  for (std::map<GURL, ServiceWorkerUsageInfo>::const_iterator it =
-           origins.begin();
-       it != origins.end();
-       ++it) {
-    usage_infos.push_back(it->second);
+  for (const auto& origin_info_pair : origins) {
+    usage_infos.push_back(origin_info_pair.second);
   }
-
   callback.Run(usage_infos);
 }
 
 namespace {
 void StatusCodeToBoolCallbackAdapter(
     const ServiceWorkerContext::ResultCallback& callback,
     ServiceWorkerStatusCode code) {
   callback.Run(code == ServiceWorkerStatusCode::SERVICE_WORKER_OK);
 }
 
@@ skipping 88 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (status != SERVICE_WORKER_OK) {
     context_core_.reset();
     return;
   }
   context_core_.reset(new ServiceWorkerContextCore(context_core_.get(), this));
   DVLOG(1) << "Restarted ServiceWorkerContextCore successfully.";
 }
 
 }  // namespace content