[Suggestions] Ability to override the timeout parameter via Variations

chrome/browser/search/suggestions/suggestions_service.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/search/suggestions/suggestions_service.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/metrics/variations/variations_http_header_provider.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/suggestions/suggestions_store.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 21 matching lines @@
   RESPONSE_VALID,
   RESPONSE_STATE_SIZE
 };
 
 // Will log the supplied response |state|.
 void LogResponseState(SuggestionsResponseState state) {
   UMA_HISTOGRAM_ENUMERATION("Suggestions.ResponseState", state,
                             RESPONSE_STATE_SIZE);
 }
 
-// Obtains the experiment parameter under the supplied |key|.
+// Obtains the experiment parameter under the supplied |key|, or empty string
+// if the parameter does not exist.
 std::string GetExperimentParam(const std::string& key) {
   return chrome_variations::GetVariationParamValue(kSuggestionsFieldTrialName,
                                                    key);
 }
 
 // Runs each callback in |requestors| on |suggestions|, then deallocates
 // |requestors|.
 void DispatchRequestsAndClear(
     const SuggestionsProfile& suggestions,
     std::vector<SuggestionsService::ResponseCallback>* requestors) {
   std::vector<SuggestionsService::ResponseCallback>::iterator it;
   for (it = requestors->begin(); it != requestors->end(); ++it) {
     it->Run(suggestions);
   }
   std::vector<SuggestionsService::ResponseCallback>().swap(*requestors);
 }
 
-// Timeout before serving requestors after a fetch suggestions request has been
-// issued.
-// TODO(manzagop): make this a Variations parameter to enable tweaking.
-const unsigned int kRequestTimeoutMs = 200;
+const int kDefaultRequestTimeoutMs = 200;
 
 }  // namespace
 
 const char kSuggestionsFieldTrialName[] = "ChromeSuggestions";
 const char kSuggestionsFieldTrialURLParam[] = "url";
 const char kSuggestionsFieldTrialSuggestionsSuffixParam[] =
     "suggestions_suffix";
 const char kSuggestionsFieldTrialBlacklistSuffixParam[] = "blacklist_suffix";
 const char kSuggestionsFieldTrialStateParam[] = "state";
 const char kSuggestionsFieldTrialStateEnabled[] = "enabled";
+const char kSuggestionsFieldTrialTimeoutMs[] = "timeout_ms";
 
 SuggestionsService::SuggestionsService(
     Profile* profile, scoped_ptr<SuggestionsStore> suggestions_store)
     : suggestions_store_(suggestions_store.Pass()),
       thumbnail_manager_(new ThumbnailManager(profile)),
       profile_(profile),
-      weak_ptr_factory_(this) {
-  // Obtain the URL to use to fetch suggestions data from the Variations param.
+      weak_ptr_factory_(this),
+      request_timeout_ms_(kDefaultRequestTimeoutMs) {
+  // Obtain various parameters from Variations.
   suggestions_url_ =
       GURL(GetExperimentParam(kSuggestionsFieldTrialURLParam) +
            GetExperimentParam(kSuggestionsFieldTrialSuggestionsSuffixParam));
   blacklist_url_prefix_ =
       GetExperimentParam(kSuggestionsFieldTrialURLParam) +
       GetExperimentParam(kSuggestionsFieldTrialBlacklistSuffixParam);
+  std::string timeout = GetExperimentParam(kSuggestionsFieldTrialTimeoutMs);
+  if (!timeout.empty()) {
+    base::StringToInt(timeout, &request_timeout_ms_);

[manzagop (departed), 2014/06/17 18:16:45]

If returns false, fallback to the default value.

[Mathieu, 2014/06/17 19:49:44]

Done.

+  }
 }
 
 SuggestionsService::~SuggestionsService() {}
 
 // static
 bool SuggestionsService::IsEnabled() {
   return GetExperimentParam(kSuggestionsFieldTrialStateParam) ==
          kSuggestionsFieldTrialStateEnabled;
 }
 
 void SuggestionsService::FetchSuggestionsData(
     SuggestionsService::ResponseCallback callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   FetchSuggestionsDataNoTimeout(callback);
 
   // Post a task to serve the cached suggestions if the request hasn't completed
   // after some time. Cancels the previous such task, if one existed.
   pending_timeout_closure_.reset(new CancelableClosure(base::Bind(
       &SuggestionsService::OnRequestTimeout, weak_ptr_factory_.GetWeakPtr())));
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE, pending_timeout_closure_->callback(),
-      base::TimeDelta::FromMilliseconds(kRequestTimeoutMs));
+      base::TimeDelta::FromMilliseconds(request_timeout_ms_));
 }
 
 void SuggestionsService::FetchSuggestionsDataNoTimeout(
     SuggestionsService::ResponseCallback callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (pending_request_.get()) {
     // Request already exists, so just add requestor to queue.
     waiting_requestors_.push_back(callback);
     return;
   }
@@ skipping 138 matching lines @@
   return request;
 }
 
 void SuggestionsService::ServeFromCache() {
   SuggestionsProfile suggestions;
   suggestions_store_->LoadSuggestions(&suggestions);
   DispatchRequestsAndClear(suggestions, &waiting_requestors_);
 }
 
 }  // namespace suggestions