Rename ServerBoundCert => ChannelID to reflect the current name

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 <algorithm>
 #include <functional>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/linked_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/browsing_data/browsing_data_channel_id_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_cookie_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_flash_lso_helper.h"
-#include "chrome/browser/browsing_data/browsing_data_server_bound_cert_helper.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/common/extension_set.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/canonical_cookie.h"
@@ skipping 94 matching lines @@
     case CookieTreeNode::DetailedInfo::TYPE_SESSION_STORAGE:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_APPCACHE:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM:
       return true;
     case CookieTreeNode::DetailedInfo::TYPE_QUOTA:
       return false;
-    case CookieTreeNode::DetailedInfo::TYPE_SERVER_BOUND_CERT:
+    case CookieTreeNode::DetailedInfo::TYPE_CHANNEL_ID:
       return false;
     case CookieTreeNode::DetailedInfo::TYPE_FLASH_LSO:
       return false;
     default:
       break;
   }
   return false;
 }
 
 // This function returns the local data container associated with a leaf tree
@@ skipping 13 matching lines @@
 CookieTreeNode::DetailedInfo::DetailedInfo()
     : node_type(TYPE_NONE),
       cookie(NULL),
       database_info(NULL),
       local_storage_info(NULL),
       session_storage_info(NULL),
       appcache_info(NULL),
       indexed_db_info(NULL),
       file_system_info(NULL),
       quota_info(NULL),
-      server_bound_cert(NULL) {}
+      channel_id(NULL) {}
 
 CookieTreeNode::DetailedInfo::~DetailedInfo() {}
 
 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::Init(
     NodeType type) {
   DCHECK_EQ(TYPE_NONE, node_type);
   node_type = type;
   return *this;
 }
 
@@ skipping 60 matching lines @@
   return *this;
 }
 
 CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitQuota(
     const BrowsingDataQuotaHelper::QuotaInfo* quota_info) {
   Init(TYPE_QUOTA);
   this->quota_info = quota_info;
   return *this;
 }
 
-CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitServerBoundCert(
-    const net::ServerBoundCertStore::ServerBoundCert* server_bound_cert) {
-  Init(TYPE_SERVER_BOUND_CERT);
-  this->server_bound_cert = server_bound_cert;
+CookieTreeNode::DetailedInfo& CookieTreeNode::DetailedInfo::InitChannelID(
+    const net::ChannelIDStore::ChannelID* channel_id) {
+  Init(TYPE_CHANNEL_ID);
+  this->channel_id = channel_id;
   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;
 }
 
@@ skipping 223 matching lines @@
     container->quota_helper_->RevokeHostQuota(quota_info_->host);
     container->quota_info_list_.erase(quota_info_);
   }
 }
 
 CookieTreeNode::DetailedInfo CookieTreeQuotaNode::GetDetailedInfo() const {
   return DetailedInfo().InitQuota(&*quota_info_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// CookieTreeServerBoundCertNode, public:
+// CookieTreeChannelIDNode, public:
 
-CookieTreeServerBoundCertNode::CookieTreeServerBoundCertNode(
-      net::ServerBoundCertStore::ServerBoundCertList::iterator cert)
-    : CookieTreeNode(base::ASCIIToUTF16(cert->server_identifier())),
-      server_bound_cert_(cert) {
+CookieTreeChannelIDNode::CookieTreeChannelIDNode(
+      net::ChannelIDStore::ChannelIDList::iterator channel_id)
+    : CookieTreeNode(base::ASCIIToUTF16(channel_id->server_identifier())),
+      channel_id_(channel_id) {
 }
 
-CookieTreeServerBoundCertNode::~CookieTreeServerBoundCertNode() {}
+CookieTreeChannelIDNode::~CookieTreeChannelIDNode() {}
 
-void CookieTreeServerBoundCertNode::DeleteStoredObjects() {
+void CookieTreeChannelIDNode::DeleteStoredObjects() {
   LocalDataContainer* container = GetLocalDataContainerForNode(this);
 
   if (container) {
-    container->server_bound_cert_helper_->DeleteServerBoundCert(
-        server_bound_cert_->server_identifier());
-    container->server_bound_cert_list_.erase(server_bound_cert_);
+    container->channel_id_helper_->DeleteChannelID(
+        channel_id_->server_identifier());
+    container->channel_id_list_.erase(channel_id_);
   }
 }
 
 CookieTreeNode::DetailedInfo
-CookieTreeServerBoundCertNode::GetDetailedInfo() const {
-  return DetailedInfo().InitServerBoundCert(&*server_bound_cert_);
+CookieTreeChannelIDNode::GetDetailedInfo() const {
+  return DetailedInfo().InitChannelID(&*channel_id_);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeRootNode, public:
 
 CookieTreeRootNode::CookieTreeRootNode(CookiesTreeModel* model)
     : model_(model) {
 }
 
 CookieTreeRootNode::~CookieTreeRootNode() {}
@@ skipping 40 matching lines @@
 CookieTreeHostNode::CookieTreeHostNode(const GURL& url)
     : CookieTreeNode(TitleForUrl(url)),
       cookies_child_(NULL),
       databases_child_(NULL),
       local_storages_child_(NULL),
       session_storages_child_(NULL),
       appcaches_child_(NULL),
       indexed_dbs_child_(NULL),
       file_systems_child_(NULL),
       quota_child_(NULL),
-      server_bound_certs_child_(NULL),
+      channel_ids_child_(NULL),
       flash_lso_child_(NULL),
       url_(url),
       canonicalized_host_(CanonicalizeHost(url)) {}
 
 CookieTreeHostNode::~CookieTreeHostNode() {}
 
 const std::string CookieTreeHostNode::GetHost() const {
   const std::string file_origin_node_name(
       std::string(url::kFileScheme) + url::kStandardSchemeSeparator);
   return url_.SchemeIsFile() ? file_origin_node_name : url_.host();
@@ skipping 63 matching lines @@
 
 CookieTreeQuotaNode* CookieTreeHostNode::UpdateOrCreateQuotaNode(
     std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info) {
   if (quota_child_)
     return quota_child_;
   quota_child_ = new CookieTreeQuotaNode(quota_info);
   AddChildSortedByTitle(quota_child_);
   return quota_child_;
 }
 
-CookieTreeServerBoundCertsNode*
-CookieTreeHostNode::GetOrCreateServerBoundCertsNode() {
-  if (server_bound_certs_child_)
-    return server_bound_certs_child_;
-  server_bound_certs_child_ = new CookieTreeServerBoundCertsNode;
-  AddChildSortedByTitle(server_bound_certs_child_);
-  return server_bound_certs_child_;
+CookieTreeChannelIDsNode*
+CookieTreeHostNode::GetOrCreateChannelIDsNode() {
+  if (channel_ids_child_)
+    return channel_ids_child_;
+  channel_ids_child_ = new CookieTreeChannelIDsNode;
+  AddChildSortedByTitle(channel_ids_child_);
+  return channel_ids_child_;
 }
 
 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(flash_lso_child_);
   return flash_lso_child_;
@@ skipping 109 matching lines @@
 }
 
 CookieTreeFileSystemsNode::~CookieTreeFileSystemsNode() {}
 
 CookieTreeNode::DetailedInfo
 CookieTreeFileSystemsNode::GetDetailedInfo() const {
   return DetailedInfo().Init(DetailedInfo::TYPE_FILE_SYSTEMS);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// CookieTreeServerBoundCertsNode, public:
+// CookieTreeChannelIDsNode, public:
 
-CookieTreeServerBoundCertsNode::CookieTreeServerBoundCertsNode()
+CookieTreeChannelIDsNode::CookieTreeChannelIDsNode()
     : CookieTreeNode(
-        l10n_util::GetStringUTF16(IDS_COOKIES_SERVER_BOUND_CERTS)) {
+        l10n_util::GetStringUTF16(IDS_COOKIES_CHANNEL_IDS)) {
 }
 
-CookieTreeServerBoundCertsNode::~CookieTreeServerBoundCertsNode() {}
+CookieTreeChannelIDsNode::~CookieTreeChannelIDsNode() {}
 
 CookieTreeNode::DetailedInfo
-CookieTreeServerBoundCertsNode::GetDetailedInfo() const {
-  return DetailedInfo().Init(DetailedInfo::TYPE_SERVER_BOUND_CERTS);
+CookieTreeChannelIDsNode::GetDetailedInfo() const {
+  return DetailedInfo().Init(DetailedInfo::TYPE_CHANNEL_IDS);
 }
 
 void CookieTreeNode::AddChildSortedByTitle(CookieTreeNode* new_child) {
   DCHECK(new_child);
   std::vector<CookieTreeNode*>::iterator iter =
       std::lower_bound(children().begin(), children().end(), new_child,
                        NodeTitleComparator());
   GetModel()->Add(this, new_child, iter - children().begin());
 }
 
@@ skipping 89 matching lines @@
     case CookieTreeNode::DetailedInfo::TYPE_SESSION_STORAGE:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_APPCACHE:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_QUOTA:
       return -1;
-    case CookieTreeNode::DetailedInfo::TYPE_SERVER_BOUND_CERT:
+    case CookieTreeNode::DetailedInfo::TYPE_CHANNEL_ID:
       return COOKIE;  // It's kinda like a cookie?
     default:
       break;
   }
   return -1;
 }
 
 void CookiesTreeModel::DeleteAllStoredObjects() {
   NotifyObserverBeginBatch();
   CookieTreeNode* root = GetRoot();
@@ skipping 24 matching lines @@
     delete Remove(root, root->GetChild(i));
 
   PopulateCookieInfoWithFilter(data_container(), &notifier, filter);
   PopulateDatabaseInfoWithFilter(data_container(), &notifier, filter);
   PopulateLocalStorageInfoWithFilter(data_container(), &notifier, filter);
   PopulateSessionStorageInfoWithFilter(data_container(), &notifier, filter);
   PopulateAppCacheInfoWithFilter(data_container(), &notifier, filter);
   PopulateIndexedDBInfoWithFilter(data_container(), &notifier, filter);
   PopulateFileSystemInfoWithFilter(data_container(), &notifier, filter);
   PopulateQuotaInfoWithFilter(data_container(), &notifier, filter);
-  PopulateServerBoundCertInfoWithFilter(data_container(), &notifier, filter);
+  PopulateChannelIDInfoWithFilter(data_container(), &notifier, filter);
 }
 
 const extensions::ExtensionSet* CookiesTreeModel::ExtensionsProtectingNode(
     const CookieTreeNode& cookie_node) {
   if (!special_storage_policy_.get())
     return NULL;
 
   CookieTreeNode::DetailedInfo info = cookie_node.GetDetailedInfo();
 
   if (!TypeIsProtected(info.node_type))
@@ skipping 49 matching lines @@
 void CookiesTreeModel::PopulateFileSystemInfo(LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateFileSystemInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateQuotaInfo(LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateQuotaInfoWithFilter(container, &notifier, base::string16());
 }
 
-void CookiesTreeModel::PopulateServerBoundCertInfo(
+void CookiesTreeModel::PopulateChannelIDInfo(
       LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
-  PopulateServerBoundCertInfoWithFilter(container, &notifier, base::string16());
+  PopulateChannelIDInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateFlashLSOInfo(
       LocalDataContainer* container) {
   ScopedBatchUpdateNotifier notifier(this, GetRoot());
   PopulateFlashLSOInfoWithFilter(container, &notifier, base::string16());
 }
 
 void CookiesTreeModel::PopulateAppCacheInfoWithFilter(
     LocalDataContainer* container,
@@ skipping 163 matching lines @@
         base::string16::npos)) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
       CookieTreeIndexedDBsNode* indexed_dbs_node =
           host_node->GetOrCreateIndexedDBsNode();
       indexed_dbs_node->AddIndexedDBNode(
           new CookieTreeIndexedDBNode(indexed_db_info));
     }
   }
 }
 
-void CookiesTreeModel::PopulateServerBoundCertInfoWithFilter(
+void CookiesTreeModel::PopulateChannelIDInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
-  if (container->server_bound_cert_list_.empty())
+  if (container->channel_id_list_.empty())
     return;
 
   notifier->StartBatchUpdate();
-  for (ServerBoundCertList::iterator cert_info =
-           container->server_bound_cert_list_.begin();
-       cert_info != container->server_bound_cert_list_.end();
-       ++cert_info) {
-    GURL origin(cert_info->server_identifier());
+  for (ChannelIDList::iterator channel_id_info =
+           container->channel_id_list_.begin();
+       channel_id_info != container->channel_id_list_.end();
+       ++channel_id_info) {
+    GURL origin(channel_id_info->server_identifier());
     if (!origin.is_valid()) {
-      // Domain Bound Cert.  Make a valid URL to satisfy the
+      // Channel ID.  Make a valid URL to satisfy the
       // CookieTreeRootNode::GetOrCreateHostNode interface.
       origin = GURL(std::string(url::kHttpsScheme) +
           url::kStandardSchemeSeparator +
-          cert_info->server_identifier() + "/");
+          channel_id_info->server_identifier() + "/");
     }
     base::string16 title = CookieTreeHostNode::TitleForUrl(origin);
     if (!filter.size() || title.find(filter) != base::string16::npos) {
       CookieTreeHostNode* host_node = root->GetOrCreateHostNode(origin);
-      CookieTreeServerBoundCertsNode* server_bound_certs_node =
-          host_node->GetOrCreateServerBoundCertsNode();
-      server_bound_certs_node->AddServerBoundCertNode(
-          new CookieTreeServerBoundCertNode(cert_info));
+      CookieTreeChannelIDsNode* channel_ids_node =
+          host_node->GetOrCreateChannelIDsNode();
+      channel_ids_node->AddChannelIDNode(
+          new CookieTreeChannelIDNode(channel_id_info));
     }
   }
 }
 
 void CookiesTreeModel::PopulateFileSystemInfoWithFilter(
     LocalDataContainer* container,
     ScopedBatchUpdateNotifier* notifier,
     const base::string16& filter) {
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
 
@@ skipping 76 matching lines @@
 
 void CookiesTreeModel::NotifyObserverEndBatch() {
   // Only notify the observers if this is the outermost call to EndBatch() if
   // called in a nested manner.
   if (--batch_update_ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelEndBatch(this));
   }
 }