Enabled pressing TAB to cycle through the Omnibox results.

chrome/browser/autocomplete/autocomplete_match.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 "base/logging.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "grit/theme_resources.h"
 
 // AutocompleteMatch ----------------------------------------------------------
 
@@ skipping 71 matching lines @@
   // For equal-relevance matches, we sort alphabetically, so that providers
   // who return multiple elements at the same priority get a "stable" sort
   // across multiple updates.
   if (elem1.relevance == elem2.relevance)
     return elem1.contents > elem2.contents;
 
   return elem1.relevance > elem2.relevance;
 }
 
 // static
 bool AutocompleteMatch::DestinationSortFunc(const AutocompleteMatch& elem1,

[Peter Kasting, 2011/04/01 00:09:09]

Nit: Do we still use this function and the next?

                                             const AutocompleteMatch& elem2) {
   // Sort identical destination_urls together.  Place the most relevant matches
   // first, so that when we call std::unique(), these are the ones that get
   // preserved.
   return (elem1.destination_url != elem2.destination_url) ?
       (elem1.destination_url < elem2.destination_url) :
       MoreRelevant(elem1, elem2);
 }
 
 // static
 bool AutocompleteMatch::DestinationsEqual(const AutocompleteMatch& elem1,
                                           const AutocompleteMatch& elem2) {
   return elem1.destination_url == elem2.destination_url;
 }
 
 // static
+bool AutocompleteMatch::NormalizedSortFunc(const AutocompleteMatch& elem1,
+                                            const AutocompleteMatch& elem2) {
+  // Sort identical normalized_urls together.  Place the most relevant matches
+  // first, so that when we call std::unique(), these are the ones that get
+  // preserved.
+  return (elem1.normalized_url != elem2.normalized_url) ?
+    (elem1.normalized_url < elem2.normalized_url) :
+    MoreRelevant(elem1, elem2);
+}
+
+// static
+bool AutocompleteMatch::NormalizedEqual(const AutocompleteMatch& elem1,
+                                          const AutocompleteMatch& elem2) {
+  return elem1.normalized_url == elem2.normalized_url;
+}
+
+// static
+bool AutocompleteMatch::KeywordsEqual(const AutocompleteMatch& elem1,
+                                     const AutocompleteMatch& elem2) {
+  return elem1.keyword == elem2.keyword;
+}
+
+// static
 void AutocompleteMatch::ClassifyMatchInString(
     const string16& find_text,
     const string16& text,
     int style,
     ACMatchClassifications* classification) {
   ClassifyLocationInString(text.find(find_text), find_text.length(),
                            text.length(), style, classification);
 }
 
 void AutocompleteMatch::ClassifyLocationInString(
@@ skipping 25 matching lines @@
   classification->push_back(ACMatchClassification(match_location,
       (style | ACMatchClassification::MATCH) & ~ACMatchClassification::DIM));
 
   // Mark post-match portion of string (if any).
   const size_t after_match(match_location + match_length);
   if (after_match < overall_length) {
     classification->push_back(ACMatchClassification(after_match, style));
   }
 }
 
+
+void AutocompleteMatch::NormalizeDestination() {
+  static const char prefix[] = "www.";
+  static const int prefix_len = strlen(prefix);
+
+  if (destination_url.is_valid() && normalized_url.is_empty()) {

[Peter Kasting, 2011/04/01 00:09:09]

Nit: I would combine this check with the compare() call, so that for invalid
destinations we just copy the destination to the normalized URL.

+    std::string host = destination_url.host();
+
+    if (host.compare(0, prefix_len, prefix) == 0) {
+      host.erase(0, prefix_len);

[Peter Kasting, 2011/04/01 00:09:09]

Nit: You can eliminate this and use host.substr(...) in the SetHostStr() call
below.

+
+      GURL::Replacements replace_host;
+      replace_host.SetHostStr(host);
+      normalized_url = destination_url.ReplaceComponents(replace_host);
+    } else {
+      normalized_url = destination_url;
+    }
+  }
+}
+
 #ifndef NDEBUG
 void AutocompleteMatch::Validate() const {
   ValidateClassifications(contents, contents_class);
   ValidateClassifications(description, description_class);
 }
 
 void AutocompleteMatch::ValidateClassifications(
     const string16& text,
     const ACMatchClassifications& classifications) const {
   if (text.empty()) {
@@ skipping 10 matching lines @@
   // The classifications should always be sorted.
   size_t last_offset = classifications[0].offset;
   for (ACMatchClassifications::const_iterator i(classifications.begin() + 1);
        i != classifications.end(); ++i) {
     DCHECK(i->offset > last_offset) << "Classification unsorted";
     DCHECK(i->offset < text.length()) << "Classification out of bounds";
     last_offset = i->offset;
   }
 }
 #endif