Refactoring CookiesTreeModel to support multiple data sources.

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_
 #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/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 "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 CookieTreeFileSystemNode;
+class CookieTreeIndexedDBNode;
+class CookieTreeIndexedDBsNode;
 class CookieTreeLocalStorageNode;
 class CookieTreeLocalStoragesNode;
+class CookieTreeOriginNode;
+class CookieTreeQuotaNode;
 class CookieTreeServerBoundCertNode;
 class CookieTreeServerBoundCertsNode;
-class CookieTreeQuotaNode;
 class CookieTreeSessionStorageNode;
 class CookieTreeSessionStoragesNode;
-class CookieTreeIndexedDBNode;
-class CookieTreeIndexedDBsNode;
-class CookieTreeOriginNode;
+
 
 // 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_APP,  // This is used for CookieTreeAppNode nodes.
       TYPE_ORIGIN,  // This is used for CookieTreeOriginNode 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.
@@ skipping 21 matching lines @@
           file_system_info(NULL),
           quota_info(NULL),
           server_bound_cert(NULL) {}
 
     DetailedInfo& Init(NodeType type) {
       DCHECK_EQ(TYPE_NONE, node_type);
       node_type = type;
       return *this;
     }
 
+    DetailedInfo& InitApp(const std::string& app_name,
+                          const std::string& app_id) {
+      Init(TYPE_APP);
+      this->app_name = app_name;
+      this->app_id = app_id;
+      return *this;
+    }
+
     DetailedInfo& InitCookie(
         const net::CookieMonster::CanonicalCookie* cookie) {
       Init(TYPE_COOKIE);
       this->cookie = cookie;
       return *this;
     }
 
     DetailedInfo& InitDatabase(
         const BrowsingDataDatabaseHelper::DatabaseInfo* database_info) {
       Init(TYPE_DATABASE);
@@ skipping 44 matching lines @@
       return *this;
     }
 
     DetailedInfo& InitServerBoundCert(
         const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert) {
       Init(TYPE_SERVER_BOUND_CERT);
       this->server_bound_cert = server_bound_cert;
       return *this;
     }
 
+    std::string app_name;
+    std::string app_id;
     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 BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info;
@@ skipping 11 matching lines @@
   virtual void DeleteStoredObjects();
 
   // Gets a pointer back to the associated model for the tree we are in.
   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:
+  // This class implements comparison by title of a CookieTreeNode. It is
+  // used to insert nodes in alphabetical order.
   class NodeTitleComparator {
    public:
     bool operator() (const CookieTreeNode* lhs, const CookieTreeNode* rhs);
   };
 
+  // This class implements comparison by application id of a CookieTreeAppNode.
+  class AppNodeComparator {
+   public:
+    bool operator() (const CookieTreeNode* lhs, const CookieTreeNode* rhs);
+  };
+
   void AddChildSortedByTitle(CookieTreeNode* new_child);
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeNode);
 };
 
+// CookieTreeAppNode ----------------------------------------------------------
+class CookieTreeAppNode : public CookieTreeNode {
+ public:
+  explicit CookieTreeAppNode(const std::string& app_name,
+                             const std::string& app_id);
+  virtual ~CookieTreeAppNode();
+
+  CookieTreeOriginNode* GetOrCreateOriginNode(const GURL& url);
+
+  // CookieTreeNode methods:
+  virtual DetailedInfo GetDetailedInfo() const OVERRIDE;
+
+  const std::string& app_id() const { return app_id_; }
+
+ private:
+  std::string app_name_;
+  std::string app_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(CookieTreeAppNode);
+};
+
 // 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);
+  // Creates a new CookieTreeAppNode, based on the app id and name. If a node,
+  // already exists in the tree, it returns a pointer to it.
+  CookieTreeAppNode* GetOrCreateAppNode(const std::string& app_name,
+                                        const std::string& app_id);
 
   // 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 {
  public:
   // Returns the origin node's title to use for a given URL.
-  static std::wstring TitleForUrl(const GURL& url);
+  static string16 TitleForUrl(const GURL& url);
 
   explicit CookieTreeOriginNode(const GURL& url);
   virtual ~CookieTreeOriginNode();
 
   // CookieTreeNode methods:
   virtual DetailedInfo GetDetailedInfo() const OVERRIDE;
 
   // CookieTreeOriginNode methods:
   CookieTreeCookiesNode* GetOrCreateCookiesNode();
   CookieTreeDatabasesNode* GetOrCreateDatabasesNode();
@@ skipping 356 matching lines @@
   virtual DetailedInfo GetDetailedInfo() const OVERRIDE;
 
   void AddServerBoundCertNode(CookieTreeServerBoundCertNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeServerBoundCertsNode);
 };
 
+// CookiesTreeModelDelegate ---------------------------------------------------
+// This is a delegate definition class. It is used by the CookiesTreeModel
+// to pass a pointer to itself to each of the LocalDataContainer objects, so
+// when resource fetching is complete, the objects can call back to the model
+// and update it. The CookiesTreeModel instance must outlive the
+// LocalDataContainer instances.
+class CookiesTreeModelDelegate {
+ public:
+  virtual void PopulateAppCacheInfoWithFilter(const std::string* app_id,
+                                              const string16& filter) = 0;
+  virtual void PopulateCookieInfoWithFilter(const std::string* app_id,
+                                            const string16& filter) = 0;
+  virtual void PopulateDatabaseInfoWithFilter(const std::string* app_id,
+                                              const string16& filter) = 0;
+  virtual void PopulateLocalStorageInfoWithFilter(const std::string* app_id,
+                                                  const string16& filter) = 0;
+  virtual void PopulateSessionStorageInfoWithFilter(
+      const std::string* app_id, const string16& filter) = 0;
+  virtual void PopulateIndexedDBInfoWithFilter(const std::string* app_id,
+                                               const string16& filter) = 0;
+  virtual void PopulateFileSystemInfoWithFilter(const std::string* app_id,
+                                                const string16& filter) = 0;
+  virtual void PopulateQuotaInfoWithFilter(const std::string* app_id,
+                                           const string16& filter) = 0;
+  virtual void PopulateServerBoundCertInfoWithFilter(
+      const std::string* app_id, const string16& filter) = 0;
+};
+
 // CookiesTreeModel -----------------------------------------------------------
-class CookiesTreeModel : public ui::TreeNodeModel<CookieTreeNode> {
+class CookiesTreeModel : public ui::TreeNodeModel<CookieTreeNode>,
+                         public CookiesTreeModelDelegate {
  public:
+  CookiesTreeModel(const ContainerMap& apps_map, bool use_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) {}
     virtual void TreeModelEndBatch(CookiesTreeModel* model) {}
   };
 
-  CookiesTreeModel(
-      BrowsingDataCookieHelper* cookie_helper,
-      BrowsingDataDatabaseHelper* database_helper,
-      BrowsingDataLocalStorageHelper* local_storage_helper,
-      BrowsingDataLocalStorageHelper* session_storage_helper,
-      BrowsingDataAppCacheHelper* appcache_helper,
-      BrowsingDataIndexedDBHelper* indexed_db_helper,
-      BrowsingDataFileSystemHelper* file_system_helper,
-      BrowsingDataQuotaHelper* quota_helper,
-      BrowsingDataServerBoundCertHelper* server_bound_cert_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<gfx::ImageSkia>* icons) OVERRIDE;
 
   // 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
   // GetIcons.
   virtual int GetIconIndex(ui::TreeModelNode* node) OVERRIDE;
 
   // CookiesTreeModel methods:
   void DeleteAllStoredObjects();
+
+  // Deletes all the stored objects for a specific app, identified by |app_id|.
+  void DeleteStoredObjectsForApp(const std::string& app_id);
   void DeleteCookieNode(CookieTreeNode* cookie_node);
 
   // Filter the origins to only display matched results.
-  void UpdateSearchResults(const std::wstring& filter);
+  void UpdateSearchResults(const string16& filter);
 
   // 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);
 
+  // CookiesTreeModelDelegate methods:
+  virtual void PopulateAppCacheInfoWithFilter(
+      const std::string* app_id, const string16& filter) OVERRIDE;
+  virtual void PopulateCookieInfoWithFilter(
+      const std::string* app_id, const string16& filter) OVERRIDE;
+  virtual void PopulateDatabaseInfoWithFilter(
+      const std::string* app_id, const string16& filter) OVERRIDE;
+  virtual void PopulateLocalStorageInfoWithFilter(
+      const std::string* app_id, const string16& filter) OVERRIDE;
+  virtual void PopulateSessionStorageInfoWithFilter(
+      const std::string* app_id, const string16& filter) OVERRIDE;
+  virtual void PopulateIndexedDBInfoWithFilter(
+      const std::string* app_id, const string16& filter) OVERRIDE;
+  virtual void PopulateFileSystemInfoWithFilter(
+      const std::string* app_id, const string16& filter) OVERRIDE;
+  virtual void PopulateQuotaInfoWithFilter(
+      const std::string* app_id, const string16& filter) OVERRIDE;
+  virtual void PopulateServerBoundCertInfoWithFilter(
+      const std::string* app_id, const string16& filter) OVERRIDE;
+
+  BrowsingDataCookieHelper* GetCookieHelper(const std::string& app_id);
+  LocalDataContainer* GetLocalDataContainer(const std::string& app_id);
+
  private:
   enum CookieIconIndex {
     ORIGIN = 0,
     COOKIE = 1,
     DATABASE = 2
   };
-  typedef std::list<net::CookieMonster::CanonicalCookie> CookieList;
-  typedef std::list<BrowsingDataDatabaseHelper::DatabaseInfo>
-      DatabaseInfoList;
-  typedef std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>
-      LocalStorageInfoList;
-  typedef std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>
-      SessionStorageInfoList;
-  typedef std::list<BrowsingDataIndexedDBHelper::IndexedDBInfo>
-      IndexedDBInfoList;
-  typedef std::list<BrowsingDataFileSystemHelper::FileSystemInfo>
-      FileSystemInfoList;
-  typedef std::list<BrowsingDataQuotaHelper::QuotaInfo> QuotaInfoArray;
-  typedef net::ServerBoundCertStore::ServerBoundCertList ServerBoundCertList;
-
-  void OnAppCacheModelInfoLoaded();
-  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);
-  void OnServerBoundCertModelInfoLoaded(const ServerBoundCertList& cert_list);
-
-  void PopulateAppCacheInfoWithFilter(const std::wstring& filter);
-  void PopulateCookieInfoWithFilter(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 PopulateQuotaInfoWithFilter(const std::wstring& filter);
-  void PopulateServerBoundCertInfoWithFilter(const std::wstring& filter);
 
   void NotifyObserverBeginBatch();
   void NotifyObserverEndBatch();
 
-  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<BrowsingDataServerBoundCertHelper> server_bound_cert_helper_;
-
-  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_;
-  ServerBoundCertList server_bound_cert_list_;
+  // Map of app ids to LocalDataContainer objects to use when retrieving
+  // locally stored data.
+  ContainerMap app_data_map_;
 
   // 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 use_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_;
-
-  // If true, use the CanonicalCookie::Source attribute to group cookies.
-  // Otherwise, use the CanonicalCookie::Domain attribute.
-  bool use_cookie_source_;
-
-  base::WeakPtrFactory<CookiesTreeModel> weak_ptr_factory_;
-
-  friend class CookieTreeAppCacheNode;
-  friend class CookieTreeCookieNode;
-  friend class CookieTreeDatabaseNode;
-  friend class CookieTreeLocalStorageNode;
-  friend class CookieTreeSessionStorageNode;
-  friend class CookieTreeIndexedDBNode;
-  friend class CookieTreeFileSystemNode;
-  friend class CookieTreeQuotaNode;
-  friend class CookieTreeServerBoundCertNode;
-
-  DISALLOW_COPY_AND_ASSIGN(CookiesTreeModel);
 };
 
 #endif  // CHROME_BROWSER_COOKIES_TREE_MODEL_H_