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

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 <list>
 #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"
@@ skipping 194 matching lines @@
 
   // CookieTreeOriginNode methods:
   CookieTreeCookiesNode* GetOrCreateCookiesNode();
   CookieTreeDatabasesNode* GetOrCreateDatabasesNode();
   CookieTreeLocalStoragesNode* GetOrCreateLocalStoragesNode();
   CookieTreeSessionStoragesNode* GetOrCreateSessionStoragesNode();
   CookieTreeAppCachesNode* GetOrCreateAppCachesNode();
   CookieTreeIndexedDBsNode* GetOrCreateIndexedDBsNode();
   CookieTreeFileSystemsNode* GetOrCreateFileSystemsNode();
   CookieTreeQuotaNode* UpdateOrCreateQuotaNode(
-      BrowsingDataQuotaHelper::QuotaInfo* quota_info);
+      std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info);
 
   // 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:
@@ skipping 15 matching lines @@
   GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeOriginNode);
 };
 
 // CookieTreeCookieNode ------------------------------------------------------
 class CookieTreeCookieNode : public CookieTreeNode {
  public:
   friend class CookieTreeCookiesNode;
 
-  // Does not take ownership of cookie, and cookie should remain valid at least
-  // as long as the CookieTreeCookieNode is valid.
-  explicit CookieTreeCookieNode(net::CookieMonster::CanonicalCookie* cookie);
+  // The cookie should remain valid at least as long as the
+  // CookieTreeCookieNode is valid.
+  explicit CookieTreeCookieNode(
+      std::list<net::CookieMonster::CanonicalCookie>::iterator cookie);
   virtual ~CookieTreeCookieNode();
 
   // CookieTreeNode methods:
   virtual void DeleteStoredObjects();
   virtual DetailedInfo GetDetailedInfo() const;
 
  private:
-  // Cookie_ is not owned by the node, and is expected to remain valid as long
-  // as the CookieTreeCookieNode is valid.
-  net::CookieMonster::CanonicalCookie* cookie_;
+  // cookie_ is expected to remain valid as long as the CookieTreeCookieNode is
+  // valid.
+  std::list<net::CookieMonster::CanonicalCookie>::iterator cookie_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeCookieNode);
 };
 
 class CookieTreeCookiesNode : public CookieTreeNode {
  public:
   CookieTreeCookiesNode();
   virtual ~CookieTreeCookiesNode();
 
   virtual DetailedInfo GetDetailedInfo() const;
 
   void AddCookieNode(CookieTreeCookieNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeCookiesNode);
 };
 
 // CookieTreeAppCacheNode -----------------------------------------------------
 class CookieTreeAppCacheNode : public CookieTreeNode {
  public:
   friend class CookieTreeAppCachesNode;
 
-  // Does not take ownership of appcache_info, and appcache_info should remain
-  // valid at least as long as the CookieTreeAppCacheNode is valid.
+  // appcache_info should remain valid at least as long as the
+  // CookieTreeAppCacheNode is valid.
   explicit CookieTreeAppCacheNode(
-      const appcache::AppCacheInfo* appcache_info);
-  virtual ~CookieTreeAppCacheNode() {}
+      const GURL& origin_url,
+      std::list<appcache::AppCacheInfo>::iterator appcache_info);
+  virtual ~CookieTreeAppCacheNode();
 
   virtual void DeleteStoredObjects();
   virtual DetailedInfo GetDetailedInfo() const;
 
  private:
-  const appcache::AppCacheInfo* appcache_info_;
+  GURL origin_url_;
+  std::list<appcache::AppCacheInfo>::iterator appcache_info_;
   DISALLOW_COPY_AND_ASSIGN(CookieTreeAppCacheNode);
 };
 
 class CookieTreeAppCachesNode : public CookieTreeNode {
  public:
   CookieTreeAppCachesNode();
   virtual ~CookieTreeAppCachesNode();
 
   virtual DetailedInfo GetDetailedInfo() const;
 
   void AddAppCacheNode(CookieTreeAppCacheNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeAppCachesNode);
 };
 
 // CookieTreeDatabaseNode -----------------------------------------------------
 class CookieTreeDatabaseNode : public CookieTreeNode {
  public:
   friend class CookieTreeDatabasesNode;
 
-  // Does not take ownership of database_info, and database_info should remain
-  // valid at least as long as the CookieTreeDatabaseNode is valid.
+  // database_info should remain valid at least as long as the
+  // CookieTreeDatabaseNode is valid.
   explicit CookieTreeDatabaseNode(
-      BrowsingDataDatabaseHelper::DatabaseInfo* database_info);
+      std::list<BrowsingDataDatabaseHelper::DatabaseInfo>::iterator
+          database_info);
   virtual ~CookieTreeDatabaseNode();
 
   virtual void DeleteStoredObjects();
   virtual DetailedInfo GetDetailedInfo() const;
 
  private:
-  // database_info_ is not owned by the node, and is expected to remain
-  // valid as long as the CookieTreeDatabaseNode is valid.
-  BrowsingDataDatabaseHelper::DatabaseInfo* database_info_;
+  // database_info_ is expected to remain valid as long as the
+  // CookieTreeDatabaseNode is valid.
+  std::list<BrowsingDataDatabaseHelper::DatabaseInfo>::iterator
+      database_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeDatabaseNode);
 };
 
 class CookieTreeDatabasesNode : public CookieTreeNode {
  public:
   CookieTreeDatabasesNode();
   virtual ~CookieTreeDatabasesNode();
 
   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.
+  // file_system_info should remain valid at least as long as the
+  // CookieTreeFileSystemNode is valid.
   explicit CookieTreeFileSystemNode(
-      BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info);
+      std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator
+          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_;
+  // file_system_info_ expected to remain valid as long as the
+  // CookieTreeFileSystemNode is valid.
+  std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator
+      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.
+  // local_storage_info should remain valid at least as long as the
+  // CookieTreeLocalStorageNode is valid.
   explicit CookieTreeLocalStorageNode(
-      BrowsingDataLocalStorageHelper::LocalStorageInfo* local_storage_info);
+      std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator
+          local_storage_info);
   virtual ~CookieTreeLocalStorageNode();
 
   // CookieTreeNode methods:
   virtual void DeleteStoredObjects();
   virtual DetailedInfo GetDetailedInfo() const;
 
  private:
-  // local_storage_info_ is not owned by the node, and is expected to remain
-  // valid as long as the CookieTreeLocalStorageNode is valid.
-  BrowsingDataLocalStorageHelper::LocalStorageInfo* local_storage_info_;
+  // local_storage_info_ is expected to remain valid as long as the
+  // CookieTreeLocalStorageNode is valid.
+  std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator
+      local_storage_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeLocalStorageNode);
 };
 
 class CookieTreeLocalStoragesNode : public CookieTreeNode {
  public:
   CookieTreeLocalStoragesNode();
   virtual ~CookieTreeLocalStoragesNode();
 
   virtual DetailedInfo GetDetailedInfo() const;
 
   void AddLocalStorageNode(CookieTreeLocalStorageNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeLocalStoragesNode);
 };
 
 
 // CookieTreeSessionStorageNode -----------------------------------------------
 class CookieTreeSessionStorageNode : public CookieTreeNode {
  public:
-  // Does not take ownership of session_storage_info, and session_storage_info
-  // should remain valid at least as long as the CookieTreeSessionStorageNode
-  // is valid.
+  // session_storage_info should remain valid at least as long as the
+  // CookieTreeSessionStorageNode is valid.
   explicit CookieTreeSessionStorageNode(
-      BrowsingDataLocalStorageHelper::LocalStorageInfo* session_storage_info);
+      std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator
+          session_storage_info);
   virtual ~CookieTreeSessionStorageNode();
 
   // CookieTreeNode methods:
+  virtual void DeleteStoredObjects();
   virtual DetailedInfo GetDetailedInfo() const;
 
  private:
-  // session_storage_info_ is not owned by the node, and is expected to remain
-  // valid as long as the CookieTreeSessionStorageNode is valid.
-  BrowsingDataLocalStorageHelper::LocalStorageInfo* session_storage_info_;
+  // session_storage_info_ is expected to remain valid as long as the
+  // CookieTreeSessionStorageNode is valid.
+  std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator
+      session_storage_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeSessionStorageNode);
 };
 
 class CookieTreeSessionStoragesNode : public CookieTreeNode {
  public:
   CookieTreeSessionStoragesNode();
   virtual ~CookieTreeSessionStoragesNode();
 
   virtual DetailedInfo GetDetailedInfo() const;
 
   void AddSessionStorageNode(CookieTreeSessionStorageNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeSessionStoragesNode);
 };
 
 // CookieTreeIndexedDBNode -----------------------------------------------
 class CookieTreeIndexedDBNode : public CookieTreeNode {
  public:
-  // Does not take ownership of session_storage_info, and session_storage_info
-  // should remain valid at least as long as the CookieTreeSessionStorageNode
-  // is valid.
+  // indexed_db_info should remain valid at least as long as the
+  // CookieTreeIndexedDBNode is valid.
   explicit CookieTreeIndexedDBNode(
-      BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info);
+      std::list<BrowsingDataIndexedDBHelper::IndexedDBInfo>::iterator
+          indexed_db_info);
   virtual ~CookieTreeIndexedDBNode();
 
   // CookieTreeNode methods:
   virtual void DeleteStoredObjects();
   virtual DetailedInfo GetDetailedInfo() const;
 
  private:
-  // indexed_db_info_ is not owned by the node, and is expected to remain
-  // valid as long as the CookieTreeIndexedDBNode is valid.
-  BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info_;
+  // indexed_db_info_ is expected to remain valid as long as the
+  // CookieTreeIndexedDBNode is valid.
+  std::list<BrowsingDataIndexedDBHelper::IndexedDBInfo>::iterator
+      indexed_db_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeIndexedDBNode);
 };
 
 class CookieTreeIndexedDBsNode : public CookieTreeNode {
  public:
   CookieTreeIndexedDBsNode();
   virtual ~CookieTreeIndexedDBsNode();
 
   virtual DetailedInfo GetDetailedInfo() const;
 
   void AddIndexedDBNode(CookieTreeIndexedDBNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeIndexedDBsNode);
 };
 
 // CookieTreeQuotaNode --------------------------------------------------
 class CookieTreeQuotaNode : public CookieTreeNode {
  public:
-  // Does not take ownership of quota_info, and quota_info should remain valid
-  // at least as long as the CookieTreeQuotaNode is valid.
-  explicit CookieTreeQuotaNode(BrowsingDataQuotaHelper::QuotaInfo* quota_info);
+  // quota_info should remain valid at least as long as the CookieTreeQuotaNode
+  // is valid.
+  explicit CookieTreeQuotaNode(
+      std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info);
   virtual ~CookieTreeQuotaNode();
 
   virtual void DeleteStoredObjects();
   virtual DetailedInfo GetDetailedInfo() const;
 
  private:
-  // quota_info_ is not owned by the node, and is expected to remain valid as
-  // long as the CookieTreeQuotaNode is valid.
-  BrowsingDataQuotaHelper::QuotaInfo* quota_info_;
+  // quota_info_ is expected to remain valid as long as the CookieTreeQuotaNode
+  // is valid.
+  std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeQuotaNode);
 };
 
 // CookiesTreeModel -----------------------------------------------------------
 class CookiesTreeModel : public ui::TreeNodeModel<CookieTreeNode> {
  public:
   // 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
@@ skipping 40 matching lines @@
   // not get CookiesTreeModel::Observer notifications.
   virtual void AddCookiesTreeObserver(Observer* observer);
   virtual void RemoveCookiesTreeObserver(Observer* observer);
 
  private:
   enum CookieIconIndex {
     ORIGIN = 0,
     COOKIE = 1,
     DATABASE = 2
   };
-  typedef net::CookieList CookieList;
-  typedef std::vector<BrowsingDataDatabaseHelper::DatabaseInfo>
+  typedef std::list<net::CookieMonster::CanonicalCookie> CookieList;
+  typedef std::list<BrowsingDataDatabaseHelper::DatabaseInfo>
       DatabaseInfoList;
-  typedef std::vector<BrowsingDataLocalStorageHelper::LocalStorageInfo>
+  typedef std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>
       LocalStorageInfoList;
-  typedef std::vector<BrowsingDataLocalStorageHelper::LocalStorageInfo>
+  typedef std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>
       SessionStorageInfoList;
-  typedef std::vector<BrowsingDataIndexedDBHelper::IndexedDBInfo>
+  typedef std::list<BrowsingDataIndexedDBHelper::IndexedDBInfo>
       IndexedDBInfoList;
-  typedef std::vector<BrowsingDataFileSystemHelper::FileSystemInfo>
+  typedef std::list<BrowsingDataFileSystemHelper::FileSystemInfo>
       FileSystemInfoList;
-  typedef std::vector<BrowsingDataQuotaHelper::QuotaInfo> QuotaInfoArray;
+  typedef std::list<BrowsingDataQuotaHelper::QuotaInfo> QuotaInfoArray;
 
   void OnAppCacheModelInfoLoaded();
-  void OnCookiesModelInfoLoaded(const CookieList& cookie_list);
+  void OnCookiesModelInfoLoaded(const net::CookieList& cookie_list);
   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 OnQuotaModelInfoLoaded(const QuotaInfoArray& quota_info);
@@ skipping 12 matching lines @@
 
   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<appcache::AppCacheInfoCollection> appcache_info_;
+  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_;
 
   // 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 CookieTreeSessionStorageNode;
   friend class CookieTreeIndexedDBNode;
   friend class CookieTreeFileSystemNode;
   friend class CookieTreeQuotaNode;
 
   DISALLOW_COPY_AND_ASSIGN(CookiesTreeModel);
 };
 
 #endif  // CHROME_BROWSER_COOKIES_TREE_MODEL_H_