Stop sharing BaseSearchProvider::OnURLFetchComplete between 2 providers

chrome/browser/autocomplete/search_provider.h

 // 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.
 //
 // This file contains the Search autocomplete provider.  This provider is
 // responsible for all autocomplete entries that start with "Search <engine>
 // for ...", including searching for the current input string, search
 // history, and search suggestions.  An instance of it gets created and
 // managed by the autocomplete controller.
 
 #ifndef CHROME_BROWSER_AUTOCOMPLETE_SEARCH_PROVIDER_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_SEARCH_PROVIDER_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/autocomplete/base_search_provider.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "components/search_engines/template_url.h"
+#include "net/url_request/url_fetcher_delegate.h"
 
+class AutocompleteProviderListener;
 class AutocompleteResult;
 class Profile;
 class SearchProviderTest;
 class TemplateURLService;
 
 namespace history {
 struct KeywordSearchTermVisit;
 }
 
 namespace net {
 class URLFetcher;
 }
 
 // Autocomplete provider for searches and suggestions from a search engine.
 //
 // After construction, the autocomplete controller repeatedly calls Start()
 // with some user input, each time expecting to receive a small set of the best
 // matches (either synchronously or asynchronously).
 //
 // Initially the provider creates a match that searches for the current input
 // text.  It also starts a task to query the Suggest servers.  When that data
 // comes back, the provider creates and returns matches for the best
 // suggestions.
-class SearchProvider : public BaseSearchProvider {
+class SearchProvider : public BaseSearchProvider,
+                       public net::URLFetcherDelegate {
  public:
   SearchProvider(AutocompleteProviderListener* listener,
                  TemplateURLService* template_url_service,
                  Profile* profile);
 
   // Extracts the suggest response metadata which SearchProvider previously
   // stored for |match|.
   static std::string GetSuggestMetadata(const AutocompleteMatch& match);
 
   // Answers prefetch handling - register displayed answers. Takes the top
@@ skipping 84 matching lines @@
   typedef std::vector<history::KeywordSearchTermVisit> HistoryResults;
 
   // Removes non-inlineable results until either the top result can inline
   // autocomplete the current input or verbatim outscores the top result.
   static void RemoveStaleResults(
       const base::string16& input,
       int verbatim_relevance,
       SearchSuggestionParser::SuggestResults* suggest_results,
       SearchSuggestionParser::NavigationResults* navigation_results);
 
-  // Recalculates the match contents class of |results| to better display
-  // against the current input and user's language.
-  void UpdateMatchContentsClass(const base::string16& input_text,
-                                SearchSuggestionParser::Results* results);
-
   // Calculates the relevance score for the keyword verbatim result (if the
   // input matches one of the profile's keyword).
   static int CalculateRelevanceForKeywordVerbatim(
       metrics::OmniboxInputType::Type type,
       bool prefer_keyword);
 
   // AutocompleteProvider:
   virtual void Start(const AutocompleteInput& input,
                      bool minimal_changes) OVERRIDE;
 
   // BaseSearchProvider:
-  virtual void SortResults(bool is_keyword,
-                           SearchSuggestionParser::Results* results) OVERRIDE;
   virtual const TemplateURL* GetTemplateURL(bool is_keyword) const OVERRIDE;
   virtual const AutocompleteInput GetInput(bool is_keyword) const OVERRIDE;
-  virtual SearchSuggestionParser::Results* GetResultsToFill(
-      bool is_keyword) OVERRIDE;
   virtual bool ShouldAppendExtraParams(
       const SearchSuggestionParser::SuggestResult& result) const OVERRIDE;
   virtual void StopSuggest() OVERRIDE;
   virtual void ClearAllResults() OVERRIDE;
-  virtual int GetDefaultResultRelevance() const OVERRIDE;
   virtual void RecordDeletionResult(bool success) OVERRIDE;
-  virtual void LogFetchComplete(bool success, bool is_keyword) OVERRIDE;
-  virtual bool IsKeywordFetcher(const net::URLFetcher* fetcher) const OVERRIDE;
-  virtual void UpdateMatches() OVERRIDE;
+
+  // net::URLFetcherDelegate:
+  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
+
+  // Recalculates the match contents class of |results| to better display
+  // against the current input and user's language.
+  void UpdateMatchContentsClass(const base::string16& input_text,
+                                SearchSuggestionParser::Results* results);
+
+  // Called after ParseSuggestResults to rank the |results|.
+  void SortResults(bool is_keyword, SearchSuggestionParser::Results* results);
+
+  // Records UMA statistics about a suggest server response.
+  void LogFetchComplete(bool success, bool is_keyword);
+
+  // Updates |matches_| from the latest results; applies calculated relevances
+  // if suggested relevances cause undesirable behavior. Updates |done_|.
+  void UpdateMatches();
 
   // Called when timer_ expires.
   void Run();
 
   // Runs the history query, if necessary. The history query is synchronous.
   // This does not update |done_|.
   void DoHistoryQuery(bool minimal_changes);
 
   // Determines whether an asynchronous subcomponent query should run for the
   // current input.  If so, starts it if necessary; otherwise stops it.
@@ skipping 108 matching lines @@
   std::string GetSessionToken();
 
   // Answers prefetch handling - finds previously displayed answer matching the
   // current |input| and sets |prefetch_data_|.
   void DoAnswersQuery(const AutocompleteInput& input);
 
   // The amount of time to wait before sending a new suggest request after the
   // previous one.  Non-const because some unittests modify this value.
   static int kMinimumTimeBetweenSuggestQueriesMs;
 
+  AutocompleteProviderListener* listener_;
+
+  // The number of suggest results that haven't yet arrived. If it's greater
+  // than 0, it indicates that one of the URLFetchers is still running.
+  int suggest_results_pending_;
+
   // Maintains the TemplateURLs used.
   Providers providers_;
 
   // The user's input.
   AutocompleteInput input_;
 
   // Input when searching against the keyword provider.
   AutocompleteInput keyword_input_;
 
   // Searches in the user's history that begin with the input text.
@@ skipping 22 matching lines @@
   base::TimeTicks token_expiration_time_;
 
   // Answers prefetch management.
   AnswersQueryData prefetch_data_;     // Data to use for query prefetching.
   AnswersQueryData last_answer_seen_;  // Last answer seen.
 
   DISALLOW_COPY_AND_ASSIGN(SearchProvider);
 };
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_SEARCH_PROVIDER_H_