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

chrome/browser/browsing_data/cookies_tree_model.cc

 // 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.
 
 #include "chrome/browser/browsing_data/cookies_tree_model.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
@@ skipping 118 matching lines @@
     case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM:
     case CookieTreeNode::DetailedInfo::TYPE_SERVICE_WORKER:
     case CookieTreeNode::DetailedInfo::TYPE_CACHE_STORAGE:
       return true;
 
     // Fall through each below cases to return false.
     case CookieTreeNode::DetailedInfo::TYPE_COOKIE:
     case CookieTreeNode::DetailedInfo::TYPE_QUOTA:
     case CookieTreeNode::DetailedInfo::TYPE_CHANNEL_ID:
     case CookieTreeNode::DetailedInfo::TYPE_FLASH_LSO:
+    case CookieTreeNode::DetailedInfo::TYPE_MEDIA_LICENSE:
       return false;
     default:
       break;
   }
   return false;
 }
 #endif
 
 // This function returns the local data container associated with a leaf tree
 // node. The app node is assumed to be 3 levels above the leaf because of the
@@ skipping 115 matching lines @@
   return *this;
 }
 
 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitFlashLSO(
     const std::string& flash_lso_domain) {
   Init(TYPE_FLASH_LSO);
   this->flash_lso_domain = flash_lso_domain;
   return *this;
 }
 
+CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitMediaLicense(
+    const BrowsingDataMediaLicenseHelper::MediaLicenseInfo*
+        media_license_info) {
+  Init(TYPE_MEDIA_LICENSE);
+  this->media_license_info = media_license_info;
+  this->origin = media_license_info->origin;
+  return *this;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeNode, public:
 
 void CookieTreeNode::DeleteStoredObjects() {
   for (const auto& child : children())
     child->DeleteStoredObjects();
 }
 
 CookiesTreeModel* CookieTreeNode::GetModel() const {
   if (parent())
@@ skipping 284 matching lines @@
     container->cache_storage_info_list_.erase(cache_storage_info_);
   }
 }
 
 CookieTreeNode::DetailedInfo CookieTreeCacheStorageNode::GetDetailedInfo()
     const {
   return DetailedInfo().InitCacheStorage(&*cache_storage_info_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// CookieTreeMediaLicenseNode, public:
+
+CookieTreeMediaLicenseNode::CookieTreeMediaLicenseNode(
+    const std::list<BrowsingDataMediaLicenseHelper::MediaLicenseInfo>::iterator
+        media_license_info)
+    : CookieTreeNode(base::UTF8ToUTF16(media_license_info->origin.spec())),
+      media_license_info_(media_license_info) {}
+
+CookieTreeMediaLicenseNode::~CookieTreeMediaLicenseNode() {}
+
+void CookieTreeMediaLicenseNode::DeleteStoredObjects() {
+  LocalDataContainer* container = GetLocalDataContainerForNode(this);
+
+  if (container) {
+    container->media_license_helper_->DeleteMediaLicenseOrigin(
+        media_license_info_->origin);
+    container->media_license_info_list_.erase(media_license_info_);
+  }
+}
+
+CookieTreeNode::DetailedInfo CookieTreeMediaLicenseNode::GetDetailedInfo()
+    const {
+  return DetailedInfo().InitMediaLicense(&*media_license_info_);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // CookieTreeRootNode, public:
 
 CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model)
     : model_(model) {
 }
 
 CookieTreeRootNode::~CookieTreeRootNode() {}
 
 CookieTreeHostNode* CookieTreeRootNode::GetOrCreateHostNode(const GURL& url) {
   std::unique_ptr<CookieTreeHostNode> host_node =
@@ skipping 145 matching lines @@
 CookieTreeFlashLSONode* CookieTreeHostNode::GetOrCreateFlashLSONode(
     const std::string& domain) {
   DCHECK_EQ(GetHost(), domain);
   if (flash_lso_child_)
     return flash_lso_child_;
   flash_lso_child_ = new CookieTreeFlashLSONode(domain);
   AddChildSortedByTitle(base::WrapUnique(flash_lso_child_));
   return flash_lso_child_;
 }
 
+CookieTreeMediaLicensesNode*
+CookieTreeHostNode::GetOrCreateMediaLicensesNode() {
+  if (media_licenses_child_)
+    return media_licenses_child_;
+  media_licenses_child_ = new CookieTreeMediaLicensesNode();
+  AddChildSortedByTitle(base::WrapUnique(media_licenses_child_));
+  return media_licenses_child_;
+}
+
 void CookieTreeHostNode::CreateContentException(
     content_settings::CookieSettings* cookie_settings,
     ContentSetting setting) const {
   DCHECK(setting == CONTENT_SETTING_ALLOW ||
          setting == CONTENT_SETTING_BLOCK ||
          setting == CONTENT_SETTING_SESSION_ONLY);
   if (CanCreateContentException()) {
     cookie_settings->ResetCookieSetting(url_);
     cookie_settings->SetCookieSetting(url_, setting);
   }
@@ skipping 166 matching lines @@
   LocalDataContainer* container = GetModel()->data_container();
   container->flash_lso_helper_->DeleteFlashLSOsForSite(
       domain_, base::Closure());
 }
 
 CookieTreeNode::DetailedInfo CookieTreeFlashLSONode::GetDetailedInfo() const {
   return DetailedInfo().InitFlashLSO(domain_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// CookieTreeMediaLicensesNode
+CookieTreeMediaLicensesNode::CookieTreeMediaLicensesNode()
+    : CookieTreeNode(l10n_util::GetStringUTF16(IDS_COOKIES_MEDIA_LICENSES)) {}
+
+CookieTreeMediaLicensesNode::~CookieTreeMediaLicensesNode() {}
+
+CookieTreeNode::DetailedInfo CookieTreeMediaLicensesNode::GetDetailedInfo()
+    const {
+  return DetailedInfo().Init(DetailedInfo::TYPE_MEDIA_LICENSES);
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // ScopedBatchUpdateNotifier
 CookiesTreeModel::ScopedBatchUpdateNotifier::ScopedBatchUpdateNotifier(
     CookiesTreeModel* model,
     CookieTreeNode* node)
     : model_(model), node_(node) {
   model_->RecordBatchSeen();
 }
 
 CookiesTreeModel::ScopedBatchUpdateNotifier::~ScopedBatchUpdateNotifier() {
   if (batch_in_progress_) {
@@ skipping 73 matching lines @@
 
     // Fall through each below cases to return DATABASE.
     case CookieTreeNode::DetailedInfo::TYPE_DATABASE:
     case CookieTreeNode::DetailedInfo::TYPE_LOCAL_STORAGE:
     case CookieTreeNode::DetailedInfo::TYPE_SESSION_STORAGE:
     case CookieTreeNode::DetailedInfo::TYPE_APPCACHE:
     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB:
     case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM:
     case CookieTreeNode::DetailedInfo::TYPE_SERVICE_WORKER:
     case CookieTreeNode::DetailedInfo::TYPE_CACHE_STORAGE:
+    case CookieTreeNode::DetailedInfo::TYPE_MEDIA_LICENSE:
       return DATABASE;
     case CookieTreeNode::DetailedInfo::TYPE_QUOTA:
       return -1;
     default:
       break;
   }
   return -1;
 }
 
 void CookiesTreeModel::DeleteAllStoredObjects() {
@@ skipping 123 matching lines @@
   PopulateCacheStorageUsageInfoWithFilter(container, &notifier,
                                           base::string16());
 }
 
 void CookiesTreeModel::PopulateFlashLSOInfo(
       LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateFlashLSOInfoWithFilter(container, &notifier, base::string16());
 }
 
+void CookiesTreeModel::PopulateMediaLicenseInfo(LocalDataContainer* container) {
+  ScopedBatchUpdateNotifier notifier(this, GetRoot());
+  PopulateMediaLicenseInfoWithFilter(container, &notifier, base::string16());
+}
+
 void CookiesTreeModel::PopulateAppCacheInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   using content::AppCacheInfo;
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
   if (container->appcache_info_.empty())
     return;
 
@@ skipping 302 matching lines @@
        it != container->flash_lso_domain_list_.end(); ++it) {
     if (filter_utf8.empty() || it->find(filter_utf8) != std::string::npos) {
       // Create a fake origin for GetOrCreateHostNode().
       GURL origin("http://" + *it);
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       host_node->GetOrCreateFlashLSONode(*it);
     }
   }
 }
 
+void CookiesTreeModel::PopulateMediaLicenseInfoWithFilter(
+    LocalDataContainer* container,
+    ScopedBatchUpdateNotifier* notifier,
+    const base::string16& filter) {
+  CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
+
+  if (container->media_license_info_list_.empty())
+    return;
+
+  notifier->StartBatchUpdate();
+  for (MediaLicenseInfoList::iterator media_license_info =
+           container->media_license_info_list_.begin();
+       media_license_info != container->media_license_info_list_.end();
+       ++media_license_info) {
+    GURL origin(media_license_info->origin);
+
+    if (filter.empty() || (CookieTreeHostNode::TitleForUrl(origin).find(
+                               filter) != base::string16::npos)) {
+      CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
+      CookieTreeMediaLicensesNode* media_licenses_node =
+          host_node->GetOrCreateMediaLicensesNode();
+      media_licenses_node->AddMediaLicenseNode(
+          base::MakeUnique<CookieTreeMediaLicenseNode>(media_license_info));
+    }
+  }
+}
+
 void CookiesTreeModel::SetBatchExpectation(int batches_expected, bool reset) {
   batches_expected_ = batches_expected;
   if (reset) {
     batches_seen_ = 0;
     batches_started_ = 0;
     batches_ended_ = 0;
   } else {
     MaybeNotifyBatchesEnded();
   }
 }
@@ skipping 20 matching lines @@
   // Only notify the observers if this is the outermost call to EndBatch() if
   // called in a nested manner.
   if (batches_ended_ == batches_started_ &&
       batches_seen_ == batches_expected_) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelEndBatch(this));
     SetBatchExpectation(0, true);
   }
 }