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/scoped_ptr.h"
 #include "content/public/common/page_transition_types.h"
 #include "googleurl/src/gurl.h"
 
 class AutocompleteProvider;
 class TemplateURL;
 
 // AutocompleteMatch ----------------------------------------------------------
 
 // A single result line with classified spans.  The autocomplete popup displays
 // the 'contents' and the 'description' (the description is optional) in the
@@ skipping 61 matching lines @@
 
   // Null-terminated array of characters that are not valid within |contents|
   // and |description| strings.
   static const char16 kInvalidChars[];
 
   AutocompleteMatch();
   AutocompleteMatch(AutocompleteProvider* provider,
                     int relevance,
                     bool deletable,
                     Type type);
+  AutocompleteMatch(const AutocompleteMatch& match);
   ~AutocompleteMatch();
 
+  AutocompleteMatch& operator=(const AutocompleteMatch& match);
+
   // Converts |type| to a string representation.  Used in logging.
   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.
+  // Destinations are compared using |stripped_destination_url|.
   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);
 
   // Removes invalid characters from |text|. Should be called on strings coming
   // from external sources (such as extensions) before assigning to |contents|
   // or |description|.
   static string16 SanitizeString(const string16& text);
 
+  // Copies the destination_url with "www." stripped off to
+  // |stripped_destination_url|.  This method is invoked internally by the
+  // AutocompleteController and does not normally need to be invoked.
+  void ComputeStrippedDestinationURL();
+
+  // Gets the selected keyword or keyword hint for this match. Returns
+  // true if |keyword| represents a keyword hint, or false if |keyword|
+  // represents a selected keyword. (|keyword| will always be set [though
+  // possibly to the empty string], and you cannot have both a selected keyword
+  // and a keyword hint simultaneously.)  If the match is already a keyword
+  // then the keyword will be set directly.  Otherwise, if
+  // |associated_keyword| is set then that value will be used.

[Peter Kasting, 2012/01/11 03:00:16]

Nit: If I understand your comments correctly, I think the last two sentences can
simply be removed -- the overall meaning doesn't change and the lack of
implementation detail is fine for a header (and doesn't make it sound at first
as if you're contradicting yourself or something, like the current text sort of
does).

+  bool GetKeyword(string16* keyword) const;
+
   // 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.
   content::PageTransition 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;
 
+  // Set with a keyword provider match if this match can show a keyword hint.
+  // For example, if this is a SearchProvider match for "www.amazon.com",
+  // |associated_keyword| could be a KeywordProvider match for "amazon.com".
+  scoped_ptr<AutocompleteMatch> associated_keyword;
+
+  // For matches that correspond to valid substituting keywords ("search
+  // engines" that aren't the default engine, or extension keywords), this
+  // is the keyword.  If this is set, then when displaying this match, the
+  // edit will use the "keyword mode" UI that shows a blue
+  // "Search <engine name>" chit before the user's typing.  This should be
+  // set for any match that's an |associated_keyword| of a match in the main
+  // result list, as well as any other matches in the main result list that
+  // are direct keyword matches (e.g. if the user types in a keyword name and
+  // some search terms directly).
+  string16 keyword;
+
   // Indicates the TemplateURL the match originated from. This is set for
   // keywords as well as matches for the default search provider.
   const TemplateURL* template_url;
 
   // 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_