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

chrome/browser/browsing_data/cookies_tree_model.h

 // 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.
 
 #ifndef CHROME_BROWSER_BROWSING_DATA_COOKIES_TREE_MODEL_H_
 #define CHROME_BROWSER_BROWSING_DATA_COOKIES_TREE_MODEL_H_
 
 // TODO(viettrungluu): This header file #includes far too much and has too much
 // inline code (which shouldn't be inline).
 
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browsing_data/browsing_data_appcache_helper.h"
+#include "chrome/browser/browsing_data/browsing_data_cache_storage_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_database_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_file_system_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_indexed_db_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_local_storage_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_quota_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_service_worker_helper.h"
 #include "chrome/browser/browsing_data/local_data_container.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "net/ssl/channel_id_store.h"
 #include "ui/base/models/tree_node_model.h"
 
 class BrowsingDataChannelIDHelper;
 class BrowsingDataCookieHelper;
 class CookiesTreeModel;
 class CookieTreeAppCacheNode;
 class CookieTreeAppCachesNode;
+class CookieTreeCacheStorageNode;
+class CookieTreeCacheStoragesNode;
 class CookieTreeChannelIDNode;
 class CookieTreeChannelIDsNode;
 class CookieTreeCookieNode;
 class CookieTreeCookiesNode;
 class CookieTreeDatabaseNode;
 class CookieTreeDatabasesNode;
 class CookieTreeFileSystemNode;
 class CookieTreeFileSystemsNode;
 class CookieTreeFlashLSONode;
 class CookieTreeHostNode;
@@ skipping 47 matching lines @@
       TYPE_APPCACHE,          // This is used for CookieTreeAppCacheNode.
       TYPE_INDEXED_DBS,       // This is used for CookieTreeIndexedDBsNode.
       TYPE_INDEXED_DB,        // This is used for CookieTreeIndexedDBNode.
       TYPE_FILE_SYSTEMS,      // This is used for CookieTreeFileSystemsNode.
       TYPE_FILE_SYSTEM,       // This is used for CookieTreeFileSystemNode.
       TYPE_QUOTA,             // This is used for CookieTreeQuotaNode.
       TYPE_CHANNEL_IDS,       // Used for CookieTreeChannelIDsNode.
       TYPE_CHANNEL_ID,        // Used for CookieTreeChannelIDNode.
       TYPE_SERVICE_WORKERS,   // This is used for CookieTreeServiceWorkersNode.
       TYPE_SERVICE_WORKER,    // This is used for CookieTreeServiceWorkerNode.
+      TYPE_CACHE_STORAGES,    // This is used for CookieTreeCacheStoragesNode.
+      TYPE_CACHE_STORAGE,     // This is used for CookieTreeCacheStorageNode.
       TYPE_FLASH_LSO,         // This is used for CookieTreeFlashLSONode.
     };
 
     DetailedInfo();
     ~DetailedInfo();
 
     DetailedInfo& Init(NodeType type);
     DetailedInfo& InitHost();
     DetailedInfo& InitCookie(const net::CanonicalCookie* cookie);
     DetailedInfo& InitDatabase(
         const BrowsingDataDatabaseHelper::DatabaseInfo* database_info);
     DetailedInfo& InitLocalStorage(
         const BrowsingDataLocalStorageHelper::LocalStorageInfo*
         local_storage_info);
     DetailedInfo& InitSessionStorage(
         const BrowsingDataLocalStorageHelper::LocalStorageInfo*
         session_storage_info);
     DetailedInfo& InitAppCache(const GURL& origin,
                                const content::AppCacheInfo* appcache_info);
     DetailedInfo& InitIndexedDB(
         const content::IndexedDBInfo* indexed_db_info);
     DetailedInfo& InitFileSystem(
         const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info);
     DetailedInfo& InitQuota(
         const BrowsingDataQuotaHelper::QuotaInfo* quota_info);
     DetailedInfo& InitChannelID(
         const net::ChannelIDStore::ChannelID* channel_id);
     DetailedInfo& InitServiceWorker(
         const content::ServiceWorkerUsageInfo* service_worker_info);
+    DetailedInfo& InitCacheStorage(
+        const content::CacheStorageUsageInfo* cache_storage_info);
     DetailedInfo& InitFlashLSO(const std::string& flash_lso_domain);
 
     NodeType node_type;
     GURL origin;
     const net::CanonicalCookie* cookie;
     const BrowsingDataDatabaseHelper::DatabaseInfo* database_info;
     const BrowsingDataLocalStorageHelper::LocalStorageInfo* local_storage_info;
     const BrowsingDataLocalStorageHelper::LocalStorageInfo*
         session_storage_info;
     const content::AppCacheInfo* appcache_info;
     const content::IndexedDBInfo* indexed_db_info;
     const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info;
     const BrowsingDataQuotaHelper::QuotaInfo* quota_info;
     const net::ChannelIDStore::ChannelID* channel_id;
     const content::ServiceWorkerUsageInfo* service_worker_info;
+    const content::CacheStorageUsageInfo* cache_storage_info;
     std::string flash_lso_domain;
   };
 
   CookieTreeNode() {}
   explicit CookieTreeNode(const base::string16& title)
       : ui::TreeNode<CookieTreeNode>(title) {}
   ~CookieTreeNode() override {}
 
   // Delete backend storage for this node, and any children nodes. (E.g. delete
   // the cookie from CookieMonster, clear the database, and so forth.)
@@ skipping 47 matching lines @@
   // CookieTreeHostNode methods:
   CookieTreeCookiesNode* GetOrCreateCookiesNode();
   CookieTreeDatabasesNode* GetOrCreateDatabasesNode();
   CookieTreeLocalStoragesNode* GetOrCreateLocalStoragesNode();
   CookieTreeSessionStoragesNode* GetOrCreateSessionStoragesNode();
   CookieTreeAppCachesNode* GetOrCreateAppCachesNode();
   CookieTreeIndexedDBsNode* GetOrCreateIndexedDBsNode();
   CookieTreeFileSystemsNode* GetOrCreateFileSystemsNode();
   CookieTreeChannelIDsNode* GetOrCreateChannelIDsNode();
   CookieTreeServiceWorkersNode* GetOrCreateServiceWorkersNode();
+  CookieTreeCacheStoragesNode* GetOrCreateCacheStoragesNode();
   CookieTreeQuotaNode* UpdateOrCreateQuotaNode(
       std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info);
   CookieTreeFlashLSONode* GetOrCreateFlashLSONode(const std::string& domain);
 
   std::string canonicalized_host() const { return canonicalized_host_; }
 
   // Creates an content exception for this origin of type
   // CONTENT_SETTINGS_TYPE_COOKIES.
   void CreateContentException(content_settings::CookieSettings* cookie_settings,
                               ContentSetting setting) const;
@@ skipping 12 matching lines @@
   CookieTreeCookiesNode* cookies_child_;
   CookieTreeDatabasesNode* databases_child_;
   CookieTreeLocalStoragesNode* local_storages_child_;
   CookieTreeSessionStoragesNode* session_storages_child_;
   CookieTreeAppCachesNode* appcaches_child_;
   CookieTreeIndexedDBsNode* indexed_dbs_child_;
   CookieTreeFileSystemsNode* file_systems_child_;
   CookieTreeQuotaNode* quota_child_;
   CookieTreeChannelIDsNode* channel_ids_child_;
   CookieTreeServiceWorkersNode* service_workers_child_;
+  CookieTreeCacheStoragesNode* cache_storages_child_;
   CookieTreeFlashLSONode* flash_lso_child_;
 
   // The URL for which this node was initially created.
   GURL url_;
 
   std::string canonicalized_host_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeHostNode);
 };
 
@@ skipping 351 matching lines @@
   DetailedInfo GetDetailedInfo() const override;
 
   void AddServiceWorkerNode(CookieTreeServiceWorkerNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeServiceWorkersNode);
 };
 
+// CookieTreeCacheStorageNode -----------------------------------------------
+class CookieTreeCacheStorageNode : public CookieTreeNode {
+ public:
+  // cache_storage_info should remain valid at least as long as the
+  // CookieTreeCacheStorageNode is valid.
+  explicit CookieTreeCacheStorageNode(
+      std::list<content::CacheStorageUsageInfo>::iterator cache_storage_info);
+  ~CookieTreeCacheStorageNode() override;
+
+  // CookieTreeNode methods:
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
+
+ private:
+  // cache_storage_info_ is expected to remain valid as long as the
+  // CookieTreeCacheStorageNode is valid.
+  std::list<content::CacheStorageUsageInfo>::iterator cache_storage_info_;
+
+  DISALLOW_COPY_AND_ASSIGN(CookieTreeCacheStorageNode);
+};
+
+class CookieTreeCacheStoragesNode : public CookieTreeNode {
+ public:
+  CookieTreeCacheStoragesNode();
+  ~CookieTreeCacheStoragesNode() override;
+
+  DetailedInfo GetDetailedInfo() const override;
+
+  void AddCacheStorageNode(CookieTreeCacheStorageNode* child) {
+    AddChildSortedByTitle(child);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CookieTreeCacheStoragesNode);
+};
+
 // CookieTreeFlashLSONode ----------------------------------------------------
 class CookieTreeFlashLSONode : public CookieTreeNode {
  public:
   explicit CookieTreeFlashLSONode(const std::string& domain);
   ~CookieTreeFlashLSONode() override;
 
   // CookieTreeNode methods:
   void DeleteStoredObjects() override;
   DetailedInfo GetDetailedInfo() const override;
 
@@ skipping 84 matching lines @@
   void PopulateAppCacheInfo(LocalDataContainer* container);
   void PopulateCookieInfo(LocalDataContainer* container);
   void PopulateDatabaseInfo(LocalDataContainer* container);
   void PopulateLocalStorageInfo(LocalDataContainer* container);
   void PopulateSessionStorageInfo(LocalDataContainer* container);
   void PopulateIndexedDBInfo(LocalDataContainer* container);
   void PopulateFileSystemInfo(LocalDataContainer* container);
   void PopulateQuotaInfo(LocalDataContainer* container);
   void PopulateChannelIDInfo(LocalDataContainer* container);
   void PopulateServiceWorkerUsageInfo(LocalDataContainer* container);
+  void PopulateCacheStorageUsageInfo(LocalDataContainer* container);
   void PopulateFlashLSOInfo(LocalDataContainer* container);
 
   BrowsingDataCookieHelper* GetCookieHelper(const std::string& app_id);
   LocalDataContainer* data_container() {
     return data_container_.get();
   }
 
   // Set the number of |batches_expected| this class should expect to receive.
   // If |reset| is true, then this is a new set of batches, but if false, then
   // this is a revised number (batches originally counted should no longer be
@@ skipping 50 matching lines @@
                                    ScopedBatchUpdateNotifier* notifier,
                                    const base::string16& filter);
   void PopulateChannelIDInfoWithFilter(
       LocalDataContainer* container,
       ScopedBatchUpdateNotifier* notifier,
       const base::string16& filter);
   void PopulateServiceWorkerUsageInfoWithFilter(
       LocalDataContainer* container,
       ScopedBatchUpdateNotifier* notifier,
       const base::string16& filter);
+  void PopulateCacheStorageUsageInfoWithFilter(
+      LocalDataContainer* container,
+      ScopedBatchUpdateNotifier* notifier,
+      const base::string16& filter);
   void PopulateFlashLSOInfoWithFilter(LocalDataContainer* container,
                                       ScopedBatchUpdateNotifier* notifier,
                                       const base::string16& filter);
 
   // Map of app ids to LocalDataContainer objects to use when retrieving
   // locally stored data.
   scoped_ptr<LocalDataContainer> data_container_;
 
 #if defined(ENABLE_EXTENSIONS)
   // The extension special storage policy; see ExtensionsProtectingNode() above.
@@ skipping 17 matching lines @@
 
   // Counts how many batches have started already. If this is non-zero and lower
   // than batches_ended_, then this model is still batching updates.
   int batches_started_;
 
   // Counts how many batches have finished.
   int batches_ended_;
 };
 
 #endif  // CHROME_BROWSER_BROWSING_DATA_COOKIES_TREE_MODEL_H_