Don't demote top match for certain match types.

chrome/browser/autocomplete/autocomplete_result.cc

 // Copyright (c) 2012 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 "chrome/browser/autocomplete/autocomplete_result.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 135 matching lines @@
                                      Profile* profile) {
   for (ACMatches::iterator i(matches_.begin()); i != matches_.end(); ++i)
     i->ComputeStrippedDestinationURL(profile);
 
   // Remove duplicates.
   std::sort(matches_.begin(), matches_.end(),
             &AutocompleteMatch::DestinationSortFunc);
   matches_.erase(std::unique(matches_.begin(), matches_.end(),
                              &AutocompleteMatch::DestinationsEqual),
                  matches_.end());
+  size_t max_num_matches = std::min(kMaxMatches, matches_.size());

[Mark P, 2013/11/04 18:47:56]

Can you put this "don't demote top match under certain conditions" logic in the
ComparingObject somehow?

The reason for my request is that ComparingObject is used in two places.  You've
corrected to make one not do the demotion.  I'm not sure if you noticed the
other place, a place you didn't change.  See line 334.

I'd prefer the logic in ComparingObject but if you can't manage to do that you
can put logic as necessary around line 334.  (Logic may or may not actually be
necessary; I haven't thought about it.  Regardless, something needs to go there,
if only a comment explaining why nothing is needed there.)

[H Fung, 2013/11/04 19:44:08]

I think that would require CompareWithDemoteByType to know whether
AutocompleteMatch was the first match.  I originally added an extra variable in
AutocompleteMatch but Peter suggested removing it.  (I think both solutions are
kind of messy)
Comment added.  I only found one non-test where AddMatch is called
(CopyOldMatches calls MergeMatchesByProvider calls AddMatch, and CopyOldMatches
calls SortAndCull afterwards)

+
+  // Don't demote the top match if applicable.
+  OmniboxFieldTrial::UndemotableTopMatchTypes undemotable_top_types;
+  OmniboxFieldTrial::GetUndemotableTopTypes(input.current_page_classification(),
+                                            &undemotable_top_types);
+  const bool have_top_undemotable_match = !matches_.empty() &&
+      undemotable_top_types.find(matches_.begin()->type) !=
+      undemotable_top_types.end();
+  AutocompleteMatch top_undemotable_match;
+  if (have_top_undemotable_match) {
+    top_undemotable_match = *matches_.begin();
+    matches_.erase(matches_.begin());
+  }
 
   // Sort and trim to the most relevant kMaxMatches matches.
-  size_t max_num_matches = std::min(kMaxMatches, matches_.size());
   CompareWithDemoteByType comparing_object(input.current_page_classification());
   std::sort(matches_.begin(), matches_.end(), comparing_object);
+  if (have_top_undemotable_match)
+    matches_.insert(matches_.begin(), top_undemotable_match);
   if (!matches_.empty() && !matches_.begin()->allowed_to_be_default_match &&
       OmniboxFieldTrial::ReorderForLegalDefaultMatch(
           input.current_page_classification())) {
     // Top match is not allowed to be the default match.  Find the most
     // relevant legal match and shift it to the front.
     for (AutocompleteResult::iterator it = matches_.begin() + 1;
          it != matches_.end(); ++it) {
       if (it->allowed_to_be_default_match) {
         std::rotate(matches_.begin(), it, it + 1);
         break;
@@ skipping 191 matching lines @@
        i != old_matches.rend() && delta > 0; ++i) {
     if (!HasMatchByDestination(*i, new_matches)) {
       AutocompleteMatch match = *i;
       match.relevance = std::min(max_relevance, match.relevance);
       match.from_previous = true;
       AddMatch(page_classification, match);
       delta--;
     }
   }
 }