Enabled pressing TAB to cycle through the Omnibox results.

chrome/browser/autocomplete/autocomplete_match.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_MATCH_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_MATCH_H_
 #pragma once
 
 #include <vector>
 #include <string>
 
+#include "base/memory/ref_counted.h"
+#include "chrome/browser/profiles/profile.h"
 #include "content/common/page_transition_types.h"
 #include "googleurl/src/gurl.h"
 
 class AutocompleteProvider;
 class PageTransition;
 class TemplateURL;
 
 // AutocompleteMatch ----------------------------------------------------------
 
 // A single result line with classified spans.  The autocomplete popup displays
@@ skipping 34 matching lines @@
     }
 
     // Offset within the string that this classification starts
     size_t offset;
 
     int style;
   };
 
   typedef std::vector<ACMatchClassification> ACMatchClassifications;
 
+  struct Keyword : public base::RefCounted<Keyword> {
+    Keyword(const string16& keyword_text, bool keyword_hint, bool keyword_mode)
+        : text(keyword_text), is_keyword_hint(keyword_hint),
+          is_keyword_mode(keyword_mode) {
+    }
+
+    string16 text;
+
+    const TemplateURL* template_url;
+
+    // True if this match should show a keyword hint.
+    bool is_keyword_hint;
+
+    // True if the keyword has been accepted or if the default
+    // is to show keyword mode.
+    bool is_keyword_mode;
+  };
+
   // The type of this match.
   enum Type {
     URL_WHAT_YOU_TYPED = 0,  // The input as a URL.
     HISTORY_URL,             // A past page whose URL contains the input.
     HISTORY_TITLE,           // A past page whose title contains the input.
     HISTORY_BODY,            // A past page whose body contains the input.
     HISTORY_KEYWORD,         // A past page whose keyword contains the input.
     NAVSUGGEST,              // A suggested URL.
     SEARCH_WHAT_YOU_TYPED,   // The input as a search query (with the default
                              // engine).
@@ skipping 15 matching lines @@
   static std::string TypeToString(Type type);
 
   // Converts |type| to a resource identifier for the appropriate icon for this
   // type.
   static int TypeToIcon(Type type);
 
   // Comparison function for determining when one match is better than another.
   static bool MoreRelevant(const AutocompleteMatch& elem1,
                            const AutocompleteMatch& elem2);
 
   // Comparison functions for removing matches with duplicate destinations.

[Peter Kasting, 2011/04/11 23:17:33]

Nit: You should document and/or name the functions to make it clear these act on
the stripped destinations.

   static bool DestinationSortFunc(const AutocompleteMatch& elem1,
                                   const AutocompleteMatch& elem2);
   static bool DestinationsEqual(const AutocompleteMatch& elem1,
                                 const AutocompleteMatch& elem2);
 
   // Helper functions for classes creating matches:
   // Fills in the classifications for |text|, using |style| as the base style
   // and marking the first instance of |find_text| as a match.  (This match
   // will also not be dimmed, if |style| has DIM set.)
   static void ClassifyMatchInString(const string16& find_text,
                                     const string16& text,
                                     int style,
                                     ACMatchClassifications* classifications);
 
   // Similar to ClassifyMatchInString(), but for cases where the range to mark
   // as matching is already known (avoids calling find()).  This can be helpful
   // when find() would be misleading (e.g. you want to mark the second match in
   // a string instead of the first).
   static void ClassifyLocationInString(size_t match_location,
                                        size_t match_length,
                                        size_t overall_length,
                                        int style,
                                        ACMatchClassifications* classifications);
 
+  // Copies the destination_url with "www." stripped off to
+  // stripped_destination_url

[Peter Kasting, 2011/04/11 23:17:33]

Nit: Add trailing period.  I suggest using || around member names too.

+  void ComputeStrippedDestinationURL();
+
   // The provider of this match, used to remember which provider the user had
   // selected when the input changes. This may be NULL, in which case there is
   // no provider (or memory of the user's selection).
   AutocompleteProvider* provider;
 
   // The relevance of this match. See table in autocomplete.h for scores
   // returned by various providers. This is used to rank matches among all
   // responding providers, so different providers must be carefully tuned to
   // supply matches with appropriate relevance.
   //
@@ skipping 12 matching lines @@
   // The position within fill_into_edit from which we'll display the inline
   // autocomplete string.  This will be string16::npos if this match should
   // not be inline autocompleted.
   size_t inline_autocomplete_offset;
 
   // The URL to actually load when the autocomplete item is selected. This URL
   // should be canonical so we can compare URLs with strcmp to avoid dupes.
   // It may be empty if there is no possible navigation.
   GURL destination_url;
 
+  // The destination URL with "www." stripped off for better dupe finding.
+  GURL stripped_destination_url;
+
   // The main text displayed in the address bar dropdown.
   string16 contents;
   ACMatchClassifications contents_class;
 
   // Additional helper text for each entry, such as a title or description.
   string16 description;
   ACMatchClassifications description_class;
 
   // The transition type to use when the user opens this match.  By default
   // this is TYPED.  Providers whose matches do not look like URLs should set
   // it to GENERATED.
   PageTransition::Type transition;
 
   // True when this match is the "what you typed" match from the history
   // system.
   bool is_history_what_you_typed_match;
 
   // Type of this match.
   Type type;
 
   // If this match corresponds to a keyword, this is the TemplateURL the
   // keyword was obtained from.
   const TemplateURL* template_url;
 
+  // Keyword for this match.
+  scoped_refptr<Keyword> keyword;
+
   // True if the user has starred the destination URL.
   bool starred;
 
   // True if this match is from a previous result.
   bool from_previous;
 
 #ifndef NDEBUG
   // Does a data integrity check on this match.
   void Validate() const;
 
   // Checks one text/classifications pair for valid values.
   void ValidateClassifications(
       const string16& text,
       const ACMatchClassifications& classifications) const;
 #endif
 };
 
 typedef AutocompleteMatch::ACMatchClassification ACMatchClassification;
 typedef std::vector<ACMatchClassification> ACMatchClassifications;
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_AUTOCOMPLETE_MATCH_H_