Wrapping blocked filesystems into TabSpecificContentSettings

chrome/browser/cookies_tree_model.cc

 // 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.
 
 #include "chrome/browser/cookies_tree_model.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
@@ skipping 50 matching lines @@
   // model, and tell CookieMonster to delete the cookies. We can keep the
   // vector storing the cookies in-tact and not delete from there (that would
   // invalidate our pointers), and the fact that it contains semi out-of-date
   // data is not problematic as we don't re-build the model based on that.
   GetModel()->cookie_monster_->DeleteCanonicalCookie(*cookie_);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeCookieNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_COOKIE,
-                      cookie_, NULL, NULL, NULL, NULL, NULL);
+                      cookie_, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 namespace {
 // comparison functor, for use in CookieTreeRootNode
 class OriginNodeComparator {
  public:
   bool operator() (const CookieTreeNode* lhs,
                    const CookieTreeNode* rhs) {
     // We want to order by registry controlled domain, so we would get
     // google.com, ad.google.com, www.google.com,
@@ skipping 59 matching lines @@
 
 void CookieTreeAppCacheNode::DeleteStoredObjects() {
   DCHECK(GetModel()->appcache_helper_);
   GetModel()->appcache_helper_->DeleteAppCacheGroup(
       appcache_info_->manifest_url);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeAppCacheNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_APPCACHE,
-                      NULL, NULL, NULL, NULL, appcache_info_, NULL);
+                      NULL, NULL, NULL, NULL, appcache_info_, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeDatabaseNode, public:
 
 CookieTreeDatabaseNode::CookieTreeDatabaseNode(
     BrowsingDataDatabaseHelper::DatabaseInfo* database_info)
     : CookieTreeNode(database_info->database_name.empty() ?
           l10n_util::GetStringUTF16(IDS_COOKIES_WEB_DATABASE_UNNAMED_NAME) :
           UTF8ToUTF16(database_info->database_name)),
       database_info_(database_info) {
 }
 
 CookieTreeDatabaseNode::~CookieTreeDatabaseNode() {}
 
 void CookieTreeDatabaseNode::DeleteStoredObjects() {
   GetModel()->database_helper_->DeleteDatabase(
       database_info_->origin_identifier, database_info_->database_name);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeDatabaseNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_DATABASE,
-                      NULL, database_info_, NULL, NULL, NULL, NULL);
+                      NULL, database_info_, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeLocalStorageNode, public:
 
 CookieTreeLocalStorageNode::CookieTreeLocalStorageNode(
     BrowsingDataLocalStorageHelper::LocalStorageInfo* local_storage_info)
     : CookieTreeNode(UTF8ToUTF16(
           local_storage_info->origin.empty() ?
               local_storage_info->database_identifier :
               local_storage_info->origin)),
       local_storage_info_(local_storage_info) {
 }
 
 CookieTreeLocalStorageNode::~CookieTreeLocalStorageNode() {}
 
 void CookieTreeLocalStorageNode::DeleteStoredObjects() {
   GetModel()->local_storage_helper_->DeleteLocalStorageFile(
       local_storage_info_->file_path);
 }
 
 CookieTreeNode::DetailedInfo
 CookieTreeLocalStorageNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_LOCAL_STORAGE,
-                      NULL, NULL, local_storage_info_, NULL, NULL, NULL);
+                      NULL, NULL, local_storage_info_, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeSessionStorageNode, public:
 
 CookieTreeSessionStorageNode::CookieTreeSessionStorageNode(
     BrowsingDataLocalStorageHelper::LocalStorageInfo* session_storage_info)
     : CookieTreeNode(UTF8ToUTF16(
           session_storage_info->origin.empty() ?
               session_storage_info->database_identifier :
               session_storage_info->origin)),
       session_storage_info_(session_storage_info) {
 }
 
 CookieTreeSessionStorageNode::~CookieTreeSessionStorageNode() {}
 
 CookieTreeNode::DetailedInfo
 CookieTreeSessionStorageNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_SESSION_STORAGE,
-                      NULL, NULL, NULL, session_storage_info_, NULL, NULL);
+                      NULL, NULL, NULL, session_storage_info_, NULL, NULL,
+                      NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeIndexedDBNode, public:
 
 CookieTreeIndexedDBNode::CookieTreeIndexedDBNode(
     BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info)
     : CookieTreeNode(UTF8ToUTF16(
           indexed_db_info->origin.empty() ?
               indexed_db_info->database_identifier :
               indexed_db_info->origin)),
       indexed_db_info_(indexed_db_info) {
 }
 
 CookieTreeIndexedDBNode::~CookieTreeIndexedDBNode() {}
 
 void CookieTreeIndexedDBNode::DeleteStoredObjects() {
   GetModel()->indexed_db_helper_->DeleteIndexedDBFile(
       indexed_db_info_->file_path);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeIndexedDBNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_INDEXED_DB,
-                      NULL, NULL, NULL, NULL, NULL, indexed_db_info_);
+                      NULL, NULL, NULL, NULL, NULL, indexed_db_info_, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// CookieTreeFileSystemNode, public:
+
+CookieTreeFileSystemNode::CookieTreeFileSystemNode(
+    BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info)
+    : CookieTreeNode(UTF8ToUTF16(
+          file_system_info->origin.spec())),
+      file_system_info_(file_system_info) {
+}
+
+CookieTreeFileSystemNode::~CookieTreeFileSystemNode() {}
+
+void CookieTreeFileSystemNode::DeleteStoredObjects() {
+  GetModel()->file_system_helper_->DeleteFileSystemOrigin(
+      file_system_info_->origin);
+}
+
+CookieTreeNode::DetailedInfo CookieTreeFileSystemNode::GetDetailedInfo() const {
+  return DetailedInfo(parent()->parent()->GetTitle(),
+                      DetailedInfo::TYPE_FILE_SYSTEM,
+                      NULL, NULL, NULL, NULL, NULL, NULL, file_system_info_);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // CookieTreeRootNode, public:
 
 CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model)
     : model_(model) {
 }
 
 CookieTreeRootNode::~CookieTreeRootNode() {}
 
 CookieTreeOriginNode* CookieTreeRootNode::GetOrCreateOriginNode(
     const GURL& url) {
@@ skipping 18 matching lines @@
   return retval;
 }
 
 CookiesTreeModel* CookieTreeRootNode::GetModel() const {
   return model_;
 }
 
 CookieTreeNode::DetailedInfo CookieTreeRootNode::GetDetailedInfo() const {
   return DetailedInfo(string16(),
                       DetailedInfo::TYPE_ROOT,
-                      NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeOriginNode, public:
 
 // static
 std::wstring CookieTreeOriginNode::TitleForUrl(
     const GURL& url) {
   return UTF8ToWide(url.SchemeIsFile() ? kFileOriginNodeName : url.host());
 }
 
 CookieTreeOriginNode::CookieTreeOriginNode(const GURL& url)
     : CookieTreeNode(WideToUTF16Hack(TitleForUrl(url))),
       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),
       url_(url) {}
 
 CookieTreeOriginNode::~CookieTreeOriginNode() {}
 
 CookieTreeNode::DetailedInfo CookieTreeOriginNode::GetDetailedInfo() const {
   return DetailedInfo(GetTitle(),
                       DetailedInfo::TYPE_ORIGIN,
-                      NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 CookieTreeCookiesNode* CookieTreeOriginNode::GetOrCreateCookiesNode() {
   if (cookies_child_)
     return cookies_child_;
   cookies_child_ = new CookieTreeCookiesNode;
   AddChildSortedByTitle(cookies_child_);
   return cookies_child_;
 }
 
@@ skipping 32 matching lines @@
 }
 
 CookieTreeIndexedDBsNode* CookieTreeOriginNode::GetOrCreateIndexedDBsNode() {
   if (indexed_dbs_child_)
     return indexed_dbs_child_;
   indexed_dbs_child_ = new CookieTreeIndexedDBsNode;
   AddChildSortedByTitle(indexed_dbs_child_);
   return indexed_dbs_child_;
 }
 
+CookieTreeFileSystemsNode* CookieTreeOriginNode::GetOrCreateFileSystemsNode() {
+  if (file_systems_child_)
+    return file_systems_child_;
+  file_systems_child_ = new CookieTreeFileSystemsNode;
+  AddChildSortedByTitle(file_systems_child_);
+  return file_systems_child_;
+}
+
 void CookieTreeOriginNode::CreateContentException(
     HostContentSettingsMap* content_settings, ContentSetting setting) const {
   if (CanCreateContentException()) {
     content_settings->AddExceptionForURL(url_,
                                          CONTENT_SETTINGS_TYPE_COOKIES,
                                          "",
                                          setting);
   }
 }
 
 bool CookieTreeOriginNode::CanCreateContentException() const {
   return !url_.SchemeIsFile();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeCookiesNode, public:
 
 CookieTreeCookiesNode::CookieTreeCookiesNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_COOKIES)) {
 }
 
 CookieTreeCookiesNode::~CookieTreeCookiesNode() {
 }
 
 CookieTreeNode::DetailedInfo CookieTreeCookiesNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_COOKIES,
-                      NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeAppCachesNode, public:
 
 CookieTreeAppCachesNode::CookieTreeAppCachesNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(
                          IDS_COOKIES_APPLICATION_CACHES)) {
 }
 
 CookieTreeAppCachesNode::~CookieTreeAppCachesNode() {}
 
 CookieTreeNode::DetailedInfo CookieTreeAppCachesNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_APPCACHES,
-                      NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeDatabasesNode, public:
 
 CookieTreeDatabasesNode::CookieTreeDatabasesNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_WEB_DATABASES)) {
 }
 
 CookieTreeDatabasesNode::~CookieTreeDatabasesNode() {}
 
 CookieTreeNode::DetailedInfo CookieTreeDatabasesNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_DATABASES,
-                      NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeLocalStoragesNode, public:
 
 CookieTreeLocalStoragesNode::CookieTreeLocalStoragesNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_LOCAL_STORAGE)) {
 }
 
 CookieTreeLocalStoragesNode::~CookieTreeLocalStoragesNode() {}
 
 CookieTreeNode::DetailedInfo
 CookieTreeLocalStoragesNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_LOCAL_STORAGES,
-                      NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeSessionStoragesNode, public:
 
 CookieTreeSessionStoragesNode::CookieTreeSessionStoragesNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_SESSION_STORAGE)) {
 }
 
 CookieTreeSessionStoragesNode::~CookieTreeSessionStoragesNode() {}
 
 CookieTreeNode::DetailedInfo
 CookieTreeSessionStoragesNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_SESSION_STORAGES,
-                      NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeIndexedDBsNode, public:
 
 CookieTreeIndexedDBsNode::CookieTreeIndexedDBsNode()
     : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_INDEXED_DBS)) {
 }
 
 CookieTreeIndexedDBsNode::~CookieTreeIndexedDBsNode() {}
 
 CookieTreeNode::DetailedInfo
 CookieTreeIndexedDBsNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->GetTitle(),
                       DetailedInfo::TYPE_INDEXED_DBS,
-                      NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// CookieTreeFileSystemsNode, public:
+
+CookieTreeFileSystemsNode::CookieTreeFileSystemsNode()
+    : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_FILE_SYSTEMS)) {
+}
+
+CookieTreeFileSystemsNode::~CookieTreeFileSystemsNode() {}
+
+CookieTreeNode::DetailedInfo
+CookieTreeFileSystemsNode::GetDetailedInfo() const {
+  return DetailedInfo(parent()->GetTitle(),
+                      DetailedInfo::TYPE_FILE_SYSTEMS,
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // CookieTreeNode, protected
 
 bool CookieTreeNode::NodeTitleComparator::operator() (
     const CookieTreeNode* lhs, const CookieTreeNode* rhs) {
   const CookieTreeNode* left =
       static_cast<const CookieTreeNode*>(lhs);
   const CookieTreeNode* right =
       static_cast<const CookieTreeNode*>(rhs);
   return (left->GetTitle() < right->GetTitle());
 }
 
 void CookieTreeNode::AddChildSortedByTitle(CookieTreeNode* new_child) {
+  DCHECK(new_child);
   std::vector<CookieTreeNode*>::iterator iter =
       lower_bound(children().begin(),
                   children().end(),
                   new_child,
                   NodeTitleComparator());
   GetModel()->Add(this, new_child, iter - children().begin());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookiesTreeModel, public:
 
 CookiesTreeModel::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)
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui::TreeNodeModel<CookieTreeNode>(
           new CookieTreeRootNode(this))),
       cookie_monster_(cookie_monster),
       appcache_helper_(appcache_helper),
       database_helper_(database_helper),
       local_storage_helper_(local_storage_helper),
       session_storage_helper_(session_storage_helper),
       indexed_db_helper_(indexed_db_helper),
+      file_system_helper_(file_system_helper),
       batch_update_(0),
       use_cookie_source_(use_cookie_source) {
   LoadCookies();
   DCHECK(database_helper_);
   database_helper_->StartFetching(NewCallback(
       this, &CookiesTreeModel::OnDatabaseModelInfoLoaded));
   DCHECK(local_storage_helper_);
   local_storage_helper_->StartFetching(NewCallback(
       this, &CookiesTreeModel::OnLocalStorageModelInfoLoaded));
   if (session_storage_helper_) {
     session_storage_helper_->StartFetching(NewCallback(
         this, &CookiesTreeModel::OnSessionStorageModelInfoLoaded));
   }
 
   // TODO(michaeln): when all of the ui impls have been updated,
   // make this a required parameter.
   if (appcache_helper_) {
     appcache_helper_->StartFetching(NewCallback(
         this, &CookiesTreeModel::OnAppCacheModelInfoLoaded));
   }
 
   if (indexed_db_helper_) {
     indexed_db_helper_->StartFetching(NewCallback(
         this, &CookiesTreeModel::OnIndexedDBModelInfoLoaded));
   }
+
+  if (file_system_helper_) {
+    file_system_helper_->StartFetching(NewCallback(
+        this, &CookiesTreeModel::OnFileSystemModelInfoLoaded));
+  }
 }
 
 CookiesTreeModel::~CookiesTreeModel() {
   database_helper_->CancelNotification();
   local_storage_helper_->CancelNotification();
   if (session_storage_helper_)
     session_storage_helper_->CancelNotification();
   if (appcache_helper_)
     appcache_helper_->CancelNotification();
   if (indexed_db_helper_)
     indexed_db_helper_->CancelNotification();
+  if (file_system_helper_)
+    file_system_helper_->CancelNotification();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookiesTreeModel, TreeModel methods (public):
 
 // 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.
 void CookiesTreeModel::GetIcons(std::vector<SkBitmap>* icons) {
   icons->push_back(*ResourceBundle::GetSharedInstance().GetBitmapNamed(
@@ skipping 17 matching lines @@
     case CookieTreeNode::DetailedInfo::TYPE_DATABASE:
       return DATABASE;
     case CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE:
       return DATABASE;  // close enough
     case CookieTreeNode::DetailedInfo::TYPE_SESSION_STORAGE:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_APPCACHE:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB:
       return DATABASE;  // ditto
+    case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM:
+      return DATABASE;  // ditto
     default:
       break;
   }
   return -1;
 }
 
 void CookiesTreeModel::LoadCookies() {
   LoadCookiesWithFilter(std::wstring());
 }
 
@@ skipping 240 matching lines @@
       CookieTreeIndexedDBsNode* indexed_dbs_node =
           origin_node->GetOrCreateIndexedDBsNode();
       indexed_dbs_node->AddIndexedDBNode(
           new CookieTreeIndexedDBNode(&(*indexed_db_info)));
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
+void CookiesTreeModel::OnFileSystemModelInfoLoaded(
+    const FileSystemInfoList& file_system_info) {
+  file_system_info_list_ = file_system_info;
+  PopulateFileSystemInfoWithFilter(std::wstring());
+}
+
+void CookiesTreeModel::PopulateFileSystemInfoWithFilter(
+    const std::wstring& filter) {
+  if (file_system_info_list_.empty())
+    return;
+  CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
+  NotifyObserverBeginBatch();
+  for (FileSystemInfoList::iterator file_system_info =
+       file_system_info_list_.begin();
+       file_system_info != file_system_info_list_.end();
+       ++file_system_info) {
+    GURL origin(file_system_info->origin);
+
+    if (!filter.size() ||
+        (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
+         std::wstring::npos)) {
+      CookieTreeOriginNode* origin_node =
+          root->GetOrCreateOriginNode(origin);
+      CookieTreeFileSystemsNode* file_systems_node =
+          origin_node->GetOrCreateFileSystemsNode();
+      file_systems_node->AddFileSystemNode(
+          new CookieTreeFileSystemNode(&(*file_system_info)));
+    }
+  }
+  NotifyObserverTreeNodeChanged(root);
+  NotifyObserverEndBatch();
+}
+
 void CookiesTreeModel::NotifyObserverBeginBatch() {
   // Only notify the model once if we're batching in a nested manner.
   if (batch_update_++ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelBeginBatch(this));
   }
 }
 
 void CookiesTreeModel::NotifyObserverEndBatch() {
   // Only notify the observers if this is the outermost call to EndBatch() if
   // called in a nested manner.
   if (--batch_update_ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelEndBatch(this));
   }
 }