Stop sharing BaseSearchProvider::OnURLFetchComplete between 2 providers

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/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
@@ skipping 76 matching lines @@
       this);
 }
 
 // BaseSearchProvider ---------------------------------------------------------
 
 // static
 const int BaseSearchProvider::kDefaultProviderURLFetcherID = 1;
 const int BaseSearchProvider::kKeywordProviderURLFetcherID = 2;
 const int BaseSearchProvider::kDeletionURLFetcherID = 3;
 
-BaseSearchProvider::BaseSearchProvider(AutocompleteProviderListener* listener,
-                                       TemplateURLService* template_url_service,
+BaseSearchProvider::BaseSearchProvider(TemplateURLService* template_url_service,
                                        Profile* profile,
                                        AutocompleteProvider::Type type)
     : AutocompleteProvider(type),
-      listener_(listener),
       template_url_service_(template_url_service),
       profile_(profile),
       field_trial_triggered_(false),
-      field_trial_triggered_in_session_(false),
-      suggest_results_pending_(0) {
+      field_trial_triggered_in_session_(false) {
 }
 
 // static
 bool BaseSearchProvider::ShouldPrefetch(const AutocompleteMatch& match) {
   return match.GetAdditionalInfo(kShouldPrefetchKey) == kTrue;
 }
 
 // static
 AutocompleteMatch BaseSearchProvider::CreateSearchSuggestion(
     const base::string16& suggestion,
@@ skipping 243 matching lines @@
   if (service == NULL ||
       !service->IsSyncEnabledAndLoggedIn() ||
       !sync_prefs.GetPreferredDataTypes(syncer::UserTypes()).Has(
           syncer::PROXY_TABS) ||
       service->GetEncryptedDataTypes().Has(syncer::SESSIONS))
     return false;
 
   return true;
 }
 
-void BaseSearchProvider::OnURLFetchComplete(const net::URLFetcher* source) {
-  DCHECK(!done_);
-  suggest_results_pending_--;
-  DCHECK_GE(suggest_results_pending_, 0);  // Should never go negative.
-
-  const bool is_keyword = IsKeywordFetcher(source);
-
-  // 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) {
-    std::string json_data = SearchSuggestionParser::ExtractJsonData(source);
-    scoped_ptr<base::Value> data(
-        SearchSuggestionParser::DeserializeJsonData(json_data));
-    if (data && StoreSuggestionResponse(json_data, *data.get()))
-      return;
-
-    results_updated = data.get() && ParseSuggestResults(
-        *data.get(), is_keyword, GetResultsToFill(is_keyword));
-  }
-
-  UpdateMatches();
-  if (done_ || results_updated)
-    listener_->OnProviderUpdate(results_updated);
-}
-
 void BaseSearchProvider::AddMatchToMap(
     const SearchSuggestionParser::SuggestResult& result,
     const std::string& metadata,
     int accepted_suggestion,
     bool mark_as_deletable,
     MatchMap* map) {
   AutocompleteMatch match = CreateSearchSuggestion(
       this, GetInput(result.from_keyword_provider()), result,
       GetTemplateURL(result.from_keyword_provider()),
       template_url_service_->search_terms_data(), accepted_suggestion,
@@ skipping 59 matching lines @@
                                              should_prefetch ? kTrue : kFalse);
         if (should_prefetch)
           i.first->second.RecordAdditionalInfo(kSuggestMetadataKey, metadata);
       }
     }
   }
 }
 
 bool BaseSearchProvider::ParseSuggestResults(
     const base::Value& root_val,
+    int default_result_relevance,
     bool is_keyword_result,
     SearchSuggestionParser::Results* results) {
   if (!SearchSuggestionParser::ParseSuggestResults(
       root_val, GetInput(is_keyword_result),
-      ChromeAutocompleteSchemeClassifier(profile_),
-      GetDefaultResultRelevance(),
+      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;
-  SortResults(is_keyword_result, results);
   return true;
 }
 
-void BaseSearchProvider::SortResults(bool is_keyword,
-                                     SearchSuggestionParser::Results* results) {
-}
-
-bool BaseSearchProvider::StoreSuggestionResponse(
-    const std::string& json_data,
-    const base::Value& parsed_data) {
-  return false;
-}
-
 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);
   SuggestionDeletionHandlers::iterator it = std::find(
       deletion_handlers_.begin(), deletion_handlers_.end(), handler);
   DCHECK(it != deletion_handlers_.end());
   deletion_handlers_.erase(it);
 }