When deleting storage through the cookies tree model, also update its cache

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 31 matching lines @@
   if (parent())
     return parent()->GetModel();
   else
     return NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeCookieNode, public:
 
 CookieTreeCookieNode::CookieTreeCookieNode(
-    net::CookieMonster::CanonicalCookie* cookie)
+    std::list<net::CookieMonster::CanonicalCookie>::iterator cookie)
     : CookieTreeNode(UTF8ToUTF16(cookie->Name())),
       cookie_(cookie) {
 }
 
 CookieTreeCookieNode::~CookieTreeCookieNode() {}
 
 void CookieTreeCookieNode::DeleteStoredObjects() {
   // notify CookieMonster that we should delete this cookie
   // We have stored a copy of all the cookies in the model, and our model is
   // never re-calculated. Thus, we just need to delete the nodes from our
   // 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.

[Bernhard Bauer, 2011/08/17 13:34:36]

Is this comment still up to date?

   GetModel()->cookie_helper_->DeleteCookie(*cookie_);
+  GetModel()->cookie_list_.erase(cookie_);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeCookieNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_COOKIE,
-                      cookie_, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+                      &*cookie_, NULL, 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 45 matching lines @@
     return retval;
   }
 };
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeAppCacheNode, public:
 
 CookieTreeAppCacheNode::CookieTreeAppCacheNode(
-    const appcache::AppCacheInfo* appcache_info)
+    const GURL& origin_url,
+    std::list<appcache::AppCacheInfo>::iterator appcache_info)
     : CookieTreeNode(UTF8ToUTF16(appcache_info->manifest_url.spec())),
+      origin_url_(origin_url),
       appcache_info_(appcache_info) {
 }
 
 void CookieTreeAppCacheNode::DeleteStoredObjects() {
   DCHECK(GetModel()->appcache_helper_);
   GetModel()->appcache_helper_->DeleteAppCacheGroup(
       appcache_info_->manifest_url);
+  GetModel()->appcache_info_[origin_url_].erase(appcache_info_);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeAppCacheNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_APPCACHE,
-                      NULL, NULL, NULL, NULL, appcache_info_, NULL, NULL, NULL);
+                      NULL, NULL, NULL, NULL, &*appcache_info_,
+                      NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeDatabaseNode, public:
 
 CookieTreeDatabaseNode::CookieTreeDatabaseNode(
-    BrowsingDataDatabaseHelper::DatabaseInfo* database_info)
+    std::list<BrowsingDataDatabaseHelper::DatabaseInfo>::iterator 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);
+  GetModel()->database_info_list_.erase(database_info_);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeDatabaseNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_DATABASE,
-                      NULL, database_info_, NULL, NULL, NULL, NULL, NULL, NULL);
+                      NULL, &*database_info_,
+                      NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeLocalStorageNode, public:
 
 CookieTreeLocalStorageNode::CookieTreeLocalStorageNode(
-    BrowsingDataLocalStorageHelper::LocalStorageInfo* local_storage_info)
+    std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator
+        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);
+  GetModel()->local_storage_info_list_.erase(local_storage_info_);
 }
 
 CookieTreeNode::DetailedInfo
 CookieTreeLocalStorageNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_LOCAL_STORAGE,
-                      NULL, NULL, local_storage_info_, NULL, NULL, NULL, NULL,
+                      NULL, NULL, &*local_storage_info_, NULL, NULL, NULL, NULL,
                       NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeSessionStorageNode, public:
 
 CookieTreeSessionStorageNode::CookieTreeSessionStorageNode(
-    BrowsingDataLocalStorageHelper::LocalStorageInfo* session_storage_info)
+    std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator
+        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() {}
 
+void CookieTreeSessionStorageNode::DeleteStoredObjects() {
+  GetModel()->session_storage_info_list_.erase(session_storage_info_);
+}
+
 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, NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeIndexedDBNode, public:
 
 CookieTreeIndexedDBNode::CookieTreeIndexedDBNode(
-    BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info)
+    std::list<BrowsingDataIndexedDBHelper::IndexedDBInfo>::iterator
+        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);
+  GetModel()->indexed_db_info_list_.erase(indexed_db_info_);
 }
 
 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, NULL, &*indexed_db_info_, NULL,
                       NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeFileSystemNode, public:
 
 CookieTreeFileSystemNode::CookieTreeFileSystemNode(
-    BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info)
+    std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator
+        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);
+  GetModel()->file_system_info_list_.erase(file_system_info_);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeFileSystemNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_FILE_SYSTEM,
-                      NULL, NULL, NULL, NULL, NULL, NULL, file_system_info_,
+                      NULL, NULL, NULL, NULL, NULL, NULL, &*file_system_info_,
                       NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeQuotaNode, public:
 
 CookieTreeQuotaNode::CookieTreeQuotaNode(
-    BrowsingDataQuotaHelper::QuotaInfo* quota_info)
+    std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info)
     : CookieTreeNode(UTF8ToUTF16(quota_info->host)),
       quota_info_(quota_info) {
 }
 
 CookieTreeQuotaNode::~CookieTreeQuotaNode() {}
 
 void CookieTreeQuotaNode::DeleteStoredObjects() {
   GetModel()->quota_helper_->DeleteQuotaHost(quota_info_->host);
+  GetModel()->quota_info_list_.erase(quota_info_);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeQuotaNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_QUOTA,
-                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, quota_info_);
+                      NULL, NULL, NULL, NULL, NULL, NULL, NULL, &*quota_info_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeRootNode, public:
 
 CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model)
     : model_(model) {
 }
 
 CookieTreeRootNode::~CookieTreeRootNode() {}
@@ skipping 112 matching lines @@
 
 CookieTreeFileSystemsNode* CookieTreeOriginNode::GetOrCreateFileSystemsNode() {
   if (file_systems_child_)
     return file_systems_child_;
   file_systems_child_ = new CookieTreeFileSystemsNode;
   AddChildSortedByTitle(file_systems_child_);
   return file_systems_child_;
 }
 
 CookieTreeQuotaNode* CookieTreeOriginNode::UpdateOrCreateQuotaNode(
-    BrowsingDataQuotaHelper::QuotaInfo* quota_info) {
+    std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info) {
   if (quota_child_)
     return quota_child_;
   quota_child_ = new CookieTreeQuotaNode(quota_info);
   AddChildSortedByTitle(quota_child_);
   return quota_child_;
 }
 
 void CookieTreeOriginNode::CreateContentException(
     HostContentSettingsMap* content_settings, ContentSetting setting) const {
   if (CanCreateContentException()) {
@@ skipping 311 matching lines @@
   ui::TreeNodeModel<CookieTreeNode>::AddObserver(observer);
 }
 
 void CookiesTreeModel::RemoveCookiesTreeObserver(Observer* observer) {
   cookies_observer_list_.RemoveObserver(observer);
   // Call super so that TreeNodeModel doesn't have dead pointers.
   ui::TreeNodeModel<CookieTreeNode>::RemoveObserver(observer);
 }
 
 void CookiesTreeModel::OnAppCacheModelInfoLoaded() {
-  appcache_info_ = appcache_helper_->info_collection();
+  using appcache::AppCacheInfo;
+  using appcache::AppCacheInfoCollection;
+  using appcache::AppCacheInfoVector;
+  typedef std::map<GURL, AppCacheInfoVector> InfoByOrigin;
+
+  scoped_refptr<AppCacheInfoCollection> appcache_info =
+      appcache_helper_->info_collection();
+  if (!appcache_info || appcache_info->infos_by_origin.empty())
+    return;
+
+  for (InfoByOrigin::const_iterator origin =
+           appcache_info->infos_by_origin.begin();
+       origin != appcache_info->infos_by_origin.end(); ++origin) {
+    std::list<AppCacheInfo>& info_list = appcache_info_[origin->first];
+    info_list.insert(
+        info_list.begin(), origin->second.begin(), origin->second.end());
+  }
+
   PopulateAppCacheInfoWithFilter(std::wstring());
 }
 
 void CookiesTreeModel::PopulateAppCacheInfoWithFilter(
     const std::wstring& filter) {
   using appcache::AppCacheInfo;
-  using appcache::AppCacheInfoVector;
-  typedef std::map<GURL, AppCacheInfoVector> InfoByOrigin;
+  typedef std::map<GURL, std::list<AppCacheInfo> > InfoByOrigin;
 
-  if (!appcache_info_ || appcache_info_->infos_by_origin.empty())
+  if (appcache_info_.empty())
     return;
 
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
   NotifyObserverBeginBatch();
-  for (InfoByOrigin::const_iterator origin =
-           appcache_info_->infos_by_origin.begin();
-       origin != appcache_info_->infos_by_origin.end(); ++origin) {
+  for (InfoByOrigin::iterator origin = appcache_info_.begin();
+       origin != appcache_info_.end(); ++origin) {
     std::wstring origin_node_name = UTF8ToWide(origin->first.host());
     if (filter.empty() ||
         (origin_node_name.find(filter) != std::wstring::npos)) {
       CookieTreeOriginNode* origin_node =
           root->GetOrCreateOriginNode(origin->first);
       CookieTreeAppCachesNode* appcaches_node =
           origin_node->GetOrCreateAppCachesNode();
 
-      for (AppCacheInfoVector::const_iterator info = origin->second.begin();
+      for (std::list<AppCacheInfo>::iterator info = origin->second.begin();
            info != origin->second.end(); ++info) {
         appcaches_node->AddAppCacheNode(
-            new CookieTreeAppCacheNode(&(*info)));
+            new CookieTreeAppCacheNode(origin->first, info));
       }
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
 void CookiesTreeModel::OnCookiesModelInfoLoaded(
-    const CookieList& cookie_list) {
-  cookie_list_ = cookie_list;
+    const net::CookieList& cookie_list) {
+  cookie_list_.insert(cookie_list_.begin(),
+                      cookie_list.begin(),
+                      cookie_list.end());
   PopulateCookieInfoWithFilter(std::wstring());
 }
 
 void CookiesTreeModel::PopulateCookieInfoWithFilter(
     const std::wstring& filter) {
   // mmargh mmargh mmargh! delicious!
 
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
   for (CookieList::iterator it = cookie_list_.begin();
        it != cookie_list_.end(); ++it) {
     std::string source_string = it->Source();
     if (source_string.empty() || !use_cookie_source_) {
       std::string domain = it->Domain();
       if (domain.length() > 1 && domain[0] == '.')
         domain = domain.substr(1);
 
       // We treat secure cookies just the same as normal ones.
       source_string = std::string(chrome::kHttpScheme) +
           chrome::kStandardSchemeSeparator + domain + "/";
     }
 
     GURL source(source_string);
     if (!filter.size() ||
         (CookieTreeOriginNode::TitleForUrl(source).find(filter) !=
          std::string::npos)) {
       CookieTreeOriginNode* origin_node =
           root->GetOrCreateOriginNode(source);
       CookieTreeCookiesNode* cookies_node =
           origin_node->GetOrCreateCookiesNode();
-      CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(&*it);
+      CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(it);
       cookies_node->AddCookieNode(new_cookie);
     }
   }
 }
 
 void CookiesTreeModel::OnDatabaseModelInfoLoaded(
     const DatabaseInfoList& database_info) {
   database_info_list_ = database_info;
   PopulateDatabaseInfoWithFilter(std::wstring());
 }
@@ skipping 10 matching lines @@
     GURL origin(database_info->origin);
 
     if (!filter.size() ||
         (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
          std::wstring::npos)) {
       CookieTreeOriginNode* origin_node =
           root->GetOrCreateOriginNode(origin);
       CookieTreeDatabasesNode* databases_node =
           origin_node->GetOrCreateDatabasesNode();
       databases_node->AddDatabaseNode(
-          new CookieTreeDatabaseNode(&(*database_info)));
+          new CookieTreeDatabaseNode(database_info));
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
 void CookiesTreeModel::OnLocalStorageModelInfoLoaded(
     const LocalStorageInfoList& local_storage_info) {
   local_storage_info_list_ = local_storage_info;
   PopulateLocalStorageInfoWithFilter(std::wstring());
@@ skipping 12 matching lines @@
     GURL origin(local_storage_info->origin);
 
     if (!filter.size() ||
         (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
          std::wstring::npos)) {
       CookieTreeOriginNode* origin_node =
           root->GetOrCreateOriginNode(origin);
       CookieTreeLocalStoragesNode* local_storages_node =
           origin_node->GetOrCreateLocalStoragesNode();
       local_storages_node->AddLocalStorageNode(
-          new CookieTreeLocalStorageNode(&(*local_storage_info)));
+          new CookieTreeLocalStorageNode(local_storage_info));
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
 void CookiesTreeModel::OnSessionStorageModelInfoLoaded(
     const LocalStorageInfoList& session_storage_info) {
   session_storage_info_list_ = session_storage_info;
   PopulateSessionStorageInfoWithFilter(std::wstring());
@@ skipping 12 matching lines @@
     GURL origin(session_storage_info->origin);
 
     if (!filter.size() ||
         (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
          std::wstring::npos)) {
       CookieTreeOriginNode* origin_node =
           root->GetOrCreateOriginNode(origin);
       CookieTreeSessionStoragesNode* session_storages_node =
           origin_node->GetOrCreateSessionStoragesNode();
       session_storages_node->AddSessionStorageNode(
-          new CookieTreeSessionStorageNode(&(*session_storage_info)));
+          new CookieTreeSessionStorageNode(session_storage_info));
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
 void CookiesTreeModel::OnIndexedDBModelInfoLoaded(
     const IndexedDBInfoList& indexed_db_info) {
   indexed_db_info_list_ = indexed_db_info;
   PopulateIndexedDBInfoWithFilter(std::wstring());
@@ skipping 12 matching lines @@
     GURL origin(indexed_db_info->origin);
 
     if (!filter.size() ||
         (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
          std::wstring::npos)) {
       CookieTreeOriginNode* origin_node =
           root->GetOrCreateOriginNode(origin);
       CookieTreeIndexedDBsNode* indexed_dbs_node =
           origin_node->GetOrCreateIndexedDBsNode();
       indexed_dbs_node->AddIndexedDBNode(
-          new CookieTreeIndexedDBNode(&(*indexed_db_info)));
+          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());
@@ skipping 12 matching lines @@
     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)));
+          new CookieTreeFileSystemNode(file_system_info));
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
 void CookiesTreeModel::OnQuotaModelInfoLoaded(
     const QuotaInfoArray& quota_info) {
   quota_info_list_ = quota_info;
   PopulateQuotaInfoWithFilter(std::wstring());
 }
 
 void CookiesTreeModel::PopulateQuotaInfoWithFilter(
     const std::wstring& filter) {
   if (quota_info_list_.empty())
     return;
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
   NotifyObserverBeginBatch();
   for (QuotaInfoArray::iterator quota_info = quota_info_list_.begin();
        quota_info != quota_info_list_.end();
        ++quota_info) {
     if (!filter.size() ||
         (UTF8ToWide(quota_info->host).find(filter) != std::wstring::npos)) {
       CookieTreeOriginNode* origin_node =
           root->GetOrCreateOriginNode(GURL("http://" + quota_info->host));
-      origin_node->UpdateOrCreateQuotaNode(&*quota_info);
+      origin_node->UpdateOrCreateQuotaNode(quota_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));
   }
 }