Remove protected virtual methods from BaseSearchProvider

chrome/browser/autocomplete/search_provider.cc

 // Copyright 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/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
-#include "base/metrics/user_metrics.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
 #include "chrome/browser/autocomplete/autocomplete_result.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
 #include "chrome/browser/autocomplete/keyword_provider.h"
 #include "chrome/browser/history/history_service.h"
@@ skipping 36 matching lines @@
 enum SuggestRequestsHistogramValue {
   REQUEST_SENT = 1,
   REQUEST_INVALIDATED,
   REPLY_RECEIVED,
   MAX_SUGGEST_REQUEST_HISTOGRAM_VALUE
 };
 
 // The verbatim score for an input which is not an URL.
 const int kNonURLVerbatimRelevance = 1300;
 
+// User metrics action strings.
+const char kUserMetricsActionDeletionSuccess[] =
+    "Omnibox.ServerSuggestDelete.Success";
+const char kUserMetricsActionDeletionFailure[] =
+    "Omnibox.ServerSuggestDelete.Failure";
+
 // Increments the appropriate value in the histogram by one.
 void LogOmniboxSuggestRequest(
     SuggestRequestsHistogramValue request_value) {
   UMA_HISTOGRAM_ENUMERATION("Omnibox.SuggestRequests", request_value,
                             MAX_SUGGEST_REQUEST_HISTOGRAM_VALUE);
 }
 
 bool HasMultipleWords(const base::string16& text) {
   base::i18n::BreakIterator i(text, base::i18n::BreakIterator::BREAK_WORD);
   bool found_word = false;
@@ skipping 40 matching lines @@
 
 
 // SearchProvider -------------------------------------------------------------
 
 // static
 int SearchProvider::kMinimumTimeBetweenSuggestQueriesMs = 100;
 
 SearchProvider::SearchProvider(AutocompleteProviderListener* listener,
                                TemplateURLService* template_url_service,
                                Profile* profile)
-    : BaseSearchProvider(template_url_service, profile,
-                         AutocompleteProvider::TYPE_SEARCH),
+    : BaseSearchProvider(
+          template_url_service, profile,
+          base::UserMetricsAction(kUserMetricsActionDeletionSuccess),
+          base::UserMetricsAction(kUserMetricsActionDeletionFailure),
+          AutocompleteProvider::TYPE_SEARCH),
       listener_(listener),
       suggest_results_pending_(0),
       providers_(template_url_service) {
 }
 
 // static
 std::string SearchProvider::GetSuggestMetadata(const AutocompleteMatch& match) {
   return match.GetAdditionalInfo(kSuggestMetadataKey);
 }
 
@@ skipping 96 matching lines @@
   }
 
   input_ = input;
 
   DoHistoryQuery(minimal_changes);
   DoAnswersQuery(input);
   StartOrStopSuggestQuery(minimal_changes);
   UpdateMatches();
 }
 
-const TemplateURL* SearchProvider::GetTemplateURL(bool is_keyword) const {
-  return is_keyword ? providers_.GetKeywordProviderURL()
-                    : providers_.GetDefaultProviderURL();
-}
+void SearchProvider::Stop(bool clear_cached_results) {
+  StopSuggest();
+  done_ = true;
 
-const AutocompleteInput SearchProvider::GetInput(bool is_keyword) const {
-  return is_keyword ? keyword_input_ : input_;
-}
-
-bool SearchProvider::ShouldAppendExtraParams(
-    const SearchSuggestionParser::SuggestResult& result) const {
-  return !result.from_keyword_provider() ||
-      providers_.default_provider().empty();
-}
-
-void SearchProvider::StopSuggest() {
-  // Increment the appropriate field in the histogram by the number of
-  // pending requests that were invalidated.
-  for (int i = 0; i < suggest_results_pending_; ++i)
-    LogOmniboxSuggestRequest(REQUEST_INVALIDATED);
-  suggest_results_pending_ = 0;
-  timer_.Stop();
-  // Stop any in-progress URL fetches.
-  keyword_fetcher_.reset();
-  default_fetcher_.reset();
-}
-
-void SearchProvider::ClearAllResults() {
-  keyword_results_.Clear();
-  default_results_.Clear();
-}
-
-void SearchProvider::RecordDeletionResult(bool success) {
-  if (success) {
-    base::RecordAction(
-        base::UserMetricsAction("Omnibox.ServerSuggestDelete.Success"));
-  } else {
-    base::RecordAction(
-        base::UserMetricsAction("Omnibox.ServerSuggestDelete.Failure"));
-  }
+  if (clear_cached_results)
+    ClearAllResults();
 }
 
 void SearchProvider::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(!done_);
   --suggest_results_pending_;
   DCHECK_GE(suggest_results_pending_, 0);  // Should never go negative.
 
   const bool is_keyword = source == keyword_fetcher_.get();
 
   // Ensure the request succeeded and that the provider used is still available.
   // A verbatim match cannot be generated without this provider, causing errors.
   const bool request_succeeded =
       source->GetStatus().is_success() && (source->GetResponseCode() == 200) &&
       GetTemplateURL(is_keyword);
 
   LogFetchComplete(request_succeeded, is_keyword);
 
   bool results_updated = false;
   if (request_succeeded) {
     scoped_ptr<base::Value> data(SearchSuggestionParser::DeserializeJsonData(
         SearchSuggestionParser::ExtractJsonData(source)));
     if (data) {
       SearchSuggestionParser::Results* results =
           is_keyword ? &keyword_results_ : &default_results_;
-      results_updated = ParseSuggestResults(*data, -1, is_keyword, results);
+      results_updated = ParseSuggestResults(
+          *data, GetInput(is_keyword), -1, is_keyword, results);
       if (results_updated)
         SortResults(is_keyword, results);
     }
   }
   UpdateMatches();
   if (done_ || results_updated)
     listener_->OnProviderUpdate(results_updated);
 }
 
+const TemplateURL* SearchProvider::GetTemplateURL(bool is_keyword) const {
+  return is_keyword ? providers_.GetKeywordProviderURL()

[Peter Kasting, 2014/08/12 18:31:18]

Nit: clang-format error, please break after ? and not before : (break after : if
you need to break again)

[hashimoto, 2014/08/13 05:21:22]

Done.

+                    : providers_.GetDefaultProviderURL();
+}
+
+const AutocompleteInput& SearchProvider::GetInput(bool is_keyword) const {
+  return is_keyword ? keyword_input_ : input_;
+}
+
+bool SearchProvider::ShouldAppendExtraParams(
+    const SearchSuggestionParser::SuggestResult& result) const {
+  return !result.from_keyword_provider() ||
+      providers_.default_provider().empty();
+}
+
+void SearchProvider::StopSuggest() {
+  // Increment the appropriate field in the histogram by the number of
+  // pending requests that were invalidated.
+  for (int i = 0; i < suggest_results_pending_; ++i)
+    LogOmniboxSuggestRequest(REQUEST_INVALIDATED);
+  suggest_results_pending_ = 0;
+  timer_.Stop();
+  // Stop any in-progress URL fetches.
+  keyword_fetcher_.reset();
+  default_fetcher_.reset();
+}
+
+void SearchProvider::ClearAllResults() {
+  keyword_results_.Clear();
+  default_results_.Clear();
+}
+
 void SearchProvider::UpdateMatchContentsClass(
     const base::string16& input_text,
     SearchSuggestionParser::Results* results) {
   for (SearchSuggestionParser::SuggestResults::iterator sug_it =
            results->suggest_results.begin();
        sug_it != results->suggest_results.end(); ++sug_it) {
     sug_it->ClassifyMatchContents(false, input_text);
   }
   const std::string languages(
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
@@ skipping 395 matching lines @@
       TemplateURLRef::NO_SUGGESTION_CHOSEN;
   if (verbatim_relevance > 0) {
     const base::string16& trimmed_verbatim =
         base::CollapseWhitespace(input_.text(), false);
     SearchSuggestionParser::SuggestResult verbatim(
         trimmed_verbatim, AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
         trimmed_verbatim, base::string16(), base::string16(), base::string16(),
         base::string16(), std::string(), std::string(), false,
         verbatim_relevance, relevance_from_server, false,
         trimmed_verbatim);
-    AddMatchToMap(verbatim, std::string(), did_not_accept_default_suggestion,
-                  false, &map);
+    AddMatchToMap(GetInput(false), verbatim, GetTemplateURL(false),
+                  std::string(), did_not_accept_default_suggestion,
+                  ShouldAppendExtraParams(verbatim), false, &map);
   }
   if (!keyword_input_.text().empty()) {
     const TemplateURL* keyword_url = providers_.GetKeywordProviderURL();
     // We only create the verbatim search query match for a keyword
     // if it's not an extension keyword.  Extension keywords are handled
     // in KeywordProvider::Start().  (Extensions are complicated...)
     // Note: in this provider, SEARCH_OTHER_ENGINE must correspond
     // to the keyword verbatim search query.  Do not create other matches
     // of type SEARCH_OTHER_ENGINE.
     if (keyword_url &&
         (keyword_url->GetType() != TemplateURL::OMNIBOX_API_EXTENSION)) {
       bool keyword_relevance_from_server;
       const int keyword_verbatim_relevance =
           GetKeywordVerbatimRelevance(&keyword_relevance_from_server);
       if (keyword_verbatim_relevance > 0) {
         const base::string16& trimmed_verbatim =
             base::CollapseWhitespace(keyword_input_.text(), false);
         SearchSuggestionParser::SuggestResult verbatim(
             trimmed_verbatim, AutocompleteMatchType::SEARCH_OTHER_ENGINE,
             trimmed_verbatim, base::string16(), base::string16(),
             base::string16(), base::string16(), std::string(), std::string(),
             true, keyword_verbatim_relevance, keyword_relevance_from_server,
             false, trimmed_verbatim);
-        AddMatchToMap(verbatim, std::string(),
-                      did_not_accept_keyword_suggestion, false, &map);
+        AddMatchToMap(GetInput(true), verbatim, keyword_url,
+                      std::string(), did_not_accept_keyword_suggestion,
+                      ShouldAppendExtraParams(verbatim), false, &map);
       }
     }
   }
   AddHistoryResultsToMap(keyword_history_results_, true,
                          did_not_accept_keyword_suggestion, &map);
   AddHistoryResultsToMap(default_history_results_, false,
                          did_not_accept_default_suggestion, &map);
 
   AddSuggestResultsToMap(keyword_results_.suggest_results,
                          keyword_results_.metadata, &map);
@@ skipping 121 matching lines @@
     if ((scored_results.front().relevance() < 1200) ||
         !HasMultipleWords(scored_results.front().suggestion()))
       scored_results.clear();  // Didn't detect the case above, score normally.
   }
   if (scored_results.empty())
     scored_results = ScoreHistoryResults(results, prevent_inline_autocomplete,
                                          input_multiple_words, input_text,
                                          is_keyword);
   for (SearchSuggestionParser::SuggestResults::const_iterator i(
            scored_results.begin()); i != scored_results.end(); ++i) {
-    AddMatchToMap(*i, std::string(), did_not_accept_suggestion, true, map);
+    AddMatchToMap(GetInput(is_keyword), *i, GetTemplateURL(is_keyword),
+                  std::string(), did_not_accept_suggestion,
+                  ShouldAppendExtraParams(*i), true, map);
   }
   UMA_HISTOGRAM_TIMES("Omnibox.SearchProvider.AddHistoryResultsTime",
                       base::TimeTicks::Now() - start_time);
 }
 
 SearchSuggestionParser::SuggestResults SearchProvider::ScoreHistoryResults(
     const HistoryResults& results,
     bool base_prevent_inline_autocomplete,
     bool input_multiple_words,
     const base::string16& input_text,
@@ skipping 101 matching lines @@
     last_relevance = i->relevance();
   }
 
   return scored_results;
 }
 
 void SearchProvider::AddSuggestResultsToMap(
     const SearchSuggestionParser::SuggestResults& results,
     const std::string& metadata,
     MatchMap* map) {
-  for (size_t i = 0; i < results.size(); ++i)
-    AddMatchToMap(results[i], metadata, i, false, map);
+  for (size_t i = 0; i < results.size(); ++i) {
+    AddMatchToMap(GetInput(results[i].from_keyword_provider()), results[i],
+                  GetTemplateURL(results[i].from_keyword_provider()), metadata,
+                  i, ShouldAppendExtraParams(results[i]), false, map);
+  }
 }
 
 int SearchProvider::GetVerbatimRelevance(bool* relevance_from_server) const {
   // Use the suggested verbatim relevance score if it is non-negative (valid),
   // if inline autocomplete isn't prevented (always show verbatim on backspace),
   // and if it won't suppress verbatim, leaving no default provider matches.
   // Otherwise, if the default provider returned no matches and was still able
   // to suppress verbatim, the user would have no search/nav matches and may be
   // left unable to search using their default provider from the omnibox.
   // Check for results on each verbatim calculation, as results from older
@@ skipping 218 matching lines @@
   last_answer_seen_.query_type = match->answer_type;
 }
 
 void SearchProvider::DoAnswersQuery(const AutocompleteInput& input) {
   // If the query text starts with trimmed input, this is valid prefetch data.
   prefetch_data_ = StartsWith(last_answer_seen_.full_query_text,
                               base::CollapseWhitespace(input.text(), false),
                               false) ?
       last_answer_seen_ : AnswersQueryData();
 }