Parametrize Suggest polling strategy and delay. Also add a parameter

components/omnibox/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 "components/omnibox/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/base64.h"
@@ skipping 98 matching lines @@
   bool operator()(const SearchSuggestionParser::Result& a,
                   const SearchSuggestionParser::Result& b) {
     // Sort in descending relevance order.
     return a.relevance() > b.relevance();
   }
 };
 
 
 // SearchProvider -------------------------------------------------------------
 
-// static
-int SearchProvider::kMinimumTimeBetweenSuggestQueriesMs = 100;
-
 SearchProvider::SearchProvider(
     AutocompleteProviderListener* listener,
     TemplateURLService* template_url_service,
     scoped_ptr<AutocompleteProviderClient> client)
     : BaseSearchProvider(template_url_service, client.Pass(),
                          AutocompleteProvider::TYPE_SEARCH),
       listener_(listener),
       suggest_results_pending_(0),
       providers_(template_url_service),
       answers_cache_(10) {
@@ skipping 440 matching lines @@
   }
   const TemplateURL* keyword_url = providers_.GetKeywordProviderURL();
   if (keyword_url) {
     url_db->GetMostRecentKeywordSearchTerms(keyword_url->id(),
                                             keyword_input_.text(),
                                             num_matches,
                                             &raw_keyword_history_results_);
   }
 }
 
+base::TimeDelta SearchProvider::GetSuggestQueryDelay() const {
+  bool from_last_keystroke;
+  int polling_delay_ms;
+  OmniboxFieldTrial::GetSuggestPollingStrategy(&from_last_keystroke,
+                                               &polling_delay_ms);
+
+  base::TimeDelta delay(base::TimeDelta::FromMilliseconds(polling_delay_ms));
+  if (from_last_keystroke)
+    return delay;
+
+  base::TimeDelta time_since_last_suggest_request =
+      base::TimeTicks::Now() - time_suggest_request_sent_;
+  return std::max(base::TimeDelta(), delay - time_since_last_suggest_request);
+}
+
 void SearchProvider::StartOrStopSuggestQuery(bool minimal_changes) {
   if (!IsQuerySuitableForSuggest()) {
     StopSuggest();
     ClearAllResults();
     return;
   }
 
+  if (OmniboxFieldTrial::DisableResultsCaching())
+    ClearAllResults();
+
   // For the minimal_changes case, if we finished the previous query and still
   // have its results, or are allowed to keep running it, just do that, rather
   // than starting a new query.
   if (minimal_changes &&
       (!default_results_.suggest_results.empty() ||
        !default_results_.navigation_results.empty() ||
        !keyword_results_.suggest_results.empty() ||
        !keyword_results_.navigation_results.empty() ||
        (!done_ && input_.want_asynchronous_matches())))
     return;
 
   // We can't keep running any previous query, so halt it.
   StopSuggest();
 
   UpdateAllOldResults(minimal_changes);
 
   // Update the content classifications of remaining results so they look good
   // against the current input.
   UpdateMatchContentsClass(input_.text(), &default_results_);
   if (!keyword_input_.text().empty())
     UpdateMatchContentsClass(keyword_input_.text(), &keyword_results_);
 
   // We can't start a new query if we're only allowed synchronous results.
   if (!input_.want_asynchronous_matches())
     return;
 
-  // To avoid flooding the suggest server, don't send a query until at
-  // least 100 ms since the last query.
-  base::TimeTicks next_suggest_time(time_suggest_request_sent_ +
-      base::TimeDelta::FromMilliseconds(kMinimumTimeBetweenSuggestQueriesMs));
-  base::TimeTicks now(base::TimeTicks::Now());
-  if (now >= next_suggest_time) {
+  // Kick off a timer that will start the URL fetch if it completes before
+  // the user types another character.  Requests may be delayed to avoid
+  // flooding the server with requests that are likely to be thrown away later
+  // anyway.
+  const base::TimeDelta delay = GetSuggestQueryDelay();
+  if (delay <= base::TimeDelta()) {
     Run();
     return;
   }
-  timer_.Start(FROM_HERE, next_suggest_time - now, this, &SearchProvider::Run);
+  timer_.Start(FROM_HERE, delay, this, &SearchProvider::Run);
 }
 
 bool SearchProvider::IsQuerySuitableForSuggest() const {
   // Don't run Suggest in incognito mode, if the engine doesn't support it, or
   // if the user has disabled it.
   const TemplateURL* default_url = providers_.GetDefaultProviderURL();
   const TemplateURL* keyword_url = providers_.GetKeywordProviderURL();
   if (client_->IsOffTheRecord() ||
       ((!default_url || default_url->suggestions_url().empty()) &&
        (!keyword_url || keyword_url->suggestions_url().empty())) ||
@@ skipping 796 matching lines @@
   for (MatchMap::const_iterator i(map.begin()); i != map.end(); ++i)
     matches.push_back(i->second);
   std::sort(matches.begin(), matches.end(), &AutocompleteMatch::MoreRelevant);
 
   // If there is a top scoring entry, find the corresponding answer.
   if (!matches.empty())
     return answers_cache_.GetTopAnswerEntry(matches[0].contents);
 
   return AnswersQueryData();
 }