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

content/browser/service_worker/service_worker_context_wrapper.cc

Index: content/browser/service_worker/service_worker_context_wrapper.cc
diff --git a/content/browser/service_worker/service_worker_context_wrapper.cc b/content/browser/service_worker/service_worker_context_wrapper.cc
index b135a85056b3bed00f969ae7059a047f2803fc7a..f22a604e9ef918acc5716a595b85d50a17da208e 100644
--- a/content/browser/service_worker/service_worker_context_wrapper.cc
+++ b/content/browser/service_worker/service_worker_context_wrapper.cc
@@ -7,6 +7,7 @@
 #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"
@@ -160,6 +161,22 @@ void ServiceWorkerContextWrapper::Terminate() {
   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);
@@ -171,16 +188,34 @@ void ServiceWorkerContextWrapper::GetAllOriginsInfo(
         base::Bind(callback, std::vector<ServiceWorkerUsageInfo>()));
     return;
   }
+  auto* info_out = new std::vector<ServiceWorkerUsageInfo>();
+  auto* usage_map_out = new std::map<GURL, int64>();

[michaeln, 2014/10/24 23:15:47]

It took me a while to understand the reason for the multiple calls and the
combining of the results. Wdyt about adding a 'size_on_disk' data member to
ServiceWorkerRegistrationInfo  instead, so everything can be computed with the
one call to GetAllRegistrations().

[dmurph, 2014/10/27 21:37:06]

I talked to Josh about this for a while, and we decided that
ServiceWorkerRegistrationInfo object already filled a pretty separate role and
it would add potentially buggy logic and extra piping to keep that struct in
sync (as it's maintained in memory).  There are also a lot of places where this
object gets created, and it's difficult to figure out where storing the size is
necessary and how to do it.

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

There don't seem to be many places where these are constructed and not very many
usages alltogether. ServiceWorkerRegistration::GetInfo() is one of them and also
in the act of responding to storage->GetAllRegistrations(...) when the
registration is not 'live'.

The size of a registration only changes when storage->StoreRegistration happens.

Where do you see difficulty?
I don't understand that comment, can you explain?

+  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;
@@ -203,8 +238,18 @@ void ServiceWorkerContextWrapper::DidGetAllRegistrationsForGetAllOrigins(
        ++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 {