Stop sharing BaseSearchProvider::OnURLFetchComplete between 2 providers

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"
@@ skipping 114 matching lines @@
 
 
 // SearchProvider -------------------------------------------------------------
 
 // static
 int SearchProvider::kMinimumTimeBetweenSuggestQueriesMs = 100;
 
 SearchProvider::SearchProvider(AutocompleteProviderListener* listener,
                                TemplateURLService* template_url_service,
                                Profile* profile)
-    : BaseSearchProvider(listener, template_url_service, profile,
+    : BaseSearchProvider(template_url_service, profile,
                          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);
 }
 
 void SearchProvider::ResetSession() {
   field_trial_triggered_in_session_ = false;
@@ skipping 147 matching lines @@
 
 const TemplateURL* SearchProvider::GetTemplateURL(bool is_keyword) const {
   return is_keyword ? providers_.GetKeywordProviderURL()
                     : providers_.GetDefaultProviderURL();
 }
 
 const AutocompleteInput SearchProvider::GetInput(bool is_keyword) const {
   return is_keyword ? keyword_input_ : input_;
 }
 
-SearchSuggestionParser::Results* SearchProvider::GetResultsToFill(
-    bool is_keyword) {
-  return is_keyword ? &keyword_results_ : &default_results_;
-}
-
 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();
 }
 
-int SearchProvider::GetDefaultResultRelevance() const {
-  return -1;
-}
-
 void SearchProvider::RecordDeletionResult(bool success) {
   if (success) {
     content::RecordAction(
         base::UserMetricsAction("Omnibox.ServerSuggestDelete.Success"));
   } else {
     content::RecordAction(
         base::UserMetricsAction("Omnibox.ServerSuggestDelete.Failure"));
   }
 }
 
@@ skipping 13 matching lines @@
     if (success) {
       UMA_HISTOGRAM_TIMES("Omnibox.SuggestRequest.Success.GoogleResponseTime",
                           elapsed_time);
     } else {
       UMA_HISTOGRAM_TIMES("Omnibox.SuggestRequest.Failure.GoogleResponseTime",
                           elapsed_time);
     }
   }
 }
 
-bool SearchProvider::IsKeywordFetcher(const net::URLFetcher* fetcher) const {
-  return fetcher == keyword_fetcher_.get();
-}
-
 void SearchProvider::UpdateMatches() {
   ConvertResultsToAutocompleteMatches();
 
   // Check constraints that may be violated by suggested relevances.
   if (!matches_.empty() &&
       (default_results_.HasServerProvidedScores() ||
        keyword_results_.HasServerProvidedScores())) {
     // These blocks attempt to repair undesirable behavior by suggested
     // relevances with minimal impact, preserving other suggested relevances.
 
@@ skipping 302 matching lines @@
   fetcher->SetLoadFlags(net::LOAD_DO_NOT_SAVE_COOKIES);
   // Add Chrome experiment state to the request headers.
   net::HttpRequestHeaders headers;
   variations::VariationsHttpHeaderProvider::GetInstance()->AppendHeaders(
       fetcher->GetOriginalURL(), profile_->IsOffTheRecord(), false, &headers);
   fetcher->SetExtraRequestHeaders(headers.ToString());
   fetcher->Start();
   return fetcher;
 }
 
+void SearchProvider::OnURLFetchComplete(const net::URLFetcher* source) {
+  DCHECK(!done_);
+  suggest_results_pending_--;

[Peter Kasting, 2014/08/08 17:33:23]

Nit: Predecrement

[hashimoto, 2014/08/11 05:15:04]

Done.

+  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);
+      if (results_updated)
+        SortResults(is_keyword, results);
+    }
+  }
+  UpdateMatches();
+  if (done_ || results_updated)
+    listener_->OnProviderUpdate(results_updated);
+}
+
 void SearchProvider::ConvertResultsToAutocompleteMatches() {
   // Convert all the results to matches and add them to a map, so we can keep
   // the most relevant match for each result.
   base::TimeTicks start_time(base::TimeTicks::Now());
   MatchMap map;
   const base::Time no_time;
   int did_not_accept_keyword_suggestion =
       keyword_results_.suggest_results.empty() ?
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE :
       TemplateURLRef::NO_SUGGESTION_CHOSEN;
@@ skipping 536 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();
 }