Sort the origins in the cookies_tree_model by effective TLD, as opposed...

chrome/browser/cookies_tree_model.cc

 // Copyright (c) 2009 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>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/table_model_observer.h"
 #include "app/tree_node_model.h"
 #include "base/linked_ptr.h"
 #include "base/string_util.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/profile.h"
 #include "grit/app_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/cookie_monster.h"
+#include "net/base/registry_controlled_domain.h"
 #include "net/url_request/url_request_context.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeNode, public:
 
 void CookieTreeNode::DeleteStoredObjects() {
   std::for_each(children().begin(),
                 children().end(),
@@ skipping 19 matching lines @@
 void CookieTreeCookieNode::DeleteStoredObjects() {
   GetModel()->DeleteCookie(*cookie_);
 }
 
 namespace {
 // comparison functor, for use in CookieTreeRootNode
 class OriginNodeComparator {
  public:
   bool operator() (const CookieTreeNode* lhs,
                    const CookieTreeNode* rhs) {
-    return (lhs->GetTitle() < rhs->GetTitle());
+    // We want to order by registry controlled domain, so we would get
+    // google.com, ad.google.com, www.google.com,
+    // microsoft.com, ad.microsoft.com. CanonicalizeHost transforms the origins
+    // into a form like google.com.www so that string comparisons work.
+    return (CanonicalizeHost(lhs->GetTitle()) <
+            CanonicalizeHost(rhs->GetTitle()));
+  }
+
+ private:
+  std::string CanonicalizeHost(const std::wstring& host_w) {
+    // The canonicalized representation makes the registry controlled domain
+    // come first, and then adds subdomains in reverse order, e.g.
+    // 1.mail.google.com would become google.com.mail.1, and then a standard
+    // string comparison works to order hosts by registry controlled domain
+    // first. Leading dots are ignored, ".google.com" is the same as
+    // "google.com".
+
+    std::string host = WideToUTF8(host_w);
+    std::string retval = net::RegistryControlledDomainService::
+        GetDomainAndRegistry(host);
+    if (!retval.length())  // Is an IP address or other special origin.
+      return host;
+
+    std::string::size_type position = host.rfind(retval);
+
+    // The host may be the registry controlled domain, in which case fail fast.
+    if (position == 0 || position == std::string::npos)
+      return host;
+
+    // If host is www.google.com, retval will contain google.com at this point.
+    // Start operating to the left of the registry controlled domain, e.g. in
+    // the www.google.com example, start at index 3.
+    --position;
+
+    // If position == 0, that means it's a dot; this will be ignored to treat
+    // ".google.com" the same as "google.com".
+    while (position > 0) {
+      retval += std::string(".");
+      // Copy up to the next dot. host[position] is a dot so start after it.
+      std::string::size_type next_dot = host.rfind(".", position - 1);
+      if (next_dot == std::string::npos) {
+        retval += host.substr(0, position);
+        break;
+      }
+      retval += host.substr(next_dot + 1, position - (next_dot + 1));
+      position = next_dot;
+    }
+    return retval;
   }
 };
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookieTreeRootNode, public:
 CookieTreeOriginNode* CookieTreeRootNode::GetOrCreateOriginNode(
     const std::wstring& origin) {
   // Strip the trailing dot if it exists.
@@ skipping 149 matching lines @@
   NotifyObserverTreeNodeChanged(root);
 }
 
 void CookiesTreeModel::DeleteCookieNode(CookieTreeNode* cookie_node) {
   cookie_node->DeleteStoredObjects();
   // find the parent and index
   CookieTreeNode* parent_node = cookie_node->GetParent();
   int cookie_node_index = parent_node->IndexOfChild(cookie_node);
   delete Remove(parent_node, cookie_node_index);
 }