Cache Storage API: Hook up to chrome://settings/cookies

content/browser/cache_storage/cache_storage_manager.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/cache_storage/cache_storage_manager.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/id_map.h"
 #include "base/sha1.h"
+#include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "base/time/time.h"
 #include "content/browser/cache_storage/cache_storage.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_quota_client.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/net_util.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/common/database/database_identifier.h"
 #include "storage/common/quota/quota_status_code.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
 bool DeleteDir(const base::FilePath& path) {
   return base::DeleteFile(path, true /* recursive */);
 }
 
 void DeleteOriginDidDeleteDir(
     const storage::QuotaClient::DeletionCallback& callback,
     bool rv) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   callback.Run(rv ? storage::kQuotaStatusOk : storage::kQuotaErrorAbort);
 }
 
-std::set<GURL> ListOriginsOnDisk(base::FilePath root_path_) {
+std::set<GURL> ListOriginsOnDisk(base::FilePath root_path) {
   std::set<GURL> origins;
-  base::FileEnumerator file_enum(root_path_, false /* recursive */,
+  base::FileEnumerator file_enum(root_path, false /* recursive */,
                                  base::FileEnumerator::DIRECTORIES);
 
   base::FilePath path;
   while (!(path = file_enum.Next()).empty()) {
     std::string protobuf;
     base::ReadFileToString(path.AppendASCII(CacheStorage::kIndexFileName),
                            &protobuf);
 
     CacheStorageIndex index;
     if (index.ParseFromString(protobuf)) {
       if (index.has_origin())
         origins.insert(GURL(index.origin()));
     }
   }
 
   return origins;
 }
 
+std::vector<CacheStorageUsageInfo> GetAllOriginsUsageOnTaskRunner(
+    const base::FilePath root_path) {
+  std::vector<CacheStorageUsageInfo> entries;
+  const std::set<GURL> origins = ListOriginsOnDisk(root_path);
+  entries.reserve(origins.size());
+  for (const GURL& origin : origins) {
+    base::FilePath path =
+        CacheStorageManager::ConstructOriginPath(root_path, origin);
+    int64 size = base::ComputeDirectorySize(path);
+    base::File::Info file_info;
+    base::Time last_modified;
+    if (base::GetFileInfo(path, &file_info))
+      last_modified = file_info.last_modified;
+    entries.push_back(CacheStorageUsageInfo(origin, size, last_modified));
+  }
+  return entries;
+}
+
 void GetOriginsForHostDidListOrigins(
     const std::string& host,
     const storage::QuotaClient::GetOriginsCallback& callback,
     const std::set<GURL>& origins) {
   std::set<GURL> out_origins;
   for (const GURL& origin : origins) {
     if (host == net::GetHostOrSpecFromURL(origin))
       out_origins.insert(origin);
   }
   callback.Run(out_origins);
 }
 
+void EmptyQuotaStatusCallback(storage::QuotaStatusCode code) {}
+
 }  // namespace
 
 // static
 scoped_ptr<CacheStorageManager> CacheStorageManager::Create(
     const base::FilePath& path,
     const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy) {
   base::FilePath root_path = path;
   if (!path.empty()) {
     root_path = path.Append(ServiceWorkerContextCore::kServiceWorkerDirectory)
@@ skipping 90 matching lines @@
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(cache_storage_map_.empty());
   DCHECK(!request_context_getter_ ||
          request_context_getter_.get() == request_context_getter.get());
   DCHECK(!blob_context_ || blob_context_.get() == blob_storage_context.get());
   request_context_getter_ = request_context_getter;
   blob_context_ = blob_storage_context;
 }
 
+void CacheStorageManager::GetAllOriginsUsage(
+    const CacheStorageContext::GetUsageInfoCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (IsMemoryBacked()) {
+    std::vector<CacheStorageUsageInfo> entries;
+    entries.reserve(cache_storage_map_.size());
+    for (const auto& origin_details : cache_storage_map_) {
+      entries.push_back(CacheStorageUsageInfo(
+          origin_details.first, origin_details.second->MemoryBackedSize(),
+          base::Time()));
+    }
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(callback, entries));
+    return;
+  }
+
+  PostTaskAndReplyWithResult(
+      cache_task_runner_.get(), FROM_HERE,
+      base::Bind(&GetAllOriginsUsageOnTaskRunner, root_path_),
+      base::Bind(callback));
+}
+
 void CacheStorageManager::GetOriginUsage(
     const GURL& origin_url,
     const storage::QuotaClient::GetUsageCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (IsMemoryBacked()) {
-    int64 sum = 0;
-    for (const auto& key_value : cache_storage_map_)
-      sum += key_value.second->MemoryBackedSize();
-    callback.Run(sum);
+    int64 usage = 0;
+    if (ContainsKey(cache_storage_map_, origin_url))
+      usage = cache_storage_map_[origin_url]->MemoryBackedSize();
+    callback.Run(usage);
     return;
   }
 
   MigrateOrigin(origin_url);
   PostTaskAndReplyWithResult(
       cache_task_runner_.get(), FROM_HERE,
       base::Bind(base::ComputeDirectorySize,
                  ConstructOriginPath(root_path_, origin_url)),
       base::Bind(callback));
 }
@@ skipping 43 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   CacheStorage* cache_storage = FindOrCreateCacheStorage(origin);
   cache_storage_map_.erase(origin);
   cache_storage->CloseAllCaches(
       base::Bind(&CacheStorageManager::DeleteOriginDidClose, origin, callback,
                  base::Passed(make_scoped_ptr(cache_storage)),
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
+void CacheStorageManager::DeleteOriginData(const GURL& origin) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DeleteOriginData(origin, base::Bind(&EmptyQuotaStatusCallback));
+}
+
 // static
 void CacheStorageManager::DeleteOriginDidClose(
     const GURL& origin,
     const storage::QuotaClient::DeletionCallback& callback,
     scoped_ptr<CacheStorage> cache_storage,
     base::WeakPtr<CacheStorageManager> cache_manager) {
   // TODO(jkarlin): Deleting the storage leaves any unfinished operations
   // hanging, resulting in unresolved promises. Fix this by guaranteeing that
   // callbacks are called in ServiceWorkerStorage.
   cache_storage.reset();
@@ skipping 85 matching lines @@
     const base::FilePath& old_path,
     const base::FilePath& new_path) {
   if (base::PathExists(old_path)) {
     if (!base::PathExists(new_path))
       base::Move(old_path, new_path);
     base::DeleteFile(old_path, /*recursive*/ true);
   }
 }
 
 }  // namespace content