[ServiceWorkerCache] Return the real size of the cache in GetOriginUsage.

content/browser/service_worker/service_worker_cache.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_cache.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
@@ skipping 24 matching lines @@
 
 enum EntryIndex { INDEX_HEADERS = 0, INDEX_RESPONSE_BODY };
 
 // The maximum size of an individual cache. Ultimately cache size is controlled
 // per-origin.
 const int kMaxCacheBytes = 512 * 1024 * 1024;
 
 // Buffer size for cache and blob reading/writing.
 const int kBufferSize = 1024 * 512;
 
+void NotReachedCompletionCallback(int rv) {
+  NOTREACHED();
+}
+
 blink::WebServiceWorkerResponseType ProtoResponseTypeToWebResponseType(
     ServiceWorkerRequestResponseHeaders_ResponseType response_type) {
   switch (response_type) {
     case ServiceWorkerRequestResponseHeaders_ResponseType_BASIC_TYPE:
       return blink::WebServiceWorkerResponseTypeBasic;
     case ServiceWorkerRequestResponseHeaders_ResponseType_CORS_TYPE:
       return blink::WebServiceWorkerResponseTypeCORS;
     case ServiceWorkerRequestResponseHeaders_ResponseType_DEFAULT_TYPE:
       return blink::WebServiceWorkerResponseTypeDefault;
     case ServiceWorkerRequestResponseHeaders_ResponseType_ERROR_TYPE:
@@ skipping 904 matching lines @@
   int rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void ServiceWorkerCache::Close() {
   backend_.reset();
 }
 
+int64 ServiceWorkerCache::MemoryBackedSize() const {
+  if (!backend_ || !memory_only_)
+    return 0;
+
+  scoped_ptr<disk_cache::Backend::Iterator> backend_iter =
+      backend_->CreateIterator();
+  disk_cache::Entry* entry = nullptr;
+
+  int64 sum = 0;
+
+  std::vector<disk_cache::Entry*> entries;
+  int rv = net::OK;
+  while ((rv = backend_iter->OpenNextEntry(
+              &entry, base::Bind(NotReachedCompletionCallback))) == net::OK) {
+    entries.push_back(entry);  // Open the entries without mutating them.
+  }
+  DCHECK(rv !=
+         net::ERR_IO_PENDING);  // Expect all memory ops to be synchronous.
+
+  for (disk_cache::Entry* entry : entries) {
+    sum += entry->GetDataSize(INDEX_HEADERS) +
+           entry->GetDataSize(INDEX_RESPONSE_BODY);
+    entry->Close();
+  }
+
+  return sum;
+}
+
 ServiceWorkerCache::ServiceWorkerCache(
     const GURL& origin,
     const base::FilePath& path,
     net::URLRequestContext* request_context,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context)
     : origin_(origin),
       path_(path),
       request_context_(request_context),
       quota_manager_proxy_(quota_manager_proxy),
       blob_storage_context_(blob_context),
       initialized_(false),
+      memory_only_(path.empty()),
       weak_ptr_factory_(this) {
 }
 
 void ServiceWorkerCache::PutImpl(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle,
     const ResponseCallback& callback) {
   if (!backend_) {
     callback.Run(ErrorTypeStorage,
@@ skipping 114 matching lines @@
     entry->Doom();
   }
 
   KeysProcessNextEntry(keys_context.Pass(), iter + 1);
 }
 
 void ServiceWorkerCache::CreateBackend(const ErrorCallback& callback) {
   DCHECK(!backend_);
 
   // Use APP_CACHE as opposed to DISK_CACHE to prevent cache eviction.
-  net::CacheType cache_type =
-      path_.empty() ? net::MEMORY_CACHE : net::APP_CACHE;
+  net::CacheType cache_type = memory_only_ ? net::MEMORY_CACHE : net::APP_CACHE;
 
   scoped_ptr<ScopedBackendPtr> backend_ptr(new ScopedBackendPtr());
 
   // Temporary pointer so that backend_ptr can be Pass()'d in Bind below.
   ScopedBackendPtr* backend = backend_ptr.get();
 
   net::CompletionCallback create_cache_callback =
       base::Bind(CreateBackendDidCreate,
                  callback,
                  base::Passed(backend_ptr.Pass()),
@@ skipping 31 matching lines @@
   initialized_ = true;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
        ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
 }  // namespace content