Remove protected virtual methods from BaseSearchProvider

chrome/browser/autocomplete/zero_suggest_provider.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/zero_suggest_provider.h"
 
 #include "base/callback.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/metrics/histogram.h"
-#include "base/metrics/user_metrics.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/autocomplete/search_provider.h"
@@ skipping 28 matching lines @@
 //     (excluding the end-of-list enum value)
 // We do not want values of existing enums to change or else it screws
 // up the statistics.
 enum ZeroSuggestRequestsHistogramValue {
   ZERO_SUGGEST_REQUEST_SENT = 1,
   ZERO_SUGGEST_REQUEST_INVALIDATED,
   ZERO_SUGGEST_REPLY_RECEIVED,
   ZERO_SUGGEST_MAX_REQUEST_HISTOGRAM_VALUE
 };
 
+// User metrics action strings.
+const char kUserMetricsActionDeletionSuccess[] =
+    "Omnibox.ZeroSuggestDelete.Success";
+const char kUserMetricsActionDeletionFailure[] =
+    "Omnibox.ZeroSuggestDelete.Failure";
+
 void LogOmniboxZeroSuggestRequest(
     ZeroSuggestRequestsHistogramValue request_value) {
   UMA_HISTOGRAM_ENUMERATION("Omnibox.ZeroSuggestRequests", request_value,
                             ZERO_SUGGEST_MAX_REQUEST_HISTOGRAM_VALUE);
 }
 
 // The maximum relevance of the top match from this provider.
 const int kDefaultVerbatimZeroSuggestRelevance = 1300;
 
 // Relevance value to use if it was not set explicitly by the server.
@@ skipping 62 matching lines @@
   }
 
   done_ = false;
   // TODO(jered): Consider adding locally-sourced zero-suggestions here too.
   // These may be useful on the NTP or more relevant to the user than server
   // suggestions, if based on local browsing history.
   MaybeUseCachedSuggestions();
   Run(suggest_url);
 }
 
+void ZeroSuggestProvider::Stop(bool clear_cached_results) {
+  if (fetcher_)
+    LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REQUEST_INVALIDATED);
+  fetcher_.reset();
+  done_ = true;
+
+  if (clear_cached_results) {
+    // We do not call Clear() on |results_| to retain |verbatim_relevance|
+    // value in the |results_| object. |verbatim_relevance| is used at the
+    // beginning of the next StartZeroSuggest() call to determine the current
+    // url match relevance.
+    results_.suggest_results.clear();
+    results_.navigation_results.clear();
+    current_query_.clear();
+  }
+}
+
 void ZeroSuggestProvider::DeleteMatch(const AutocompleteMatch& match) {
   if (OmniboxFieldTrial::InZeroSuggestPersonalizedFieldTrial()) {
     // Remove the deleted match from the cache, so it is not shown to the user
     // again. Since we cannot remove just one result, blow away the cache.
     profile_->GetPrefs()->SetString(prefs::kZeroSuggestCachedResults,
                                     std::string());
   }
   BaseSearchProvider::DeleteMatch(match);
 }
 
+void ZeroSuggestProvider::AddProviderInfo(ProvidersInfo* provider_info) const {
+  BaseSearchProvider::AddProviderInfo(provider_info);
+  if (!results_.suggest_results.empty() || !results_.navigation_results.empty())
+    provider_info->back().set_times_returned_results_in_session(1);
+}
+
 void ZeroSuggestProvider::ResetSession() {
   // The user has started editing in the omnibox, so leave
   // |field_trial_triggered_in_session_| unchanged and set
   // |field_trial_triggered_| to false since zero suggest is inactive now.
   field_trial_triggered_ = false;
 }
 
-void ZeroSuggestProvider::ModifyProviderInfo(
-    metrics::OmniboxEventProto_ProviderInfo* provider_info) const {
-  if (!results_.suggest_results.empty() || !results_.navigation_results.empty())
-    provider_info->set_times_returned_results_in_session(1);
-}
-
 ZeroSuggestProvider::ZeroSuggestProvider(
   AutocompleteProviderListener* listener,
   TemplateURLService* template_url_service,
   Profile* profile)
-    : BaseSearchProvider(template_url_service, profile,
-                         AutocompleteProvider::TYPE_ZERO_SUGGEST),
+    : BaseSearchProvider(
+          template_url_service, profile,
+          base::UserMetricsAction(kUserMetricsActionDeletionSuccess),
+          base::UserMetricsAction(kUserMetricsActionDeletionFailure),
+          AutocompleteProvider::TYPE_ZERO_SUGGEST),
       listener_(listener),
       results_from_cache_(false),
       weak_ptr_factory_(this) {
 }
 
 ZeroSuggestProvider::~ZeroSuggestProvider() {
 }
 
-const TemplateURL* ZeroSuggestProvider::GetTemplateURL(bool is_keyword) const {
-  // Zero suggest provider should not receive keyword results.
-  DCHECK(!is_keyword);
-  return template_url_service_->GetDefaultSearchProvider();
-}
-
-const AutocompleteInput ZeroSuggestProvider::GetInput(bool is_keyword) const {
-  return AutocompleteInput(
-      base::string16(), base::string16::npos, base::string16(),
-      GURL(current_query_), current_page_classification_, true, false, false,
-      true, ChromeAutocompleteSchemeClassifier(profile_));
-}
-
-bool ZeroSuggestProvider::ShouldAppendExtraParams(
-      const SearchSuggestionParser::SuggestResult& result) const {
-  // We always use the default provider for search, so append the params.
-  return true;
-}
-
-void ZeroSuggestProvider::StopSuggest() {
-  if (fetcher_)
-    LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REQUEST_INVALIDATED);
-  fetcher_.reset();
-}
-
-void ZeroSuggestProvider::ClearAllResults() {
-  // We do not call Clear() on |results_| to retain |verbatim_relevance|
-  // value in the |results_| object. |verbatim_relevance| is used at the
-  // beginning of the next StartZeroSuggest() call to determine the current url
-  // match relevance.
-  results_.suggest_results.clear();
-  results_.navigation_results.clear();
-  current_query_.clear();
-}
-
-void ZeroSuggestProvider::RecordDeletionResult(bool success) {
-  if (success) {
-    base::RecordAction(
-        base::UserMetricsAction("Omnibox.ZeroSuggestDelete.Success"));
-  } else {
-    base::RecordAction(
-        base::UserMetricsAction("Omnibox.ZeroSuggestDelete.Failure"));
-  }
-}
-
 void ZeroSuggestProvider::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(!done_);
   DCHECK_EQ(fetcher_.get(), source);
 
   LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REPLY_RECEIVED);
 
   bool results_updated = false;
   if (source->GetStatus().is_success() && source->GetResponseCode() == 200) {
     std::string json_data = SearchSuggestionParser::ExtractJsonData(source);
     scoped_ptr<base::Value> data(
         SearchSuggestionParser::DeserializeJsonData(json_data));
     if (data) {
       if (StoreSuggestionResponse(json_data, *data))
         return;
       results_updated = ParseSuggestResults(
-          *data, kDefaultZeroSuggestRelevance, false, &results_);
+          *data, GetInput(), kDefaultZeroSuggestRelevance, false, &results_);
     }
   }
   fetcher_.reset();
   done_ = true;
   ConvertResultsToAutocompleteMatches();
   listener_->OnProviderUpdate(results_updated);
 }
 
+AutocompleteInput ZeroSuggestProvider::GetInput() const {
+  return AutocompleteInput(
+      base::string16(), base::string16::npos, base::string16(),
+      GURL(current_query_), current_page_classification_, true, false, false,
+      true, ChromeAutocompleteSchemeClassifier(profile_));
+}
+
 bool ZeroSuggestProvider::StoreSuggestionResponse(
     const std::string& json_data,
     const base::Value& parsed_data) {
   if (!OmniboxFieldTrial::InZeroSuggestPersonalizedFieldTrial() ||
       json_data.empty())
     return false;
   profile_->GetPrefs()->SetString(prefs::kZeroSuggestCachedResults, json_data);
 
   // If we received an empty result list, we should update the display, as it
   // may be showing cached results that should not be shown.
   const base::ListValue* root_list = NULL;
   const base::ListValue* results_list = NULL;
   if (parsed_data.GetAsList(&root_list) &&
       root_list->GetList(1, &results_list) &&
       results_list->empty())
     return false;
 
   // We are finished with the request and want to bail early.
   if (results_from_cache_)
     done_ = true;
 
   return results_from_cache_;
 }
 
 void ZeroSuggestProvider::AddSuggestResultsToMap(
     const SearchSuggestionParser::SuggestResults& results,
     MatchMap* map) {
-  for (size_t i = 0; i < results.size(); ++i)
-    AddMatchToMap(results[i], std::string(), i, false, map);
+  for (size_t i = 0; i < results.size(); ++i) {
+    AddMatchToMap(GetInput(), results[i],
+                  template_url_service_->GetDefaultSearchProvider(),
+                  std::string(), i, true, false, map);
+  }
 }
 
 AutocompleteMatch ZeroSuggestProvider::NavigationToMatch(
     const SearchSuggestionParser::NavigationResult& navigation) {
   AutocompleteMatch match(this, navigation.relevance(), false,
                           navigation.type());
   match.destination_url = navigation.url();
 
   // Zero suggest results should always omit protocols and never appear bold.
   const std::string languages(
@@ skipping 161 matching lines @@
 
 void ZeroSuggestProvider::MaybeUseCachedSuggestions() {
   if (!OmniboxFieldTrial::InZeroSuggestPersonalizedFieldTrial())
     return;
 
   std::string json_data = profile_->GetPrefs()->GetString(
       prefs::kZeroSuggestCachedResults);
   if (!json_data.empty()) {
     scoped_ptr<base::Value> data(
         SearchSuggestionParser::DeserializeJsonData(json_data));
-    if (data && ParseSuggestResults(
-            *data, kDefaultZeroSuggestRelevance, false, &results_)) {
+    if (data &&
+        ParseSuggestResults(*data, GetInput(), kDefaultZeroSuggestRelevance,
+                            false, &results_)) {
       ConvertResultsToAutocompleteMatches();
       results_from_cache_ = !matches_.empty();
     }
   }
 }