Show Flash LSOs for Pepper Flash in cookie dialog.

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_
 
 // TODO(viettrungluu): This header file #includes far too much and has too much
 // inline code (which shouldn't be inline).
 
@@ skipping 23 matching lines @@
 class CookieSettings;
 class CookiesTreeModel;
 class CookieTreeAppCacheNode;
 class CookieTreeAppCachesNode;
 class CookieTreeCookieNode;
 class CookieTreeCookiesNode;
 class CookieTreeDatabaseNode;
 class CookieTreeDatabasesNode;
 class CookieTreeFileSystemNode;
 class CookieTreeFileSystemsNode;
+class CookieTreeFlashLSONode;
 class CookieTreeHostNode;
 class CookieTreeIndexedDBNode;
 class CookieTreeIndexedDBsNode;
 class CookieTreeLocalStorageNode;
 class CookieTreeLocalStoragesNode;
 class CookieTreeQuotaNode;
 class CookieTreeServerBoundCertNode;
 class CookieTreeServerBoundCertsNode;
 class CookieTreeSessionStorageNode;
 class CookieTreeSessionStoragesNode;
@@ skipping 28 matching lines @@
       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.
       TYPE_QUOTA,  // This is used for CookieTreeQuotaNode.
       TYPE_SERVER_BOUND_CERTS, // Used for CookieTreeServerBoundCertsNode.
       TYPE_SERVER_BOUND_CERT, // Used for CookieTreeServerBoundCertNode.
+      TYPE_FLASH_LSO,  // This is used for CookieTreeFlashLSONode.
     };
 
     DetailedInfo();
     ~DetailedInfo();
 
     DetailedInfo& Init(NodeType type);
     DetailedInfo& InitHost(const std::string& app_id,
                            const std::string& app_name);
     DetailedInfo& InitCookie(const net::CanonicalCookie* cookie);
     DetailedInfo& InitDatabase(
         const BrowsingDataDatabaseHelper::DatabaseInfo* database_info);
     DetailedInfo& InitLocalStorage(
         const BrowsingDataLocalStorageHelper::LocalStorageInfo*
         local_storage_info);
     DetailedInfo& InitSessionStorage(
         const BrowsingDataLocalStorageHelper::LocalStorageInfo*
         session_storage_info);
     DetailedInfo& InitAppCache(const GURL& origin,
                                const appcache::AppCacheInfo* appcache_info);
     DetailedInfo& InitIndexedDB(
         const BrowsingDataIndexedDBHelper::IndexedDBInfo* indexed_db_info);
     DetailedInfo& InitFileSystem(
         const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info);
     DetailedInfo& InitQuota(
         const BrowsingDataQuotaHelper::QuotaInfo* quota_info);
     DetailedInfo& InitServerBoundCert(
         const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert);
+    DetailedInfo& InitFlashLSO(const std::string& flash_lso_domain);
 
     std::string app_name;
     std::string app_id;
     NodeType node_type;
     GURL origin;
     const net::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;
     const BrowsingDataQuotaHelper::QuotaInfo* quota_info;
     const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert;
+    std::string flash_lso_domain;
   };
 
   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 53 matching lines @@
   CookieTreeCookiesNode* GetOrCreateCookiesNode();
   CookieTreeDatabasesNode* GetOrCreateDatabasesNode();
   CookieTreeLocalStoragesNode* GetOrCreateLocalStoragesNode();
   CookieTreeSessionStoragesNode* GetOrCreateSessionStoragesNode();
   CookieTreeAppCachesNode* GetOrCreateAppCachesNode();
   CookieTreeIndexedDBsNode* GetOrCreateIndexedDBsNode();
   CookieTreeFileSystemsNode* GetOrCreateFileSystemsNode();
   CookieTreeServerBoundCertsNode* GetOrCreateServerBoundCertsNode();
   CookieTreeQuotaNode* UpdateOrCreateQuotaNode(
       std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info);
+  CookieTreeFlashLSONode* GetOrCreateFlashLSONode(const std::string& domain);
 
   std::string canonicalized_host() const { return canonicalized_host_; }
 
   // Creates an content exception for this origin of type
   // CONTENT_SETTINGS_TYPE_COOKIES.
   void CreateContentException(CookieSettings* cookie_settings,
                               ContentSetting setting) const;
 
   // True if a content exception can be created for this origin.
   bool CanCreateContentException() const;
@@ skipping 10 matching lines @@
   // 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_;
   CookieTreeQuotaNode* quota_child_;
   CookieTreeServerBoundCertsNode* server_bound_certs_child_;
+  CookieTreeFlashLSONode* flash_lso_child_;
 
   std::string app_id_;
   std::string app_name_;
 
   // The URL for which this node was initially created.
   GURL url_;
 
   std::string canonicalized_host_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeHostNode);
@@ skipping 319 matching lines @@
   virtual DetailedInfo GetDetailedInfo() const OVERRIDE;
 
   void AddServerBoundCertNode(CookieTreeServerBoundCertNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeServerBoundCertsNode);
 };
 
+// CookieTreeFlashLSONode ----------------------------------------------------
+class CookieTreeFlashLSONode : public CookieTreeNode {
+ public:
+  explicit CookieTreeFlashLSONode(const std::string& domain);
+  virtual ~CookieTreeFlashLSONode();
+
+  // CookieTreeNode methods:
+  virtual void DeleteStoredObjects() OVERRIDE;
+  virtual DetailedInfo GetDetailedInfo() const OVERRIDE;
+
+ private:
+  std::string domain_;
+
+  DISALLOW_COPY_AND_ASSIGN(CookieTreeFlashLSONode);
+};
+
 // CookiesTreeModel -----------------------------------------------------------
 class CookiesTreeModel : public ui::TreeNodeModel<CookieTreeNode> {
  public:
   CookiesTreeModel(const ContainerMap& apps_map,
                    ExtensionSpecialStoragePolicy* special_storage_policy,
                    bool group_by_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
@@ skipping 61 matching lines @@
   // data helpers.
   void PopulateAppCacheInfo(LocalDataContainer* container);
   void PopulateCookieInfo(LocalDataContainer* container);
   void PopulateDatabaseInfo(LocalDataContainer* container);
   void PopulateLocalStorageInfo(LocalDataContainer* container);
   void PopulateSessionStorageInfo(LocalDataContainer* container);
   void PopulateIndexedDBInfo(LocalDataContainer* container);
   void PopulateFileSystemInfo(LocalDataContainer* container);
   void PopulateQuotaInfo(LocalDataContainer* container);
   void PopulateServerBoundCertInfo(LocalDataContainer* container);
+  void PopulateFlashLSOInfo(LocalDataContainer* container);
 
   BrowsingDataCookieHelper* GetCookieHelper(const std::string& app_id);
   LocalDataContainer* GetLocalDataContainer(const std::string& app_id);
 
  private:
   enum CookieIconIndex {
     ORIGIN = 0,
     COOKIE = 1,
     DATABASE = 2
   };
@@ skipping 22 matching lines @@
   void PopulateFileSystemInfoWithFilter(LocalDataContainer* container,
                                         ScopedBatchUpdateNotifier* notifier,
                                         const string16& filter);
   void PopulateQuotaInfoWithFilter(LocalDataContainer* container,
                                    ScopedBatchUpdateNotifier* notifier,
                                    const string16& filter);
   void PopulateServerBoundCertInfoWithFilter(
       LocalDataContainer* container,
       ScopedBatchUpdateNotifier* notifier,
       const string16& filter);
+  void PopulateFlashLSOInfoWithFilter(LocalDataContainer* container,
+                                      ScopedBatchUpdateNotifier* notifier,
+                                      const string16& filter);
 
   // Map of app ids to LocalDataContainer objects to use when retrieving
   // locally stored data.
   ContainerMap app_data_map_;
 
   // The extension special storage policy; see ExtensionsProtectingNode() above.
   scoped_refptr<ExtensionSpecialStoragePolicy> special_storage_policy_;
 
   // 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 group_by_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_;
 };
 
 #endif  // CHROME_BROWSER_COOKIES_TREE_MODEL_H_