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_
 
 // 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/browser/local_data_container.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 CookieTreeFileSystemNode;
 class CookieTreeFileSystemsNode;
+class CookieTreeHostNode;
 class CookieTreeIndexedDBNode;
 class CookieTreeIndexedDBsNode;
 class CookieTreeLocalStorageNode;
 class CookieTreeLocalStoragesNode;
-class CookieTreeOriginNode;
 class CookieTreeQuotaNode;
 class CookieTreeServerBoundCertNode;
 class CookieTreeServerBoundCertsNode;
 class CookieTreeSessionStorageNode;
 class CookieTreeSessionStoragesNode;
-
+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& InitOrigin(const std::string& app_id,
-                             const std::string& app_name) {
-      Init(TYPE_ORIGIN);
-      this->app_name = app_name;
-      this->app_id = app_id;
-      return *this;
-    }
-
+    DetailedInfo& Init(NodeType type);
+    DetailedInfo& InitHost(const std::string& app_id,
+                           const std::string& app_name);
     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;
-    }
-
-    DetailedInfo& InitAppCache(const appcache::AppCacheInfo* appcache_info) {
-      Init(TYPE_APPCACHE);
-      this->appcache_info = appcache_info;
-      return *this;
-    }
-
+        session_storage_info);
+    DetailedInfo& InitAppCache(const GURL& origin,
+                               const appcache::AppCacheInfo* appcache_info);
     DetailedInfo& InitIndexedDB(
-        const BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info) {
-      Init(TYPE_INDEXED_DB);
-      this->indexed_db_info = indexed_db_info;
-      return *this;
-    }
-
+        const BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info);
     DetailedInfo& InitFileSystem(
-        const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info) {
-      Init(TYPE_FILE_SYSTEM);
-      this->file_system_info = file_system_info;
-      return *this;
-    }
-
+        const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info);
     DetailedInfo& InitQuota(
-        const BrowsingDataQuotaHelper::QuotaInfo* quota_info) {
-      Init(TYPE_QUOTA);
-      this->quota_info = quota_info;
-      return *this;
-    }
-
+        const BrowsingDataQuotaHelper::QuotaInfo* quota_info);
     DetailedInfo& InitServerBoundCert(
-        const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert) {
-      Init(TYPE_SERVER_BOUND_CERT);
-      this->server_bound_cert = server_bound_cert;
-      return *this;
-    }
+        const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert);
 
     std::string app_name;
     std::string app_id;
-    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,
-                                              const std::string& app_id,
-                                              const std::string& app_name);
+  CookieTreeHostNode* GetOrCreateHostNode(const GURL& url,
+                                          const std::string& app_id,
+                                          const std::string& app_name);
 
   // 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.
+  // Returns the host node's title to use for a given URL.
   static string16 TitleForUrl(const GURL& url,
                               const std::string& app_id,
                               const std::string& app_name);
 
-  explicit CookieTreeOriginNode(const GURL& url,
-                                const std::string& app_id,
-                                const std::string& app_name);
-  virtual ~CookieTreeOriginNode();
+  explicit CookieTreeHostNode(const GURL& url,
+                              const std::string& app_id,
+                              const std::string& app_name);
+  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);
 
+  std::string canonicalized_host() const { return canonicalized_host_; }
+
   // Creates an content exception for this origin of type
   // CONTENT_SETTINGS_TYPE_COOKIES.
   void CreateContentException(CookieSettings* cookie_settings,
                               ContentSetting setting) const;
 
   // True if a content exception can be created for this origin.
   bool CanCreateContentException() const;
 
   const std::string& app_id() const { return app_id_; }
   const std::string& app_name() const { return app_name_; }
@@ skipping 14 matching lines @@
   CookieTreeFileSystemsNode* file_systems_child_;
   CookieTreeQuotaNode* quota_child_;
   CookieTreeServerBoundCertsNode* server_bound_certs_child_;
 
   std::string app_id_;
   std::string app_name_;
 
   // The URL for which this node was initially created.
   GURL url_;
 
-  DISALLOW_COPY_AND_ASSIGN(CookieTreeOriginNode);
+  std::string canonicalized_host_;
+
+  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 312 matching lines @@
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeServerBoundCertsNode);
 };
 
 // CookiesTreeModel -----------------------------------------------------------
 class CookiesTreeModel : public ui::TreeNodeModel<CookieTreeNode> {
  public:
-  CookiesTreeModel(const ContainerMap& apps_map, bool group_by_cookie_source);
+  CookiesTreeModel(const ContainerMap& apps_map,
+                   ExtensionSpecialStoragePolicy* special_storage_policy,
+                   bool group_by_cookie_source);
   virtual ~CookiesTreeModel();
 
   // Because non-cookie nodes are fetched in a background thread, they are not
   // present at the time the Model is created. The Model then notifies its
   // observers for every item added from databases, local storage, and
   // appcache. We extend the Observer interface to add notifications before and
   // after these batch inserts.
   class Observer : public ui::TreeModelObserver {
    public:
     virtual void TreeModelBeginBatch(CookiesTreeModel* model) {}
@@ skipping 30 matching lines @@
   // CookiesTreeModel methods:
   void DeleteAllStoredObjects();
 
   // Deletes a specific node in the tree, identified by |cookie_node|, and its
   // subtree.
   void DeleteCookieNode(CookieTreeNode* cookie_node);
 
   // Filter the origins to only display matched results.
   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);
 
   // Methods that update the model based on the data retrieved by the browsing
   // data helpers.
   void PopulateAppCacheInfo(LocalDataContainer* container);
@@ skipping 45 matching lines @@
                                    const string16& filter);
   void PopulateServerBoundCertInfoWithFilter(
       LocalDataContainer* container,
       ScopedBatchUpdateNotifier* notifier,
       const string16& filter);
 
   // Map of app ids to LocalDataContainer objects to use when retrieving
   // locally stored data.
   ContainerMap app_data_map_;
 
+  // The extension special storage policy; see ExtensionsProtectingNode() above.
+  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 true, use the CanonicalCookie::Source attribute to group cookies.
   // Otherwise, use the CanonicalCookie::Domain attribute.
   bool group_by_cookie_source_;
 
   // 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_;
 };
 
 #endif  // CHROME_BROWSER_COOKIES_TREE_MODEL_H_