Store creating url in origin nodes and use it for content settings.

chrome/browser/cookies_tree_model.cc

 // Copyright (c) 2010 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/cookies_tree_model.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
@@ skipping 156 matching lines @@
       local_storage_info_(local_storage_info) {
 }
 
 void CookieTreeLocalStorageNode::DeleteStoredObjects() {
   GetModel()->local_storage_helper_->DeleteLocalStorageFile(
       local_storage_info_->file_path);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeRootNode, public:
+
 CookieTreeOriginNode* CookieTreeRootNode::GetOrCreateOriginNode(
-    const std::wstring& origin) {
-  // Strip the leading dot if it exists.
-  std::wstring rewritten_origin = origin;
-  if (origin.length() >= 1 && origin[0] == '.')
-    rewritten_origin = origin.substr(1);
-
-  CookieTreeOriginNode rewritten_origin_node(rewritten_origin);
+    const GURL& url) {
+  CookieTreeOriginNode origin_node(url);
 
   // First see if there is an existing match.
   std::vector<CookieTreeNode*>::iterator origin_node_iterator =
       lower_bound(children().begin(),
                   children().end(),
-                  &rewritten_origin_node,
+                  &origin_node,
                   OriginNodeComparator());
 
-  if (origin_node_iterator != children().end() && rewritten_origin ==
+  if (origin_node_iterator != children().end() &&
+      CookieTreeOriginNode::TitleForUrl(url) ==
       (*origin_node_iterator)->GetTitle())
     return static_cast<CookieTreeOriginNode*>(*origin_node_iterator);
   // Node doesn't exist, create a new one and insert it into the (ordered)
   // children.
-  CookieTreeOriginNode* retval = new CookieTreeOriginNode(rewritten_origin);
+  CookieTreeOriginNode* retval = new CookieTreeOriginNode(url);
   DCHECK(model_);
   model_->Add(this, (origin_node_iterator - children().begin()), retval);
   return retval;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeOriginNode, public:
 
+// static
+std::wstring CookieTreeOriginNode::TitleForUrl(
+    const GURL& url) {
+  return UTF8ToWide(url.SchemeIsFile() ? kFileOriginNodeName : url.host());
+}
+
+CookieTreeOriginNode::CookieTreeOriginNode(const GURL& url)
+    : CookieTreeNode(TitleForUrl(url)),
+      cookies_child_(NULL),
+      databases_child_(NULL),
+      local_storages_child_(NULL),
+      appcaches_child_(NULL),
+      url_(url) {}
+
+
 CookieTreeCookiesNode* CookieTreeOriginNode::GetOrCreateCookiesNode() {
   if (cookies_child_)
     return cookies_child_;
   cookies_child_ = new CookieTreeCookiesNode;
   AddChildSortedByTitle(cookies_child_);
   return cookies_child_;
 }
 
 CookieTreeDatabasesNode* CookieTreeOriginNode::GetOrCreateDatabasesNode() {
   if (databases_child_)
@@ skipping 14 matching lines @@
 
 CookieTreeAppCachesNode* CookieTreeOriginNode::GetOrCreateAppCachesNode() {
   if (appcaches_child_)
     return appcaches_child_;
   appcaches_child_ = new CookieTreeAppCachesNode;
   AddChildSortedByTitle(appcaches_child_);
   return appcaches_child_;
 }
 
 void CookieTreeOriginNode::CreateContentException(
-    HostContentSettingsMap* content_settings, ContentSetting setting) {
-    std::wstring title(GetTitle());
-    content_settings->AddExceptionForURL(GURL(WideToUTF16(title)),
+    HostContentSettingsMap* content_settings, ContentSetting setting) const {
+  if (CanCreateContentException()) {
+    content_settings->AddExceptionForURL(url_,
                                          CONTENT_SETTINGS_TYPE_COOKIES,
                                          setting);
+  }
+}
+
+bool CookieTreeOriginNode::CanCreateContentException() const {
+  return !url_.SchemeIsFile();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeCookiesNode, public:
 
 CookieTreeCookiesNode::CookieTreeCookiesNode()
     : CookieTreeNode(l10n_util::GetString(IDS_COOKIES_COOKIES)) {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 121 matching lines @@
   LoadCookiesWithFilter(std::wstring());
 }
 
 void CookiesTreeModel::LoadCookiesWithFilter(const std::wstring& filter) {
   // mmargh mmargh mmargh!
 
   all_cookies_ = cookie_monster_->GetAllCookies();
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
   for (CookieList::iterator it = all_cookies_.begin();
        it != all_cookies_.end(); ++it) {
-    std::wstring origin_node_name = UTF8ToWide(it->first);
+    std::string origin_host = it->first;
+    if (origin_host.length() > 1 && origin_host[0] == '.')
+      origin_host = it->first.substr(1);
+    // We treat secure cookies just the same as normal ones.
+    GURL origin(std::string(chrome::kHttpScheme) +
+                chrome::kStandardSchemeSeparator + origin_host + "/");
     if (!filter.size() ||
-        (origin_node_name.find(filter) != std::wstring::npos)) {
+        (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
+         std::string::npos)) {
       CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin_node_name);
+          root->GetOrCreateOriginNode(origin);
       CookieTreeCookiesNode* cookies_node =
           origin_node->GetOrCreateCookiesNode();
       CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(&*it);
       cookies_node->AddCookieNode(new_cookie);
     }
   }
 }
 
 void CookiesTreeModel::DeleteAllStoredObjects() {
   NotifyObserverBeginBatch();
@@ skipping 60 matching lines @@
 
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
   NotifyObserverBeginBatch();
   for (InfoByOrigin::const_iterator origin =
            appcache_info_->infos_by_origin.begin();
        origin != appcache_info_->infos_by_origin.end(); ++origin) {
     std::wstring origin_node_name = UTF8ToWide(origin->first.host());
     if (filter.empty() ||
         (origin_node_name.find(filter) != std::wstring::npos)) {
       CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin_node_name);
+          root->GetOrCreateOriginNode(origin->first);
       CookieTreeAppCachesNode* appcaches_node =
           origin_node->GetOrCreateAppCachesNode();
 
       for (AppCacheInfoVector::const_iterator info = origin->second.begin();
            info != origin->second.end(); ++info) {
         appcaches_node->AddAppCacheNode(
             new CookieTreeAppCacheNode(&(*info)));
       }
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
 void CookiesTreeModel::OnDatabaseModelInfoLoaded(
     const DatabaseInfoList& database_info) {
   database_info_list_ = database_info;
   PopulateDatabaseInfoWithFilter(std::wstring());
 }
 
 void CookiesTreeModel::PopulateDatabaseInfoWithFilter(
     const std::wstring& filter) {
   if (database_info_list_.empty())
     return;
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
   NotifyObserverBeginBatch();
   for (DatabaseInfoList::iterator database_info = database_info_list_.begin();
        database_info != database_info_list_.end();
        ++database_info) {
-    // Determine which 'origin' node to place each 'info' in.
-    std::wstring origin_node_name;
-    if (database_info->IsFileSchemeData())
-      origin_node_name = UTF8ToWide(kFileOriginNodeName);
-    else
-      origin_node_name = UTF8ToWide(database_info->host);
+    GURL origin(database_info->origin);
 
     if (!filter.size() ||
-        (origin_node_name.find(filter) != std::wstring::npos)) {
+        (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
+         std::wstring::npos)) {
       CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin_node_name);
+          root->GetOrCreateOriginNode(origin);
       CookieTreeDatabasesNode* databases_node =
           origin_node->GetOrCreateDatabasesNode();
       databases_node->AddDatabaseNode(
           new CookieTreeDatabaseNode(&(*database_info)));
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
 void CookiesTreeModel::OnStorageModelInfoLoaded(
     const LocalStorageInfoList& local_storage_info) {
   local_storage_info_list_ = local_storage_info;
   PopulateLocalStorageInfoWithFilter(std::wstring());
 }
 
 void CookiesTreeModel::PopulateLocalStorageInfoWithFilter(
     const std::wstring& filter) {
   if (local_storage_info_list_.empty())
     return;
   CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
   NotifyObserverBeginBatch();
   for (LocalStorageInfoList::iterator local_storage_info =
        local_storage_info_list_.begin();
        local_storage_info != local_storage_info_list_.end();
        ++local_storage_info) {
-    // Determine which 'origin' node to place each 'info' in.
-    std::wstring origin_node_name;
-    if (local_storage_info->IsFileSchemeData())
-      origin_node_name = UTF8ToWide(kFileOriginNodeName);
-    else
-      origin_node_name = UTF8ToWide(local_storage_info->host);
+    GURL origin(local_storage_info->origin);
 
     if (!filter.size() ||
-        (origin_node_name.find(filter) != std::wstring::npos)) {
+        (CookieTreeOriginNode::TitleForUrl(origin).find(filter) !=
+         std::wstring::npos)) {
       CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(origin_node_name);
+          root->GetOrCreateOriginNode(origin);
       CookieTreeLocalStoragesNode* local_storages_node =
           origin_node->GetOrCreateLocalStoragesNode();
       local_storages_node->AddLocalStorageNode(
           new CookieTreeLocalStorageNode(&(*local_storage_info)));
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
 void CookiesTreeModel::NotifyObserverBeginBatch() {
   // Only notify the model once if we're batching in a nested manner.
   if (batch_update_++ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelBeginBatch(this));
   }
 }
 
 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));
   }
 }