[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/callback_helpers.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"
@@ skipping 133 matching lines @@
   context()->UnregisterServiceWorker(
       pattern,
       base::Bind(&FinishUnregistrationOnIO, continuation));
 }
 
 void ServiceWorkerContextWrapper::Terminate() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   process_manager_->Shutdown();
 }
 
+void ServiceWorkerContextWrapper::CombineUsageInfo(
+    std::vector<ServiceWorkerUsageInfo>* usage_info,
+    std::map<GURL, int64>* usage_map,
+    const GetUsageInfoCallback& callback) {
+  DCHECK(usage_info);
+  DCHECK(usage_map);
+  for (auto& info : *usage_info) {
+    auto it = usage_map->find(info.origin);
+    info.total_size_bytes = it != usage_map->end() ? it->second : 0;
+  }
+  // We own usage_info, so as soon as we go out of scope it will be destroyed.
+  // Since we are explicitly calling Run here, we should be good, as the
+  // usage callback will be fully run before this callback is destroyed.
+  callback.Run(*usage_info);
+}
+
 void ServiceWorkerContextWrapper::GetAllOriginsInfo(
     const GetUsageInfoCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!context_core_.get()) {
     LOG(ERROR) << "ServiceWorkerContextCore is no longer alive.";
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(callback, std::vector<ServiceWorkerUsageInfo>()));
     return;
   }
+  auto* info_out = new std::vector<ServiceWorkerUsageInfo>();
+  auto* usage_map_out = new std::map<GURL, int64>();
+  base::Closure barrier = base::BarrierClosure(
+      2,
+      base::Bind(&ServiceWorkerContextWrapper::CombineUsageInfo,
+                 this,
+                 base::Owned(info_out),
+                 base::Owned(usage_map_out),
+                 callback));
   context()->storage()->GetAllRegistrations(base::Bind(
       &ServiceWorkerContextWrapper::DidGetAllRegistrationsForGetAllOrigins,
       this,
-      callback));
+      barrier,
+      base::Unretained(info_out)));
+  context()->storage()->GetAllUsageByOrigin(
+      base::Bind(&ServiceWorkerContextWrapper::DidGetUsageForAllOrigins,
+                 this,
+                 barrier,
+                 base::Unretained(usage_map_out)));
 }
 
 void ServiceWorkerContextWrapper::DidGetAllRegistrationsForGetAllOrigins(
-    const GetUsageInfoCallback& callback,
+    const base::Closure& closure,
+    std::vector<ServiceWorkerUsageInfo>* registrations_out,
     const std::vector<ServiceWorkerRegistrationInfo>& registrations) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(registrations_out);
+  base::ScopedClosureRunner closureRunner(closure);
   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;
     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);
   }
 
   for (std::map<GURL, ServiceWorkerUsageInfo>::const_iterator it =
            origins.begin();
        it != origins.end();
        ++it) {
     usage_infos.push_back(it->second);
   }
+  usage_infos.swap(*registrations_out);
+}
 
-  callback.Run(usage_infos);
+void ServiceWorkerContextWrapper::DidGetUsageForAllOrigins(
+    const base::Closure& closure,
+    std::map<GURL, int64>* usage_out,
+    const std::map<GURL, int64>& usage_map) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(usage_out);
+  base::ScopedClosureRunner closureRunner(closure);
+  usage_out->clear();
+  usage_out->insert(usage_map.begin(), usage_map.end());
 }
 
 namespace {
 void StatusCodeToBoolCallbackAdapter(
     const ServiceWorkerContext::ResultCallback& callback,
     ServiceWorkerStatusCode code) {
   callback.Run(code == ServiceWorkerStatusCode::SERVICE_WORKER_OK);
 }
 
 void EmptySuccessCallback(bool success) {
@@ skipping 87 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