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

content/browser/service_worker/service_worker_quota_client.cc

 // Copyright 2014 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_quota_client.h"
 
 #include "base/bind.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/public/browser/browser_thread.h"
 
 using storage::QuotaClient;
@@ skipping 12 matching lines @@
     origins.insert(info.origin);
   }
   callback.Run(origins);
 }
 
 void ReportToQuotaStatus(const QuotaClient::DeletionCallback& callback,
                          bool status) {
   callback.Run(status ? storage::QuotaStatusCode::kQuotaStatusOk
                       : storage::QuotaStatusCode::kQuotaStatusUnknown);
 }
+
+void AccumulateUsage(const QuotaClient::GetUsageCallback& callback,

[michaeln, 2014/10/30 23:32:24]

oh, the name of this method doesn't fit since its not summing things up

[dmurph, 2014/10/31 19:10:49]

Done.

+                     const GURL& origin,
+                     const std::vector<ServiceWorkerUsageInfo>& usage_info) {
+  for (const auto& info : usage_info) {
+    if (info.origin == origin) {
+      callback.Run(info.total_size_bytes);
+      return;
+    }
+  }
+  callback.Run(0);
+}
 }  // namespace
 
 ServiceWorkerQuotaClient::ServiceWorkerQuotaClient(
     ServiceWorkerContextWrapper* context)
     : context_(context) {
 }
 
 ServiceWorkerQuotaClient::~ServiceWorkerQuotaClient() {
 }
 
 QuotaClient::ID ServiceWorkerQuotaClient::id() const {
   return QuotaClient::kServiceWorker;
 }
 
 void ServiceWorkerQuotaClient::OnQuotaManagerDestroyed() {
   delete this;
 }
 
 void ServiceWorkerQuotaClient::GetOriginUsage(
     const GURL& origin,
     storage::StorageType type,
     const GetUsageCallback& callback) {
-  // TODO(dmurph): Add usage fetching when information is available.
-  callback.Run(0);
+  if (type != storage::StorageType::kStorageTypeTemporary) {
+    callback.Run(0);
+    return;
+  }
+  context_->GetAllOriginsInfo(base::Bind(&AccumulateUsage, callback, origin));
 }
 
 void ServiceWorkerQuotaClient::GetOriginsForType(
     storage::StorageType type,
     const GetOriginsCallback& callback) {
   if (type != storage::StorageType::kStorageTypeTemporary) {
     callback.Run(std::set<GURL>());
     return;
   }
   context_->GetAllOriginsInfo(base::Bind(&ReportOrigins, callback, false, ""));
@@ skipping 19 matching lines @@
     return;
   }
   context_->DeleteForOrigin(origin, base::Bind(&ReportToQuotaStatus, callback));
 }
 
 bool ServiceWorkerQuotaClient::DoesSupport(storage::StorageType type) const {
   return type == storage::StorageType::kStorageTypeTemporary;
 }
 
 }  // namespace content