Remove protected virtual methods from BaseSearchProvider

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/metrics/user_metrics.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
 #include "chrome/browser/bitmap_fetcher/bitmap_fetcher_service.h"
 #include "chrome/browser/bitmap_fetcher/bitmap_fetcher_service_factory.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 69 matching lines @@
       this);
 }
 
 // BaseSearchProvider ---------------------------------------------------------
 
 // static
 const int BaseSearchProvider::kDefaultProviderURLFetcherID = 1;
 const int BaseSearchProvider::kKeywordProviderURLFetcherID = 2;
 const int BaseSearchProvider::kDeletionURLFetcherID = 3;
 
-BaseSearchProvider::BaseSearchProvider(TemplateURLService* template_url_service,
-                                       Profile* profile,
-                                       AutocompleteProvider::Type type)
+BaseSearchProvider::BaseSearchProvider(
+    TemplateURLService* template_url_service,
+    Profile* profile,
+    const base::UserMetricsAction& uma_deletion_success,
+    const base::UserMetricsAction& uma_deletion_failure,
+    AutocompleteProvider::Type type)
     : AutocompleteProvider(type),
       template_url_service_(template_url_service),
       profile_(profile),
       field_trial_triggered_(false),
-      field_trial_triggered_in_session_(false) {
+      field_trial_triggered_in_session_(false),
+      uma_deletion_success_(uma_deletion_success),
+      uma_deletion_failure_(uma_deletion_failure) {
 }
 
 // static
 bool BaseSearchProvider::ShouldPrefetch(const AutocompleteMatch& match) {
   return match.GetAdditionalInfo(kShouldPrefetchKey) == kTrue;
 }
 
 // static
 AutocompleteMatch BaseSearchProvider::CreateSearchSuggestion(
     const base::string16& suggestion,
     AutocompleteMatchType::Type type,
     bool from_keyword_provider,
     const TemplateURL* template_url,
     const SearchTermsData& search_terms_data) {
   return CreateSearchSuggestion(
       NULL, AutocompleteInput(), SearchSuggestionParser::SuggestResult(
           suggestion, type, suggestion, base::string16(), base::string16(),
           base::string16(), base::string16(), std::string(), std::string(),
           from_keyword_provider, 0, false, false, base::string16()),
       template_url, search_terms_data, 0, false);
 }
 
-void BaseSearchProvider::Stop(bool clear_cached_results) {
-  StopSuggest();
-  done_ = true;
-
-  if (clear_cached_results)
-    ClearAllResults();
-}
-
 void BaseSearchProvider::DeleteMatch(const AutocompleteMatch& match) {
   DCHECK(match.deletable);
   if (!match.GetAdditionalInfo(BaseSearchProvider::kDeletionUrlKey).empty()) {
     deletion_handlers_.push_back(new SuggestionDeletionHandler(
         match.GetAdditionalInfo(BaseSearchProvider::kDeletionUrlKey),
         profile_,
         base::Bind(&BaseSearchProvider::OnDeletionComplete,
                    base::Unretained(this))));
   }
 
@@ skipping 21 matching lines @@
   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]);
     if (field_trial_triggered_in_session_) {
       new_entry.mutable_field_trial_triggered_in_session()->Add(
           field_trial_hashes[i]);
     }
   }
-  ModifyProviderInfo(&new_entry);
 }
 
 // static
 const char BaseSearchProvider::kRelevanceFromServerKey[] =
     "relevance_from_server";
 const char BaseSearchProvider::kShouldPrefetchKey[] = "should_prefetch";
 const char BaseSearchProvider::kSuggestMetadataKey[] = "suggest_metadata";
 const char BaseSearchProvider::kDeletionUrlKey[] = "deletion_url";
 const char BaseSearchProvider::kTrue[] = "true";
 const char BaseSearchProvider::kFalse[] = "false";
@@ skipping 172 matching lines @@
       !service->IsSyncEnabledAndLoggedIn() ||
       !sync_prefs.GetPreferredDataTypes(syncer::UserTypes()).Has(
           syncer::PROXY_TABS) ||
       service->GetEncryptedDataTypes().Has(syncer::SESSIONS))
     return false;
 
   return true;
 }
 
 void BaseSearchProvider::AddMatchToMap(
+    const AutocompleteInput& input,
     const SearchSuggestionParser::SuggestResult& result,
+    const TemplateURL* template_url,
     const std::string& metadata,
     int accepted_suggestion,
+    bool should_append_extra_params,
     bool mark_as_deletable,
     MatchMap* map) {
   AutocompleteMatch match = CreateSearchSuggestion(
-      this, GetInput(result.from_keyword_provider()), result,
-      GetTemplateURL(result.from_keyword_provider()),
+      this, input, result, template_url,
       template_url_service_->search_terms_data(), accepted_suggestion,
-      ShouldAppendExtraParams(result));
+      should_append_extra_params);
   if (!match.destination_url.is_valid())
     return;
   match.search_terms_args->bookmark_bar_pinned =
       profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
   match.RecordAdditionalInfo(kRelevanceFromServerKey,
                              result.relevance_from_server() ? kTrue : kFalse);
   match.RecordAdditionalInfo(kShouldPrefetchKey,
                              result.should_prefetch() ? kTrue : kFalse);
   SetDeletionURL(result.deletion_url(), &match);
   if (mark_as_deletable)
@@ skipping 48 matching lines @@
                                              should_prefetch ? kTrue : kFalse);
         if (should_prefetch)
           i.first->second.RecordAdditionalInfo(kSuggestMetadataKey, metadata);
       }
     }
   }
 }
 
 bool BaseSearchProvider::ParseSuggestResults(
     const base::Value& root_val,
+    const AutocompleteInput& input,
     int default_result_relevance,
     bool is_keyword_result,
     SearchSuggestionParser::Results* results) {
   if (!SearchSuggestionParser::ParseSuggestResults(
-      root_val, GetInput(is_keyword_result),
+      root_val, input,
       ChromeAutocompleteSchemeClassifier(profile_), default_result_relevance,
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages),
       is_keyword_result, results))
     return false;
 
   BitmapFetcherService* image_service =
       BitmapFetcherServiceFactory::GetForBrowserContext(profile_);
   DCHECK(image_service);
   for (std::vector<GURL>::const_iterator it =
            results->answers_image_urls.begin();
        it != results->answers_image_urls.end(); ++it)
     image_service->Prefetch(*it);
 
   field_trial_triggered_ |= results->field_trial_triggered;
   field_trial_triggered_in_session_ |= results->field_trial_triggered;
   return true;
 }
 
-void BaseSearchProvider::ModifyProviderInfo(
-    metrics::OmniboxEventProto_ProviderInfo* provider_info) const {
-}
-
 void BaseSearchProvider::DeleteMatchFromMatches(
     const AutocompleteMatch& match) {
   for (ACMatches::iterator i(matches_.begin()); i != matches_.end(); ++i) {
     // Find the desired match to delete by checking the type and contents.
     // We can't check the destination URL, because the autocomplete controller
     // may have reformulated that. Not that while checking for matching
     // contents works for personalized suggestions, if more match types gain
     // deletion support, this algorithm may need to be re-examined.
     if (i->contents == match.contents && i->type == match.type) {
       matches_.erase(i);
       break;
     }
   }
 }
 
 void BaseSearchProvider::OnDeletionComplete(
     bool success, SuggestionDeletionHandler* handler) {
-  RecordDeletionResult(success);
+  base::RecordAction(success ? uma_deletion_success_ : uma_deletion_failure_);
   SuggestionDeletionHandlers::iterator it = std::find(
       deletion_handlers_.begin(), deletion_handlers_.end(), handler);
   DCHECK(it != deletion_handlers_.end());
   deletion_handlers_.erase(it);
 }