Part 5 of search provider refactoring.

chrome/browser/autocomplete/base_search_provider.cc

 // Copyright 2014 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/base_search_provider.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
@@ skipping 24 matching lines @@
                                        AutocompleteProvider::Type type)
     : AutocompleteProvider(listener, profile, type),
       field_trial_triggered_(false),
       field_trial_triggered_in_session_(false) {}
 
 // static
 bool BaseSearchProvider::ShouldPrefetch(const AutocompleteMatch& match) {
   return match.GetAdditionalInfo(kShouldPrefetchKey) == kTrue;
 }
 
+void BaseSearchProvider::Stop(bool clear_cached_results) {
+  StopSuggest();
+  done_ = true;
+
+  if (clear_cached_results)
+    ClearAllResults();
+}
+
 void BaseSearchProvider::AddProviderInfo(ProvidersInfo* provider_info) const {
   provider_info->push_back(metrics::OmniboxEventProto_ProviderInfo());
   metrics::OmniboxEventProto_ProviderInfo& new_entry = provider_info->back();
   new_entry.set_provider(AsOmniboxEventProviderType());
   new_entry.set_provider_done(done_);
   std::vector<uint32> field_trial_hashes;
   OmniboxFieldTrial::GetActiveSuggestFieldTrialHashes(&field_trial_hashes);
   for (size_t i = 0; i < field_trial_hashes.size(); ++i) {
     if (field_trial_triggered_)
       new_entry.mutable_field_trial_triggered()->Add(field_trial_hashes[i]);
@@ skipping 404 matching lines @@
   // already in |map|, replace it if |match| is more relevant.
   // NOTE: Keep this ToLower() call in sync with url_database.cc.
   MatchKey match_key(
       std::make_pair(base::i18n::ToLower(result.suggestion()),
                      match.search_terms_args->suggest_query_params));
   const std::pair<MatchMap::iterator, bool> i(
        map->insert(std::make_pair(match_key, match)));
 
   bool should_prefetch = result.should_prefetch();
   if (!i.second) {
-     // NOTE: We purposefully do a direct relevance comparison here instead of
-     // using AutocompleteMatch::MoreRelevant(), so that we'll prefer "items
-     // added first" rather than "items alphabetically first" when the scores
-     // are equal. The only case this matters is when a user has results with
-     // the same score that differ only by capitalization; because the history
-     // system returns results sorted by recency, this means we'll pick the most
-     // recent such result even if the precision of our relevance score is too
-     // low to distinguish the two.
-     if (match.relevance > i.first->second.relevance) {
-       i.first->second = match;
-     } else if (match.keyword == i.first->second.keyword) {
-       // Old and new matches are from the same search provider. It is okay to
-       // record one match's prefetch data onto a different match (for the same
-       // query string) for the following reasons:
-       // 1. Because the suggest server only sends down a query string from
-       // which we construct a URL, rather than sending a full URL, and because
-       // we construct URLs from query strings in the same way every time, the
-       // URLs for the two matches will be the same. Therefore, we won't end up
-       // prefetching something the server didn't intend.
-       // 2. Presumably the server sets the prefetch bit on a match it things is
-       // sufficiently relevant that the user is likely to choose it. Surely
-       // setting the prefetch bit on a match of even higher relevance won't
-       // violate this assumption.
-       should_prefetch |= ShouldPrefetch(i.first->second);
-       i.first->second.RecordAdditionalInfo(kShouldPrefetchKey,
-                                            should_prefetch ? kTrue : kFalse);
-       if (should_prefetch)
-         i.first->second.RecordAdditionalInfo(kSuggestMetadataKey, metadata);
-     }
-   }
+    // NOTE: We purposefully do a direct relevance comparison here instead of
+    // using AutocompleteMatch::MoreRelevant(), so that we'll prefer "items
+    // added first" rather than "items alphabetically first" when the scores
+    // are equal. The only case this matters is when a user has results with
+    // the same score that differ only by capitalization; because the history
+    // system returns results sorted by recency, this means we'll pick the most
+    // recent such result even if the precision of our relevance score is too
+    // low to distinguish the two.
+    if (match.relevance > i.first->second.relevance) {
+      i.first->second = match;
+    } else if (match.keyword == i.first->second.keyword) {
+      // Old and new matches are from the same search provider. It is okay to
+      // record one match's prefetch data onto a different match (for the same
+      // query string) for the following reasons:
+      // 1. Because the suggest server only sends down a query string from
+      // which we construct a URL, rather than sending a full URL, and because
+      // we construct URLs from query strings in the same way every time, the
+      // URLs for the two matches will be the same. Therefore, we won't end up
+      // prefetching something the server didn't intend.
+      // 2. Presumably the server sets the prefetch bit on a match it things is
+      // sufficiently relevant that the user is likely to choose it. Surely
+      // setting the prefetch bit on a match of even higher relevance won't
+      // violate this assumption.
+      should_prefetch |= ShouldPrefetch(i.first->second);
+      i.first->second.RecordAdditionalInfo(kShouldPrefetchKey,
+                                           should_prefetch ? kTrue : kFalse);
+      if (should_prefetch)
+        i.first->second.RecordAdditionalInfo(kSuggestMetadataKey, metadata);
+    }
+  }
 }