Wrapping blocked filesystems into TabSpecificContentSettings

chrome/browser/cookies_tree_model.h

 // Copyright (c) 2011 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 <string>
 #include <vector>
 
 #include "base/memory/ref_counted.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/common/content_settings.h"
 #include "net/base/cookie_monster.h"
 #include "ui/base/models/tree_node_model.h"
 
 class CookiesTreeModel;
 class CookieTreeAppCacheNode;
 class CookieTreeAppCachesNode;
 class CookieTreeCookieNode;
 class CookieTreeCookiesNode;
 class CookieTreeDatabaseNode;
 class CookieTreeDatabasesNode;
+class CookieTreeFileSystemsNode;
+class CookieTreeFileSystemNode;
 class CookieTreeLocalStorageNode;
 class CookieTreeLocalStoragesNode;
 class CookieTreeSessionStorageNode;
 class CookieTreeSessionStoragesNode;
 class CookieTreeIndexedDBNode;
 class CookieTreeIndexedDBsNode;
 class CookieTreeOriginNode;
 class HostContentSettingsMap;
 
 // CookieTreeNode -------------------------------------------------------------
@@ skipping 15 matching lines @@
       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.
     };
 
     // TODO(viettrungluu): Figure out whether we want to store |origin| as a
     // |string16| or a (UTF-8) |std::string|, and convert. Remove constructor
     // taking an |std::wstring|.
     DetailedInfo(const string16& origin, NodeType node_type,
         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 BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info,
+        const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info)
         : origin(UTF16ToWideHack(origin)),
           node_type(node_type),
           cookie(cookie),
           database_info(database_info),
           local_storage_info(local_storage_info),
           session_storage_info(session_storage_info),
           appcache_info(appcache_info),
-          indexed_db_info(indexed_db_info) {
+          indexed_db_info(indexed_db_info),
+          file_system_info(file_system_info) {
       DCHECK((node_type != TYPE_DATABASE) || database_info);
       DCHECK((node_type != TYPE_LOCAL_STORAGE) || local_storage_info);
       DCHECK((node_type != TYPE_SESSION_STORAGE) || session_storage_info);
       DCHECK((node_type != TYPE_APPCACHE) || appcache_info);
       DCHECK((node_type != TYPE_INDEXED_DB) || indexed_db_info);
+      DCHECK((node_type != TYPE_FILE_SYSTEM) || file_system_info);
     }
 #if !defined(WCHAR_T_IS_UTF16)
     DetailedInfo(const std::wstring& origin, NodeType node_type,
         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 BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info,
+        const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info)
         : origin(origin),
           node_type(node_type),
           cookie(cookie),
           database_info(database_info),
           local_storage_info(local_storage_info),
           session_storage_info(session_storage_info),
           appcache_info(appcache_info),
-          indexed_db_info(indexed_db_info) {
+          indexed_db_info(indexed_db_info),
+          file_system_info(file_system_info) {
       DCHECK((node_type != TYPE_DATABASE) || database_info);
       DCHECK((node_type != TYPE_LOCAL_STORAGE) || local_storage_info);
       DCHECK((node_type != TYPE_SESSION_STORAGE) || session_storage_info);
       DCHECK((node_type != TYPE_APPCACHE) || appcache_info);
       DCHECK((node_type != TYPE_INDEXED_DB) || indexed_db_info);
+      DCHECK((node_type != TYPE_FILE_SYSTEM) || file_system_info);
     }
 #endif
 
     std::wstring origin;
     NodeType node_type;
     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;
   };
 
   CookieTreeNode() {}
   explicit CookieTreeNode(const string16& title)
       : ui::TreeNode<CookieTreeNode>(title) {}
   virtual ~CookieTreeNode() {}
 
   // Delete backend storage for this node, and any children nodes. (E.g. delete
   // the cookie from CookieMonster, clear the database, and so forth.)
   virtual void DeleteStoredObjects();
@@ skipping 49 matching lines @@
   // CookieTreeNode methods:
   virtual DetailedInfo GetDetailedInfo() const;
 
   // CookieTreeOriginNode methods:
   CookieTreeCookiesNode* GetOrCreateCookiesNode();
   CookieTreeDatabasesNode* GetOrCreateDatabasesNode();
   CookieTreeLocalStoragesNode* GetOrCreateLocalStoragesNode();
   CookieTreeSessionStoragesNode* GetOrCreateSessionStoragesNode();
   CookieTreeAppCachesNode* GetOrCreateAppCachesNode();
   CookieTreeIndexedDBsNode* GetOrCreateIndexedDBsNode();
+  CookieTreeFileSystemsNode* GetOrCreateFileSystemsNode();
 
   // Creates an content exception for this origin of type
   // CONTENT_SETTINGS_TYPE_COOKIES.
   void CreateContentException(HostContentSettingsMap* content_settings,
                               ContentSetting setting) const;
 
   // True if a content exception can be created for this origin.
   bool CanCreateContentException() const;
 
  private:
   // Pointers to the cookies, databases, local and session storage and appcache
   // nodes.  When we build up the tree we need to quickly get a reference to
   // the COOKIES node to add children. Checking each child and interrogating
   // them to see if they are a COOKIES, APPCACHES, DATABASES etc node seems
   // less preferable than storing an extra pointer per origin.
   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_;
 
   // The URL for which this node was initially created.
   GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeOriginNode);
 };
 
 // CookieTreeCookieNode ------------------------------------------------------
 class CookieTreeCookieNode : public CookieTreeNode {
  public:
@@ skipping 95 matching lines @@
   virtual DetailedInfo GetDetailedInfo() const;
 
   void AddDatabaseNode(CookieTreeDatabaseNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeDatabasesNode);
 };
 
+// CookieTreeFileSystemNode --------------------------------------------------
+class CookieTreeFileSystemNode : public CookieTreeNode {
+ public:
+  friend class CookieTreeFileSystemsNode;
+
+  // Does not take ownership of file_system_info, and file_system_info should
+  // remain valid at least as long as the CookieTreeFileSystemNode is valid.
+  explicit CookieTreeFileSystemNode(
+      BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info);
+  virtual ~CookieTreeFileSystemNode();
+
+  virtual void DeleteStoredObjects();
+  virtual DetailedInfo GetDetailedInfo() const;
+
+ private:
+  // file_system_info_ is not owned by the node, and is expected to remain
+  // valid as long as the CookieTreeFileSystemNode is valid.
+  BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info_;
+
+  DISALLOW_COPY_AND_ASSIGN(CookieTreeFileSystemNode);
+};
+
+class CookieTreeFileSystemsNode : public CookieTreeNode {
+ public:
+  CookieTreeFileSystemsNode();
+  virtual ~CookieTreeFileSystemsNode();
+
+  virtual DetailedInfo GetDetailedInfo() const;
+
+  void AddFileSystemNode(CookieTreeFileSystemNode* child) {
+    AddChildSortedByTitle(child);
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CookieTreeFileSystemsNode);
+};
 
 // CookieTreeLocalStorageNode -------------------------------------------------
 class CookieTreeLocalStorageNode : public CookieTreeNode {
  public:
   // Does not take ownership of local_storage_info, and local_storage_info
   // should remain valid at least as long as the CookieTreeLocalStorageNode is
   // valid.
   explicit CookieTreeLocalStorageNode(
       BrowsingDataLocalStorageHelper::LocalStorageInfo* local_storage_info);
   virtual ~CookieTreeLocalStorageNode();
@@ skipping 116 matching lines @@
     virtual void TreeModelEndBatch(CookiesTreeModel* model) {}
   };
 
   CookiesTreeModel(
       net::CookieMonster* cookie_monster_,
       BrowsingDataDatabaseHelper* database_helper,
       BrowsingDataLocalStorageHelper* local_storage_helper,
       BrowsingDataLocalStorageHelper* session_storage_helper,
       BrowsingDataAppCacheHelper* appcache_helper,
       BrowsingDataIndexedDBHelper* indexed_db_helper,
+      BrowsingDataFileSystemHelper* file_system_helper,
       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<SkBitmap>* icons);
 
   // 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
@@ skipping 22 matching lines @@
   };
   typedef net::CookieList CookieList;
   typedef std::vector<BrowsingDataDatabaseHelper::DatabaseInfo>
       DatabaseInfoList;
   typedef std::vector<BrowsingDataLocalStorageHelper::LocalStorageInfo>
       LocalStorageInfoList;
   typedef std::vector<BrowsingDataLocalStorageHelper::LocalStorageInfo>
       SessionStorageInfoList;
   typedef std::vector<BrowsingDataIndexedDBHelper::IndexedDBInfo>
       IndexedDBInfoList;
+  typedef std::vector<BrowsingDataFileSystemHelper::FileSystemInfo>
+      FileSystemInfoList;
 
   void LoadCookies();
   void LoadCookiesWithFilter(const std::wstring& filter);
 
   void OnAppCacheModelInfoLoaded();
   void OnDatabaseModelInfoLoaded(const DatabaseInfoList& database_info);
   void OnLocalStorageModelInfoLoaded(
       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 PopulateAppCacheInfoWithFilter(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 NotifyObserverBeginBatch();
   void NotifyObserverEndBatch();
 
   scoped_refptr<net::CookieMonster> cookie_monster_;
   CookieList all_cookies_;
 
   scoped_refptr<BrowsingDataAppCacheHelper> appcache_helper_;
   scoped_refptr<BrowsingDataDatabaseHelper> database_helper_;
   scoped_refptr<appcache::AppCacheInfoCollection> appcache_info_;
   DatabaseInfoList database_info_list_;
 
   scoped_refptr<BrowsingDataLocalStorageHelper> local_storage_helper_;
   scoped_refptr<BrowsingDataLocalStorageHelper> session_storage_helper_;
   scoped_refptr<BrowsingDataIndexedDBHelper> indexed_db_helper_;
+  scoped_refptr<BrowsingDataFileSystemHelper> file_system_helper_;
   LocalStorageInfoList local_storage_info_list_;
   LocalStorageInfoList session_storage_info_list_;
   IndexedDBInfoList indexed_db_info_list_;
+  FileSystemInfoList file_system_info_list_;
 
   // 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_;
 
   // If true, use the CanonicalCookie::Source attribute to group cookies.
   // Otherwise, use the CanonicalCookie::Domain attribute.
   bool use_cookie_source_;
 
   friend class CookieTreeAppCacheNode;
   friend class CookieTreeCookieNode;
   friend class CookieTreeDatabaseNode;
   friend class CookieTreeLocalStorageNode;
   friend class CookieTreeIndexedDBNode;
+  friend class CookieTreeFileSystemNode;
 
   DISALLOW_COPY_AND_ASSIGN(CookiesTreeModel);
 };
 
 #endif  // CHROME_BROWSER_COOKIES_TREE_MODEL_H_