Use |min| param to query a variable number of suggestions

components/suggestions/suggestions_service_impl.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 "components/suggestions/suggestions_service_impl.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/feature_list.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/field_trial_params.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/google/core/browser/google_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/signin_manager_base.h"
 #include "components/suggestions/blacklist_store.h"
+#include "components/suggestions/features.h"
 #include "components/suggestions/image_manager.h"
 #include "components/suggestions/suggestions_store.h"
 #include "components/sync/driver/sync_service.h"
 #include "components/variations/net/variations_http_headers.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/url_util.h"
@@ skipping 40 matching lines @@
 GURL GetGoogleBaseURL() {
   GURL url(google_util::CommandLineGoogleBaseURL());
   if (url.is_valid())
     return url;
   return GURL(kDefaultGoogleBaseURL);
 }
 
 // Format strings for the various suggestions URLs. They all have two string
 // params: The Google base URL and the device type.
 // TODO(mathp): Put this in TemplateURL.
-const char kSuggestionsURLFormat[] = "%schromesuggestions?t=%s";
+const char kSuggestionsURLFormat[] = "%schromesuggestions?%s";
 const char kSuggestionsBlacklistURLPrefixFormat[] =
     "%schromesuggestions/blacklist?t=%s&url=";
 const char kSuggestionsBlacklistClearURLFormat[] =
     "%schromesuggestions/blacklist/clear?t=%s";
 
 const char kSuggestionsBlacklistURLParam[] = "url";
+const char kSuggestionsDeviceParam[] = "t=%s";
+const char kSuggestionsMinParam[] = "min=%i";
+
+const char kSuggestionsMinVariationName[] = "min_suggestions";
+const int kSuggestionsMinVariationDefault = 0;
 
 #if defined(OS_ANDROID) || defined(OS_IOS)
 const char kDeviceType[] = "2";
 #else
 const char kDeviceType[] = "1";
 #endif
 
 // Format string for OAuth2 authentication headers.
 const char kAuthorizationHeaderFormat[] = "Authorization: Bearer %s";
 
 const char kFaviconURL[] =
     "https://s2.googleusercontent.com/s2/favicons?domain_url=%s&alt=s&sz=32";
 
 // The default expiry timeout is 168 hours.
 const int64_t kDefaultExpiryUsec = 168 * base::Time::kMicrosecondsPerHour;
 
+int GetMinimumSuggestionsCount() {
+  return base::GetFieldTrialParamByFeatureAsInt(
+      kUseSuggestionsEvenIfFewFeature, kSuggestionsMinVariationName,
+      kSuggestionsMinVariationDefault);
+}
+
 }  // namespace
 
 SuggestionsServiceImpl::SuggestionsServiceImpl(
     SigninManagerBase* signin_manager,
     OAuth2TokenService* token_service,
     syncer::SyncService* sync_service,
     net::URLRequestContextGetter* url_request_context,
     std::unique_ptr<SuggestionsStore> suggestions_store,
     std::unique_ptr<ImageManager> thumbnail_manager,
     std::unique_ptr<BlacklistStore> blacklist_store)
@@ skipping 131 matching lines @@
 
 // static
 void SuggestionsServiceImpl::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   SuggestionsStore::RegisterProfilePrefs(registry);
   BlacklistStore::RegisterProfilePrefs(registry);
 }
 
 // static
 GURL SuggestionsServiceImpl::BuildSuggestionsURL() {
+  std::string device = base::StringPrintf(kSuggestionsDeviceParam, kDeviceType);
+  std::string query = device;
+  if (base::FeatureList::IsEnabled(kUseSuggestionsEvenIfFewFeature)) {
+    std::string min_suggestions =
+        base::StringPrintf(kSuggestionsMinParam, GetMinimumSuggestionsCount());
+    query =
+        base::StringPrintf("%s&%s", device.c_str(), min_suggestions.c_str());
+  }
   return GURL(base::StringPrintf(
-      kSuggestionsURLFormat, GetGoogleBaseURL().spec().c_str(), kDeviceType));
+      kSuggestionsURLFormat, GetGoogleBaseURL().spec().c_str(), query.c_str()));
 }
 
 // static
 std::string SuggestionsServiceImpl::BuildSuggestionsBlacklistURLPrefix() {
   return base::StringPrintf(kSuggestionsBlacklistURLPrefixFormat,
                             GetGoogleBaseURL().spec().c_str(), kDeviceType);
 }
 
 // static
 GURL SuggestionsServiceImpl::BuildSuggestionsBlacklistURL(
@@ skipping 314 matching lines @@
     scheduling_delay_ = TimeDelta::FromSeconds(kDefaultSchedulingDelaySec);
   } else {
     TimeDelta candidate_delay =
         scheduling_delay_ * kSchedulingBackoffMultiplier;
     if (candidate_delay < TimeDelta::FromSeconds(kSchedulingMaxDelaySec))
       scheduling_delay_ = candidate_delay;
   }
 }
 
 }  // namespace suggestions