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();

[sky, 2011/08/09 00:32:51]

nit: Can you mention this is invoked internally and normally you need not invoke
it. Having this method really makes me think this should no longer be a struct,
but that's a separate issue.

+
   // 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 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;

[sky, 2011/08/09 00:32:51]

Since the matches you care about have TemplateURL set, do we really need to
cache the keyword too? Couldn't we ask the TemplateURL for the keyword()
instead? If you need to ignore the default search engine
AutocompleteController::PopulateMatchKeywordHints( could check if the
TemplateURL corresponds to the default.

[aaron.randolph, 2011/08/16 17:52:43]

The issue with |template_url| is it is only set on KeywordProvider matches when
the keyword supports replacement.  Since the |keyword| member is used for more
than just the new functionality I added (I also changed OpenMatch calls to use
it), I believe this would make calls that currently utilize the |keyword| member
(e.g., OpenMatch) not function correctly.  

+
   // 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_