Initial implementation of dedupping search provider's URLs.

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"
 #include "chrome/browser/autocomplete/autocomplete_input.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
+#include "chrome/browser/search_engines/template_url_prepopulate_data.h"

[Peter Kasting, 2012/10/26 22:13:49]

Nit: Not necessary?

[Bart N., 2012/10/26 23:36:55]

Good catch, yes.

 
 // static
 const size_t AutocompleteResult::kMaxMatches = 6;
 const int AutocompleteResult::kLowestDefaultScore = 1200;
 
 void AutocompleteResult::Selection::Clear() {
   destination_url = GURL();
   provider_affinity = NULL;
   is_history_what_you_typed_match = false;
 }
@@ skipping 17 matching lines @@
   matches_ = rhs.matches_;
   // Careful!  You can't just copy iterators from another container, you have to
   // reconstruct them.
   default_match_ = (rhs.default_match_ == rhs.end()) ?
       end() : (begin() + (rhs.default_match_ - rhs.begin()));
 
   alternate_nav_url_ = rhs.alternate_nav_url_;
 }
 
 void AutocompleteResult::CopyOldMatches(const AutocompleteInput& input,
-                                        const AutocompleteResult& old_matches) {
+                                        const AutocompleteResult& old_matches,
+                                        Profile* profile) {
   if (old_matches.empty())
     return;
 
   if (empty()) {
     // If we've got no matches we can copy everything from the last result.
     CopyFrom(old_matches);
     for (ACMatches::iterator i(begin()); i != end(); ++i)
       i->from_previous = true;
     return;
   }
@@ skipping 14 matching lines @@
   // matches, the new ones will all become visible, so we won't have lost
   // anything permanently.
   ProviderToMatches matches_per_provider, old_matches_per_provider;
   BuildProviderToMatches(&matches_per_provider);
   old_matches.BuildProviderToMatches(&old_matches_per_provider);
   for (ProviderToMatches::const_iterator i(old_matches_per_provider.begin());
        i != old_matches_per_provider.end(); ++i) {
     MergeMatchesByProvider(i->second, matches_per_provider[i->first]);
   }
 
-  SortAndCull(input);
+  SortAndCull(input, profile);
 }
 
 void AutocompleteResult::AppendMatches(const ACMatches& matches) {
 #ifndef NDEBUG
   for (ACMatches::const_iterator i(matches.begin()); i != matches.end(); ++i) {
     DCHECK_EQ(AutocompleteMatch::SanitizeString(i->contents), i->contents);
     DCHECK_EQ(AutocompleteMatch::SanitizeString(i->description),
               i->description);
   }
 #endif
   std::copy(matches.begin(), matches.end(), std::back_inserter(matches_));
   default_match_ = end();
   alternate_nav_url_ = GURL();
 }
 
 void AutocompleteResult::AddMatch(const AutocompleteMatch& match) {
   DCHECK(default_match_ != end());
   DCHECK_EQ(AutocompleteMatch::SanitizeString(match.contents), match.contents);
   DCHECK_EQ(AutocompleteMatch::SanitizeString(match.description),
             match.description);
   ACMatches::iterator insertion_point =
       std::upper_bound(begin(), end(), match, &AutocompleteMatch::MoreRelevant);
   matches_difference_type default_offset = default_match_ - begin();
   if ((insertion_point - begin()) <= default_offset)
     ++default_offset;
   matches_.insert(insertion_point, match);
   default_match_ = begin() + default_offset;
 }
 
-void AutocompleteResult::SortAndCull(const AutocompleteInput& input) {
+void AutocompleteResult::SortAndCull(const AutocompleteInput& input,
+                                     Profile* profile) {
   for (ACMatches::iterator i(matches_.begin()); i != matches_.end(); ++i)
-    i->ComputeStrippedDestinationURL();
+    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());
 
   // Sort and trim to the most relevant kMaxMatches matches.
   const size_t num_matches = std::min(kMaxMatches, matches_.size());
@@ skipping 113 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(match);
       delta--;
     }
   }
 }