Adds media license nodes to cookie tree model and cookies view.

chrome/browser/browsing_data/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_BROWSING_DATA_COOKIES_TREE_MODEL_H_
 #define CHROME_BROWSER_BROWSING_DATA_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 35 matching lines @@
 class CookieTreeDatabaseNode;
 class CookieTreeDatabasesNode;
 class CookieTreeFileSystemNode;
 class CookieTreeFileSystemsNode;
 class CookieTreeFlashLSONode;
 class CookieTreeHostNode;
 class CookieTreeIndexedDBNode;
 class CookieTreeIndexedDBsNode;
 class CookieTreeLocalStorageNode;
 class CookieTreeLocalStoragesNode;
+class CookieTreeMediaLicenseNode;
+class CookieTreeMediaLicensesNode;
 class CookieTreeQuotaNode;
 class CookieTreeServiceWorkerNode;
 class CookieTreeServiceWorkersNode;
 class CookieTreeSessionStorageNode;
 class CookieTreeSessionStoragesNode;
 class ExtensionSpecialStoragePolicy;
 
 namespace content_settings {
 class CookieSettings;
 }
@@ skipping 36 matching lines @@
       TYPE_FILE_SYSTEMS,      // This is used for CookieTreeFileSystemsNode.
       TYPE_FILE_SYSTEM,       // This is used for CookieTreeFileSystemNode.
       TYPE_QUOTA,             // This is used for CookieTreeQuotaNode.
       TYPE_CHANNEL_IDS,       // Used for CookieTreeChannelIDsNode.
       TYPE_CHANNEL_ID,        // Used for CookieTreeChannelIDNode.
       TYPE_SERVICE_WORKERS,   // This is used for CookieTreeServiceWorkersNode.
       TYPE_SERVICE_WORKER,    // This is used for CookieTreeServiceWorkerNode.
       TYPE_CACHE_STORAGES,    // This is used for CookieTreeCacheStoragesNode.
       TYPE_CACHE_STORAGE,     // This is used for CookieTreeCacheStorageNode.
       TYPE_FLASH_LSO,         // This is used for CookieTreeFlashLSONode.
+      TYPE_MEDIA_LICENSES,    // This is used for CookieTreeMediaLicensesNode.
+      TYPE_MEDIA_LICENSE,     // This is used for CookieTreeMediaLicenseNode.
     };
 
     DetailedInfo();
     DetailedInfo(const DetailedInfo& other);
     ~DetailedInfo();
 
     DetailedInfo& Init(NodeType type);
     DetailedInfo& InitHost();
     DetailedInfo& InitCookie(const net::CanonicalCookie* cookie);
     DetailedInfo& InitDatabase(
@@ skipping 12 matching lines @@
         const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info);
     DetailedInfo& InitQuota(
         const BrowsingDataQuotaHelper::QuotaInfo* quota_info);
     DetailedInfo& InitChannelID(
         const net::ChannelIDStore::ChannelID* channel_id);
     DetailedInfo& InitServiceWorker(
         const content::ServiceWorkerUsageInfo* service_worker_info);
     DetailedInfo& InitCacheStorage(
         const content::CacheStorageUsageInfo* cache_storage_info);
     DetailedInfo& InitFlashLSO(const std::string& flash_lso_domain);
+    DetailedInfo& InitMediaLicense(
+        const BrowsingDataMediaLicenseHelper::MediaLicenseInfo*
+            media_license_info);
 
     NodeType node_type;
     GURL origin;
     const net::CanonicalCookie* cookie = nullptr;
     const BrowsingDataDatabaseHelper::DatabaseInfo* database_info = nullptr;
     const BrowsingDataLocalStorageHelper::LocalStorageInfo* local_storage_info =
         nullptr;
     const BrowsingDataLocalStorageHelper::LocalStorageInfo*
         session_storage_info = nullptr;
     const content::AppCacheInfo* appcache_info = nullptr;
     const content::IndexedDBInfo* indexed_db_info = nullptr;
     const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info =
         nullptr;
     const BrowsingDataQuotaHelper::QuotaInfo* quota_info = nullptr;
     const net::ChannelIDStore::ChannelID* channel_id = nullptr;
     const content::ServiceWorkerUsageInfo* service_worker_info = nullptr;
     const content::CacheStorageUsageInfo* cache_storage_info = nullptr;
     std::string flash_lso_domain;
+    const BrowsingDataMediaLicenseHelper::MediaLicenseInfo* media_license_info =
+        nullptr;
   };
 
   CookieTreeNode() {}
   explicit CookieTreeNode(const base::string16& title)
       : ui::TreeNode<CookieTreeNode>(title) {}
   ~CookieTreeNode() override {}
 
   // 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 50 matching lines @@
   CookieTreeSessionStoragesNode* GetOrCreateSessionStoragesNode();
   CookieTreeAppCachesNode* GetOrCreateAppCachesNode();
   CookieTreeIndexedDBsNode* GetOrCreateIndexedDBsNode();
   CookieTreeFileSystemsNode* GetOrCreateFileSystemsNode();
   CookieTreeChannelIDsNode* GetOrCreateChannelIDsNode();
   CookieTreeServiceWorkersNode* GetOrCreateServiceWorkersNode();
   CookieTreeCacheStoragesNode* GetOrCreateCacheStoragesNode();
   CookieTreeQuotaNode* UpdateOrCreateQuotaNode(
       std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info);
   CookieTreeFlashLSONode* GetOrCreateFlashLSONode(const std::string& domain);
+  CookieTreeMediaLicensesNode* GetOrCreateMediaLicensesNode();
 
   std::string canonicalized_host() const { return canonicalized_host_; }
 
   // Creates an content exception for this origin of type
   // CONTENT_SETTINGS_TYPE_COOKIES.
   void CreateContentException(content_settings::CookieSettings* cookie_settings,
                               ContentSetting setting) const;
 
   // True if a content exception can be created for this origin.
   bool CanCreateContentException() const;
@@ skipping 11 matching lines @@
   CookieTreeLocalStoragesNode* local_storages_child_ = nullptr;
   CookieTreeSessionStoragesNode* session_storages_child_ = nullptr;
   CookieTreeAppCachesNode* appcaches_child_ = nullptr;
   CookieTreeIndexedDBsNode* indexed_dbs_child_ = nullptr;
   CookieTreeFileSystemsNode* file_systems_child_ = nullptr;
   CookieTreeQuotaNode* quota_child_ = nullptr;
   CookieTreeChannelIDsNode* channel_ids_child_ = nullptr;
   CookieTreeServiceWorkersNode* service_workers_child_ = nullptr;
   CookieTreeCacheStoragesNode* cache_storages_child_ = nullptr;
   CookieTreeFlashLSONode* flash_lso_child_ = nullptr;
+  CookieTreeMediaLicensesNode* media_licenses_child_ = nullptr;
 
   // The URL for which this node was initially created.
   GURL url_;
 
   std::string canonicalized_host_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeHostNode);
 };
 
 // CookieTreeCookieNode ------------------------------------------------------
@@ skipping 404 matching lines @@
   // CookieTreeNode methods:
   void DeleteStoredObjects() override;
   DetailedInfo GetDetailedInfo() const override;
 
  private:
   std::string domain_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeFlashLSONode);
 };
 
+// CookieTreeMediaLicenseNode -----------------------------------------------
+class CookieTreeMediaLicenseNode : public CookieTreeNode {
+ public:
+  friend class CookieTreeMediaLicensesNode;
+
+  // |media_license_info| is expected to remain valid as long as the
+  // CookieTreeMediaLicenseNode is valid.
+  explicit CookieTreeMediaLicenseNode(
+      const std::list<BrowsingDataMediaLicenseHelper::MediaLicenseInfo>::
+          iterator media_license_info);
+  ~CookieTreeMediaLicenseNode() override;
+
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
+
+ private:
+  // |media_license_info_| is expected to remain valid as long as the
+  // CookieTreeMediaLicenseNode is valid.
+  std::list<BrowsingDataMediaLicenseHelper::MediaLicenseInfo>::iterator
+      media_license_info_;
+
+  DISALLOW_COPY_AND_ASSIGN(CookieTreeMediaLicenseNode);
+};
+
+class CookieTreeMediaLicensesNode : public CookieTreeNode {
+ public:
+  CookieTreeMediaLicensesNode();
+  ~CookieTreeMediaLicensesNode() override;
+
+  DetailedInfo GetDetailedInfo() const override;
+
+  void AddMediaLicenseNode(std::unique_ptr<CookieTreeMediaLicenseNode> child) {
+    AddChildSortedByTitle(std::move(child));
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CookieTreeMediaLicensesNode);
+};
+
 // CookiesTreeModel -----------------------------------------------------------
 class CookiesTreeModel : public ui::TreeNodeModel<CookieTreeNode> {
  public:
   CookiesTreeModel(LocalDataContainer* data_container,
                    ExtensionSpecialStoragePolicy* special_storage_policy);
   ~CookiesTreeModel() override;
 
   // Given a CanonicalCookie, return the ID of the message which should be
   // displayed in various ports' "Send for:" UI.
   static int GetSendForMessageID(const net::CanonicalCookie& cookie);
@@ skipping 69 matching lines @@
   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 PopulateChannelIDInfo(LocalDataContainer* container);
   void PopulateServiceWorkerUsageInfo(LocalDataContainer* container);
   void PopulateCacheStorageUsageInfo(LocalDataContainer* container);
   void PopulateFlashLSOInfo(LocalDataContainer* container);
+  void PopulateMediaLicenseInfo(LocalDataContainer* container);
 
   BrowsingDataCookieHelper* GetCookieHelper(const std::string& app_id);
   LocalDataContainer* data_container() {
     return data_container_.get();
   }
 
   // Set the number of |batches_expected| this class should expect to receive.
   // If |reset| is true, then this is a new set of batches, but if false, then
   // this is a revised number (batches originally counted should no longer be
   // expected).
@@ skipping 56 matching lines @@
       LocalDataContainer* container,
       ScopedBatchUpdateNotifier* notifier,
       const base::string16& filter);
   void PopulateCacheStorageUsageInfoWithFilter(
       LocalDataContainer* container,
       ScopedBatchUpdateNotifier* notifier,
       const base::string16& filter);
   void PopulateFlashLSOInfoWithFilter(LocalDataContainer* container,
                                       ScopedBatchUpdateNotifier* notifier,
                                       const base::string16& filter);
+  void PopulateMediaLicenseInfoWithFilter(LocalDataContainer* container,
+                                          ScopedBatchUpdateNotifier* notifier,
+                                          const base::string16& filter);
 
 #if defined(ENABLE_EXTENSIONS)
   // The extension special storage policy; see ExtensionsProtectingNode() above.
   scoped_refptr<ExtensionSpecialStoragePolicy> special_storage_policy_;
 #endif
 
   // Map of app ids to LocalDataContainer objects to use when retrieving
   // locally stored data.
   std::unique_ptr<LocalDataContainer> data_container_;
 
@@ skipping 10 matching lines @@
 
   // Counts how many batches have started already. If this is non-zero and lower
   // than batches_ended_, then this model is still batching updates.
   int batches_started_ = 0;
 
   // Counts how many batches have finished.
   int batches_ended_ = 0;
 };
 
 #endif  // CHROME_BROWSER_BROWSING_DATA_COOKIES_TREE_MODEL_H_