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/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 58 matching lines @@
     EXTENSION_APP,           // An Extension App with a title/url that contains
                              // the input.
     NUM_TYPES,
   };
 
   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);
 
+  // Copies the destination_url with "www." stripped off to
+  // |stripped_destination_url|.
+  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;
 
+  // Set if this match has a keyword hint.

[Peter Kasting, 2011/07/27 20:18:25]

Nit: I'm a little concerned about potential confusion with there being
|keyword|, |associated_keyword|, and |template_url| fields all here.  It seems
like maybe we need more detailed comments with examples?

+  scoped_ptr<AutocompleteMatch> associated_keyword;
+
+  // If this match corresponds to a keyword, this is the keyword text.
+  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_