Show apps protecting local data in chrome://settings/cookies.

chrome/browser/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_COOKIES_TREE_MODEL_H_
 #define CHROME_BROWSER_COOKIES_TREE_MODEL_H_
 #pragma once
 
 // 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/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browsing_data_appcache_helper.h"
 #include "chrome/browser/browsing_data_database_helper.h"
 #include "chrome/browser/browsing_data_file_system_helper.h"
 #include "chrome/browser/browsing_data_indexed_db_helper.h"
 #include "chrome/browser/browsing_data_local_storage_helper.h"
 #include "chrome/browser/browsing_data_quota_helper.h"
 #include "chrome/common/content_settings.h"
+#include "chrome/common/extensions/extension_set.h"
 #include "net/base/server_bound_cert_store.h"
 #include "net/cookies/cookie_monster.h"
 #include "ui/base/models/tree_node_model.h"
 
 class BrowsingDataCookieHelper;
 class BrowsingDataServerBoundCertHelper;
 class CookieSettings;
 class CookiesTreeModel;
 class CookieTreeAppCacheNode;
 class CookieTreeAppCachesNode;
 class CookieTreeCookieNode;
 class CookieTreeCookiesNode;
 class CookieTreeDatabaseNode;
 class CookieTreeDatabasesNode;
 class CookieTreeFileSystemsNode;
 class CookieTreeFileSystemNode;
 class CookieTreeLocalStorageNode;
 class CookieTreeLocalStoragesNode;
 class CookieTreeServerBoundCertNode;
 class CookieTreeServerBoundCertsNode;
 class CookieTreeQuotaNode;
 class CookieTreeSessionStorageNode;
 class CookieTreeSessionStoragesNode;
 class CookieTreeIndexedDBNode;
 class CookieTreeIndexedDBsNode;
-class CookieTreeOriginNode;
+class CookieTreeHostNode;
+class ExtensionSpecialStoragePolicy;
 
 // CookieTreeNode -------------------------------------------------------------
 // The base node type in the Cookies, Databases, and Local Storage options
 // view, from which all other types are derived. Specialized from TreeNode in
 // that it has a notion of deleting objects stored in the profile, and being
 // able to have its children do the same.
 class CookieTreeNode : public ui::TreeNode<CookieTreeNode> {
  public:
   // Used to pull out information for the InfoView (the details display below
   // the tree control.)
   struct DetailedInfo {
     // NodeType corresponds to the various CookieTreeNode types.
     enum NodeType {
       TYPE_NONE,
       TYPE_ROOT,  // This is used for CookieTreeRootNode nodes.
-      TYPE_ORIGIN,  // This is used for CookieTreeOriginNode nodes.
+      TYPE_HOST,  // This is used for CookieTreeHostNode nodes.
       TYPE_COOKIES,  // This is used for CookieTreeCookiesNode nodes.
       TYPE_COOKIE,  // This is used for CookieTreeCookieNode nodes.
       TYPE_DATABASES,  // This is used for CookieTreeDatabasesNode.
       TYPE_DATABASE,  // This is used for CookieTreeDatabaseNode.
       TYPE_LOCAL_STORAGES,  // This is used for CookieTreeLocalStoragesNode.
       TYPE_LOCAL_STORAGE,  // This is used for CookieTreeLocalStorageNode.
       TYPE_SESSION_STORAGES,  // This is used for CookieTreeSessionStoragesNode.
       TYPE_SESSION_STORAGE,  // This is used for CookieTreeSessionStorageNode.
       TYPE_APPCACHES,  // This is used for CookieTreeAppCachesNode.
       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_SERVER_BOUND_CERTS, // Used for CookieTreeServerBoundCertsNode.
       TYPE_SERVER_BOUND_CERT, // Used for CookieTreeServerBoundCertNode.
     };
 
-    // TODO(viettrungluu): Figure out whether we want to store |origin| as a
-    // |string16| or a (UTF-8) |std::string|, and convert.
-    explicit DetailedInfo(const string16& origin)
-        : origin(origin),
-          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),
-          server_bound_cert(NULL) {}
+    DetailedInfo();
+    ~DetailedInfo();
 
-    DetailedInfo& Init(NodeType type) {
-      DCHECK_EQ(TYPE_NONE, node_type);
-      node_type = type;
-      return *this;
-    }
-
+    DetailedInfo& Init(NodeType type);
     DetailedInfo& InitCookie(
-        const net::CookieMonster::CanonicalCookie* cookie) {
-      Init(TYPE_COOKIE);
-      this->cookie = cookie;
-      return *this;
-    }
-
+        const net::CookieMonster::CanonicalCookie* cookie);
     DetailedInfo& InitDatabase(
-        const BrowsingDataDatabaseHelper::DatabaseInfo* database_info) {
-      Init(TYPE_DATABASE);
-      this->database_info = database_info;
-      return *this;
-    }
-
+        const BrowsingDataDatabaseHelper::DatabaseInfo* database_info);
     DetailedInfo& InitLocalStorage(
         const BrowsingDataLocalStorageHelper::LocalStorageInfo*
-        local_storage_info) {
-      Init(TYPE_LOCAL_STORAGE);
-      this->local_storage_info = local_storage_info;
-      return *this;
-    }
-
+        local_storage_info);
     DetailedInfo& InitSessionStorage(
         const BrowsingDataLocalStorageHelper::LocalStorageInfo*
-        session_storage_info) {
-      Init(TYPE_SESSION_STORAGE);
-      this->session_storage_info = session_storage_info;
-      return *this;
-    }
+        session_storage_info);
+    DetailedInfo& InitAppCache(const GURL& origin,
+                               const appcache::AppCacheInfo* appcache_info);
+    DetailedInfo& InitIndexedDB(
+        const BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info);
+    DetailedInfo& InitFileSystem(
+        const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info);
+    DetailedInfo& InitQuota(
+        const BrowsingDataQuotaHelper::QuotaInfo* quota_info);
+    DetailedInfo& InitServerBoundCert(
+        const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert);
 
-    DetailedInfo& InitAppCache(const appcache::AppCacheInfo* appcache_info) {
-      Init(TYPE_APPCACHE);
-      this->appcache_info = appcache_info;
-      return *this;
-    }
-
-    DetailedInfo& InitIndexedDB(
-        const BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info) {
-      Init(TYPE_INDEXED_DB);
-      this->indexed_db_info = indexed_db_info;
-      return *this;
-    }
-
-    DetailedInfo& InitFileSystem(
-        const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info) {
-      Init(TYPE_FILE_SYSTEM);
-      this->file_system_info = file_system_info;
-      return *this;
-    }
-
-    DetailedInfo& InitQuota(
-        const BrowsingDataQuotaHelper::QuotaInfo* quota_info) {
-      Init(TYPE_QUOTA);
-      this->quota_info = quota_info;
-      return *this;
-    }
-
-    DetailedInfo& InitServerBoundCert(
-        const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert) {
-      Init(TYPE_SERVER_BOUND_CERT);
-      this->server_bound_cert = server_bound_cert;
-      return *this;
-    }
-
-    string16 origin;
     NodeType node_type;
+    GURL origin;
     const net::CookieMonster::CanonicalCookie* cookie;
     const BrowsingDataDatabaseHelper::DatabaseInfo* database_info;
     const BrowsingDataLocalStorageHelper::LocalStorageInfo* local_storage_info;
     const BrowsingDataLocalStorageHelper::LocalStorageInfo*
         session_storage_info;
     const appcache::AppCacheInfo* appcache_info;
     const BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info;
     const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info;
     const BrowsingDataQuotaHelper::QuotaInfo* quota_info;
     const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert;
@@ skipping 12 matching lines @@
   virtual CookiesTreeModel* GetModel() const;
 
   // Returns a struct with detailed information used to populate the details
   // part of the view.
   virtual DetailedInfo GetDetailedInfo() const = 0;
 
  protected:
   void AddChildSortedByTitle(CookieTreeNode* new_child);
 
  private:
-
   DISALLOW_COPY_AND_ASSIGN(CookieTreeNode);
 };
 
 // CookieTreeRootNode ---------------------------------------------------------
 // The node at the root of the CookieTree that gets inserted into the view.
 class CookieTreeRootNode : public CookieTreeNode {
  public:
   explicit CookieTreeRootNode(CookiesTreeModel* model);
   virtual ~CookieTreeRootNode();
 
-  CookieTreeOriginNode* GetOrCreateOriginNode(const GURL& url);
+  CookieTreeHostNode* GetOrCreateHostNode(const GURL& url);
 
   // CookieTreeNode methods:
   virtual CookiesTreeModel* GetModel() const OVERRIDE;
   virtual DetailedInfo GetDetailedInfo() const OVERRIDE;
 
  private:
   CookiesTreeModel* model_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeRootNode);
 };
 
-// CookieTreeOriginNode -------------------------------------------------------
-class CookieTreeOriginNode : public CookieTreeNode {
+// CookieTreeHostNode -------------------------------------------------------
+class CookieTreeHostNode : public CookieTreeNode {
  public:
-  // Returns the origin node's title to use for a given URL.
-  static std::wstring TitleForUrl(const GURL& url);
+  // Returns the host node's title to use for a given URL.
+  static string16 TitleForUrl(const GURL& url);
 
-  explicit CookieTreeOriginNode(const GURL& url);
-  virtual ~CookieTreeOriginNode();
+  explicit CookieTreeHostNode(const GURL& url);
+  virtual ~CookieTreeHostNode();
 
   // CookieTreeNode methods:
   virtual DetailedInfo GetDetailedInfo() const OVERRIDE;
 
-  // CookieTreeOriginNode methods:
+  // CookieTreeHostNode methods:
   CookieTreeCookiesNode* GetOrCreateCookiesNode();
   CookieTreeDatabasesNode* GetOrCreateDatabasesNode();
   CookieTreeLocalStoragesNode* GetOrCreateLocalStoragesNode();
   CookieTreeSessionStoragesNode* GetOrCreateSessionStoragesNode();
   CookieTreeAppCachesNode* GetOrCreateAppCachesNode();
   CookieTreeIndexedDBsNode* GetOrCreateIndexedDBsNode();
   CookieTreeFileSystemsNode* GetOrCreateFileSystemsNode();
   CookieTreeServerBoundCertsNode* GetOrCreateServerBoundCertsNode();
   CookieTreeQuotaNode* UpdateOrCreateQuotaNode(
       std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info);
@@ skipping 18 matching lines @@
   CookieTreeSessionStoragesNode* session_storages_child_;
   CookieTreeAppCachesNode* appcaches_child_;
   CookieTreeIndexedDBsNode* indexed_dbs_child_;
   CookieTreeFileSystemsNode* file_systems_child_;
   CookieTreeQuotaNode* quota_child_;
   CookieTreeServerBoundCertsNode* server_bound_certs_child_;
 
   // The URL for which this node was initially created.
   GURL url_;
 
-  DISALLOW_COPY_AND_ASSIGN(CookieTreeOriginNode);
+  DISALLOW_COPY_AND_ASSIGN(CookieTreeHostNode);
 };
 
 // CookieTreeCookieNode ------------------------------------------------------
 class CookieTreeCookieNode : public CookieTreeNode {
  public:
   friend class CookieTreeCookiesNode;
 
   // The cookie should remain valid at least as long as the
   // CookieTreeCookieNode is valid.
   explicit CookieTreeCookieNode(
@@ skipping 333 matching lines @@
   CookiesTreeModel(
       BrowsingDataCookieHelper* cookie_helper,
       BrowsingDataDatabaseHelper* database_helper,
       BrowsingDataLocalStorageHelper* local_storage_helper,
       BrowsingDataLocalStorageHelper* session_storage_helper,
       BrowsingDataAppCacheHelper* appcache_helper,
       BrowsingDataIndexedDBHelper* indexed_db_helper,
       BrowsingDataFileSystemHelper* file_system_helper,
       BrowsingDataQuotaHelper* quota_helper,
       BrowsingDataServerBoundCertHelper* server_bound_cert_helper,
+      ExtensionSpecialStoragePolicy* special_storage_policy,
       bool use_cookie_source);
   virtual ~CookiesTreeModel();
 
   // ui::TreeModel methods:
   // Returns the set of icons for the nodes in the tree. You only need override
   // this if you don't want to use the default folder icons.
   virtual void GetIcons(std::vector<gfx::ImageSkia>* icons) OVERRIDE;
 
   // Returns the index of the icon to use for |node|. Return -1 to use the
   // default icon. The index is relative to the list of icons returned from
   // GetIcons.
   virtual int GetIconIndex(ui::TreeModelNode* node) OVERRIDE;
 
   // CookiesTreeModel methods:
   void DeleteAllStoredObjects();
   void DeleteCookieNode(CookieTreeNode* cookie_node);
 
   // Filter the origins to only display matched results.
-  void UpdateSearchResults(const std::wstring& filter);
+  void UpdateSearchResults(const string16& filter);
+
+  // Returns the set of extensions which protect the data item represented by
+  // this node from deletion.
+  // Returns NULL if the node doesn't represent a protected data item or the
+  // special storage policy is NULL.
+  const ExtensionSet* ExtensionsProtectingNode(
+      const CookieTreeNode& cookie_node);
 
   // Manages CookiesTreeModel::Observers. This will also call
   // TreeNodeModel::AddObserver so that it gets all the proper notifications.
   // Note that the converse is not true: simply adding a TreeModelObserver will
   // not get CookiesTreeModel::Observer notifications.
   virtual void AddCookiesTreeObserver(Observer* observer);
   virtual void RemoveCookiesTreeObserver(Observer* observer);
 
  private:
   enum CookieIconIndex {
@@ skipping 22 matching lines @@
       const LocalStorageInfoList& local_storage_info);
   void OnSessionStorageModelInfoLoaded(
       const LocalStorageInfoList& local_storage_info);
   void OnIndexedDBModelInfoLoaded(
       const IndexedDBInfoList& indexed_db_info);
   void OnFileSystemModelInfoLoaded(
       const FileSystemInfoList& file_system_info);
   void OnQuotaModelInfoLoaded(const QuotaInfoArray& quota_info);
   void OnServerBoundCertModelInfoLoaded(const ServerBoundCertList& cert_list);
 
-  void PopulateAppCacheInfoWithFilter(const std::wstring& filter);
-  void PopulateCookieInfoWithFilter(const std::wstring& filter);
-  void PopulateDatabaseInfoWithFilter(const std::wstring& filter);
-  void PopulateLocalStorageInfoWithFilter(const std::wstring& filter);
-  void PopulateSessionStorageInfoWithFilter(const std::wstring& filter);
-  void PopulateIndexedDBInfoWithFilter(const std::wstring& filter);
-  void PopulateFileSystemInfoWithFilter(const std::wstring& filter);
-  void PopulateQuotaInfoWithFilter(const std::wstring& filter);
-  void PopulateServerBoundCertInfoWithFilter(const std::wstring& filter);
+  void PopulateAppCacheInfoWithFilter(const string16& filter);
+  void PopulateCookieInfoWithFilter(const string16& filter);
+  void PopulateDatabaseInfoWithFilter(const string16& filter);
+  void PopulateLocalStorageInfoWithFilter(const string16& filter);
+  void PopulateSessionStorageInfoWithFilter(const string16& filter);
+  void PopulateIndexedDBInfoWithFilter(const string16& filter);
+  void PopulateFileSystemInfoWithFilter(const string16& filter);
+  void PopulateQuotaInfoWithFilter(const string16& filter);
+  void PopulateServerBoundCertInfoWithFilter(const string16& filter);
 
   void NotifyObserverBeginBatch();
   void NotifyObserverEndBatch();
 
   scoped_refptr<BrowsingDataAppCacheHelper> appcache_helper_;
   scoped_refptr<BrowsingDataCookieHelper> cookie_helper_;
   scoped_refptr<BrowsingDataDatabaseHelper> database_helper_;
   scoped_refptr<BrowsingDataLocalStorageHelper> local_storage_helper_;
   scoped_refptr<BrowsingDataLocalStorageHelper> session_storage_helper_;
   scoped_refptr<BrowsingDataIndexedDBHelper> indexed_db_helper_;
   scoped_refptr<BrowsingDataFileSystemHelper> file_system_helper_;
   scoped_refptr<BrowsingDataQuotaHelper> quota_helper_;
   scoped_refptr<BrowsingDataServerBoundCertHelper> server_bound_cert_helper_;
 
   std::map<GURL, std::list<appcache::AppCacheInfo> > appcache_info_;
   CookieList cookie_list_;
   DatabaseInfoList database_info_list_;
   LocalStorageInfoList local_storage_info_list_;
   LocalStorageInfoList session_storage_info_list_;
   IndexedDBInfoList indexed_db_info_list_;
   FileSystemInfoList file_system_info_list_;
   QuotaInfoArray quota_info_list_;
   ServerBoundCertList server_bound_cert_list_;
+  scoped_refptr<ExtensionSpecialStoragePolicy> special_storage_policy_;
 
   // The CookiesTreeModel maintains a separate list of observers that are
   // specifically of the type CookiesTreeModel::Observer.
   ObserverList<Observer> cookies_observer_list_;
 
   // If this is non-zero, then this model is batching updates (there's a lot of
   // notifications coming down the pipe). This is an integer is used to balance
   // calls to Begin/EndBatch() if they're called in a nested manner.
   int batch_update_;
 
@@ skipping 10 matching lines @@
   friend class CookieTreeSessionStorageNode;
   friend class CookieTreeIndexedDBNode;
   friend class CookieTreeFileSystemNode;
   friend class CookieTreeQuotaNode;
   friend class CookieTreeServerBoundCertNode;
 
   DISALLOW_COPY_AND_ASSIGN(CookiesTreeModel);
 };
 
 #endif  // CHROME_BROWSER_COOKIES_TREE_MODEL_H_