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

chrome/browser/browsing_data/cookies_tree_model.cc

 // Copyright (c) 2012 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 "chrome/browser/browsing_data/cookies_tree_model.h"
 
 #include <algorithm>
 #include <functional>
 #include <map>
 #include <vector>
@@ skipping 120 matching lines @@
     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_QUOTA:
       return false;
     case CookieTreeNode::DetailedInfo::TYPE_CHANNEL_ID:
       return false;
     case CookieTreeNode::DetailedInfo::TYPE_SERVICE_WORKER:
       return true;
+    case CookieTreeNode::DetailedInfo::TYPE_CACHE_STORAGE:
+      return true;
     case CookieTreeNode::DetailedInfo::TYPE_FLASH_LSO:
       return false;
     default:
       break;
   }
   return false;
 }
 #endif
 
 // This function returns the local data container associated with a leaf tree
@@ skipping 14 matching lines @@
     : node_type(TYPE_NONE),
       cookie(NULL),
       database_info(NULL),
       local_storage_info(NULL),
       session_storage_info(NULL),
       appcache_info(NULL),
       indexed_db_info(NULL),
       file_system_info(NULL),
       quota_info(NULL),
       channel_id(NULL),
-      service_worker_info(NULL) {
-}
+      service_worker_info(NULL),
+      cache_storage_info(NULL) {}
 
 CookieTreeNode::DetailedInfo::~DetailedInfo() {}
 
 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::Init(
     NodeType type) {
   DCHECK_EQ(TYPE_NONE, node_type);
   node_type = type;
   return *this;
 }
 
@@ skipping 75 matching lines @@
 }
 
 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitServiceWorker(
     const content::ServiceWorkerUsageInfo* service_worker_info) {
   Init(TYPE_SERVICE_WORKER);
   this->service_worker_info = service_worker_info;
   this->origin = service_worker_info->origin;
   return *this;
 }
 
+CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitCacheStorage(
+    const content::CacheStorageUsageInfo* cache_storage_info) {
+  Init(TYPE_CACHE_STORAGE);
+  this->cache_storage_info = cache_storage_info;
+  this->origin = cache_storage_info->origin;
+  return *this;
+}
+
 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitFlashLSO(
     const std::string& flash_lso_domain) {
   Init(TYPE_FLASH_LSO);
   this->flash_lso_domain = flash_lso_domain;
   return *this;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeNode, public:
 
@@ skipping 272 matching lines @@
     container->service_worker_info_list_.erase(service_worker_info_);
   }
 }
 
 CookieTreeNode::DetailedInfo CookieTreeServiceWorkerNode::GetDetailedInfo()
     const {
   return DetailedInfo().InitServiceWorker(&*service_worker_info_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// CookieTreeCacheStorageNode, public:
+
+CookieTreeCacheStorageNode::CookieTreeCacheStorageNode(
+    std::list<content::CacheStorageUsageInfo>::iterator cache_storage_info)
+    : CookieTreeNode(base::UTF8ToUTF16(cache_storage_info->origin.spec())),
+      cache_storage_info_(cache_storage_info) {}
+
+CookieTreeCacheStorageNode::~CookieTreeCacheStorageNode() {}
+
+void CookieTreeCacheStorageNode::DeleteStoredObjects() {
+  LocalDataContainer* container = GetLocalDataContainerForNode(this);
+
+  if (container) {
+    container->cache_storage_helper_->DeleteCacheStorage(
+        cache_storage_info_->origin);
+    container->cache_storage_info_list_.erase(cache_storage_info_);
+  }
+}
+
+CookieTreeNode::DetailedInfo CookieTreeCacheStorageNode::GetDetailedInfo()
+    const {
+  return DetailedInfo().InitCacheStorage(&*cache_storage_info_);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // CookieTreeRootNode, public:
 
 CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model)
     : model_(model) {
 }
 
 CookieTreeRootNode::~CookieTreeRootNode() {}
 
 CookieTreeHostNode* CookieTreeRootNode::GetOrCreateHostNode(
     const GURL& url) {
@@ skipping 39 matching lines @@
       cookies_child_(NULL),
       databases_child_(NULL),
       local_storages_child_(NULL),
       session_storages_child_(NULL),
       appcaches_child_(NULL),
       indexed_dbs_child_(NULL),
       file_systems_child_(NULL),
       quota_child_(NULL),
       channel_ids_child_(NULL),
       service_workers_child_(NULL),
+      cache_storages_child_(NULL),
       flash_lso_child_(NULL),
       url_(url),
-      canonicalized_host_(CanonicalizeHost(url)) {
-}
+      canonicalized_host_(CanonicalizeHost(url)) {}
 
 CookieTreeHostNode::~CookieTreeHostNode() {}
 
 const std::string CookieTreeHostNode::GetHost() const {
   const std::string file_origin_node_name(
       std::string(url::kFileScheme) + url::kStandardSchemeSeparator);
   return url_.SchemeIsFile() ? file_origin_node_name : url_.host();
 }
 
 CookieTreeNode::DetailedInfo CookieTreeHostNode::GetDetailedInfo() const {
@@ skipping 78 matching lines @@
 
 CookieTreeServiceWorkersNode*
 CookieTreeHostNode::GetOrCreateServiceWorkersNode() {
   if (service_workers_child_)
     return service_workers_child_;
   service_workers_child_ = new CookieTreeServiceWorkersNode;
   AddChildSortedByTitle(service_workers_child_);
   return service_workers_child_;
 }
 
+CookieTreeCacheStoragesNode*
+CookieTreeHostNode::GetOrCreateCacheStoragesNode() {
+  if (cache_storages_child_)
+    return cache_storages_child_;
+  cache_storages_child_ = new CookieTreeCacheStoragesNode;
+  AddChildSortedByTitle(cache_storages_child_);
+  return cache_storages_child_;
+}
+
 CookieTreeFlashLSONode* CookieTreeHostNode::GetOrCreateFlashLSONode(
     const std::string& domain) {
   DCHECK_EQ(GetHost(), domain);
   if (flash_lso_child_)
     return flash_lso_child_;
   flash_lso_child_ = new CookieTreeFlashLSONode(domain);
   AddChildSortedByTitle(flash_lso_child_);
   return flash_lso_child_;
 }
 
@@ skipping 146 matching lines @@
 
 CookieTreeServiceWorkersNode::~CookieTreeServiceWorkersNode() {
 }
 
 CookieTreeNode::DetailedInfo CookieTreeServiceWorkersNode::GetDetailedInfo()
     const {
   return DetailedInfo().Init(DetailedInfo::TYPE_SERVICE_WORKERS);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// CookieTreeCacheStoragesNode, public:
+
+CookieTreeCacheStoragesNode::CookieTreeCacheStoragesNode()
+    : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_CACHE_STORAGE)) {}
+
+CookieTreeCacheStoragesNode::~CookieTreeCacheStoragesNode() {}
+
+CookieTreeNode::DetailedInfo CookieTreeCacheStoragesNode::GetDetailedInfo()
+    const {
+  return DetailedInfo().Init(DetailedInfo::TYPE_CACHE_STORAGES);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // CookieTreeFlashLSONode
 CookieTreeFlashLSONode::CookieTreeFlashLSONode(
     const std::string& domain)
     : domain_(domain) {}
 CookieTreeFlashLSONode::~CookieTreeFlashLSONode() {}
 
 void CookieTreeFlashLSONode::DeleteStoredObjects() {
   // We are one level below the host node.
   CookieTreeHostNode* host = static_cast<CookieTreeHostNode*>(parent());
   CHECK_EQ(host->GetDetailedInfo().node_type,
@@ skipping 102 matching lines @@
     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_QUOTA:
       return -1;
     case CookieTreeNode::DetailedInfo::TYPE_CHANNEL_ID:
       return COOKIE;  // It's kinda like a cookie?
     case CookieTreeNode::DetailedInfo::TYPE_SERVICE_WORKER:
       return DATABASE;  // Just like appcache
+    case CookieTreeNode::DetailedInfo::TYPE_CACHE_STORAGE:
+      return DATABASE;  // ditto
     default:
       break;
   }
   return -1;
 }
 
 void CookiesTreeModel::DeleteAllStoredObjects() {
   NotifyObserverBeginBatch();
   CookieTreeNode* root = GetRoot();
   root->DeleteStoredObjects();
@@ skipping 26 matching lines @@
   PopulateCookieInfoWithFilter(data_container(), &notifier, filter);
   PopulateDatabaseInfoWithFilter(data_container(), &notifier, filter);
   PopulateLocalStorageInfoWithFilter(data_container(), &notifier, filter);
   PopulateSessionStorageInfoWithFilter(data_container(), &notifier, filter);
   PopulateAppCacheInfoWithFilter(data_container(), &notifier, filter);
   PopulateIndexedDBInfoWithFilter(data_container(), &notifier, filter);
   PopulateFileSystemInfoWithFilter(data_container(), &notifier, filter);
   PopulateQuotaInfoWithFilter(data_container(), &notifier, filter);
   PopulateChannelIDInfoWithFilter(data_container(), &notifier, filter);
   PopulateServiceWorkerUsageInfoWithFilter(data_container(), &notifier, filter);
+  PopulateCacheStorageUsageInfoWithFilter(data_container(), &notifier, filter);
 }
 
 #if defined(ENABLE_EXTENSIONS)
 const extensions::ExtensionSet* CookiesTreeModel::ExtensionsProtectingNode(
     const CookieTreeNode& cookie_node) {
   if (!special_storage_policy_.get())
     return NULL;
 
   CookieTreeNode::DetailedInfo info = cookie_node.GetDetailedInfo();
 
@@ skipping 64 matching lines @@
   PopulateChannelIDInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateServiceWorkerUsageInfo(
     LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateServiceWorkerUsageInfoWithFilter(
       container, &notifier, base::string16());
 }
 
+void CookiesTreeModel::PopulateCacheStorageUsageInfo(
+    LocalDataContainer* container) {
+  ScopedBatchUpdateNotifier notifier(this, GetRoot());
+  PopulateCacheStorageUsageInfoWithFilter(container, &notifier,
+                                          base::string16());
+}
+
 void CookiesTreeModel::PopulateFlashLSOInfo(
       LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateFlashLSOInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateAppCacheInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
@@ skipping 216 matching lines @@
                                .find(filter) != base::string16::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeServiceWorkersNode* service_workers_node =
           host_node->GetOrCreateServiceWorkersNode();
       service_workers_node->AddServiceWorkerNode(
           new CookieTreeServiceWorkerNode(service_worker_info));
     }
   }
 }
 
+void CookiesTreeModel::PopulateCacheStorageUsageInfoWithFilter(
+    LocalDataContainer* container,
+    ScopedBatchUpdateNotifier* notifier,
+    const base::string16& filter) {
+  CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
+
+  if (container->cache_storage_info_list_.empty())
+    return;
+
+  notifier->StartBatchUpdate();
+  for (CacheStorageUsageInfoList::iterator cache_storage_info =
+           container->cache_storage_info_list_.begin();
+       cache_storage_info != container->cache_storage_info_list_.end();
+       ++cache_storage_info) {
+    const GURL& origin = cache_storage_info->origin;
+
+    if (filter.empty() || (CookieTreeHostNode::TitleForUrl(origin)
+                               .find(filter) != base::string16::npos)) {
+      CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
+      CookieTreeCacheStoragesNode* cache_storages_node =
+          host_node->GetOrCreateCacheStoragesNode();
+      cache_storages_node->AddCacheStorageNode(
+          new CookieTreeCacheStorageNode(cache_storage_info));
+    }
+  }
+}
+
 void CookiesTreeModel::PopulateFileSystemInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->file_system_info_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
@@ skipping 91 matching lines @@
 void CookiesTreeModel::MaybeNotifyBatchesEnded() {
   // Only notify the observers if this is the outermost call to EndBatch() if
   // called in a nested manner.
   if (batches_ended_ == batches_started_ &&
       batches_seen_ == batches_expected_) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelEndBatch(this));
   }
 }