[Remote suggestions] Clean up variation params in the fetcher.

components/ntp_snippets/remote/remote_suggestions_fetcher.cc

 // Copyright 2016 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/ntp_snippets/remote/remote_suggestions_fetcher.h"
 
 #include <cstdlib>
 #include <utility>
 
 #include "base/files/file_path.h"
@@ skipping 34 matching lines @@
 
 namespace {
 
 const char kChromeReaderApiScope[] =
     "https://www.googleapis.com/auth/webhistory";
 const char kContentSuggestionsApiScope[] =
     "https://www.googleapis.com/auth/chrome-content-suggestions";
 const char kSnippetsServerNonAuthorizedFormat[] = "%s?key=%s";
 const char kAuthorizationRequestHeaderFormat[] = "Bearer %s";
 
-// Variation parameter for personalizing fetching of suggestions.
-const char kPersonalizationName[] = "fetching_personalization";
-
 // Variation parameter for chrome-content-suggestions backend.
 const char kContentSuggestionsBackend[] = "content_suggestions_backend";
 
-// Constants for possible values of the "fetching_personalization" parameter.
-const char kPersonalizationPersonalString[] = "personal";
-const char kPersonalizationNonPersonalString[] = "non_personal";
-const char kPersonalizationBothString[] = "both";  // the default value
-
 const int kFetchTimeHistogramResolution = 5;
 
 std::string FetchResultToString(FetchResult result) {
   switch (result) {
     case FetchResult::SUCCESS:
       return "OK";
     case FetchResult::DEPRECATED_EMPTY_HOSTS:
       return "Cannot fetch for empty hosts list.";
     case FetchResult::URL_REQUEST_STATUS_ERROR:
       return "URLRequestStatus error";
@@ skipping 36 matching lines @@
     case FetchResult::JSON_PARSE_ERROR:
       return Status(StatusCode::TEMPORARY_ERROR, FetchResultToString(result));
     case FetchResult::RESULT_MAX:
       break;
   }
   NOTREACHED();
   return Status(StatusCode::PERMANENT_ERROR, std::string());
 }
 
 std::string GetFetchEndpoint() {
-  std::string endpoint = variations::GetVariationParamValue(
-      ntp_snippets::kStudyName, kContentSuggestionsBackend);
+  std::string endpoint = variations::GetVariationParamValueByFeature(
+      ntp_snippets::kArticleSuggestionsFeature, kContentSuggestionsBackend);
   return endpoint.empty() ? kContentSuggestionsServer : endpoint;
 }
 
 bool UsesChromeContentSuggestionsAPI(const GURL& endpoint) {
   if (endpoint == kChromeReaderServer) {
     return false;
   }
 
   if (endpoint != kContentSuggestionsServer &&
       endpoint != kContentSuggestionsStagingServer &&
       endpoint != kContentSuggestionsAlphaServer) {
     LOG(WARNING) << "Unknown value for " << kContentSuggestionsBackend << ": "
-                 << "assuming chromecontentsuggestions-style API";
+                 << endpoint << "; assuming chromecontentsuggestions-style API";
   }
   return true;
 }
 
 // Creates suggestions from dictionary values in |list| and adds them to
 // |suggestions|. Returns true on success, false if anything went wrong.
 // |remote_category_id| is only used if |content_suggestions_api| is true.
 bool AddSuggestionsFromListValue(bool content_suggestions_api,
                                  int remote_category_id,
                                  const base::ListValue& list,
@@ skipping 123 matching lines @@
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_RARE_NTP_USER),
       request_throttler_active_ntp_user_(
           pref_service,
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_ACTIVE_NTP_USER),
       request_throttler_active_suggestions_consumer_(
           pref_service,
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_ACTIVE_SUGGESTIONS_CONSUMER),
-      weak_ptr_factory_(this) {
-  std::string personalization = variations::GetVariationParamValue(
-      ntp_snippets::kStudyName, kPersonalizationName);
-  if (personalization == kPersonalizationNonPersonalString) {
-    personalization_ = Personalization::kNonPersonal;
-  } else if (personalization == kPersonalizationPersonalString) {
-    personalization_ = Personalization::kPersonal;
-  } else {
-    personalization_ = Personalization::kBoth;
-    LOG_IF(WARNING, !personalization.empty() &&
-                        personalization != kPersonalizationBothString)
-        << "Unknown value for " << kPersonalizationName << ": "
-        << personalization;
-  }
-}
+      weak_ptr_factory_(this) {}
 
 RemoteSuggestionsFetcher::~RemoteSuggestionsFetcher() {
   if (waiting_for_refresh_token_) {
     token_service_->RemoveObserver(this);
   }
 }
 
 void RemoteSuggestionsFetcher::FetchSnippets(
     const RequestParams& params,
     SnippetsAvailableCallback callback) {
@@ skipping 14 matching lines @@
                                 GetMinuteOfTheDay(/*local_time=*/false,
                                                   /*reduced_resolution=*/true));
   }
 
   JsonRequest::Builder builder;
   builder.SetFetchAPI(fetch_api_)
       .SetFetchAPI(fetch_api_)
       .SetLanguageModel(language_model_)
       .SetParams(params)
       .SetParseJsonCallback(parse_json_callback_)
-      .SetPersonalization(personalization_)
       .SetTickClock(tick_clock_.get())
       .SetUrlRequestContextGetter(url_request_context_getter_)
       .SetUserClassifier(*user_classifier_);
 
-  if (NeedsAuthentication() && signin_manager_->IsAuthenticated()) {
+  if (signin_manager_->IsAuthenticated()) {
     // Signed-in: get OAuth token --> fetch suggestions.
     oauth_token_retried_ = false;
     pending_requests_.emplace(std::move(builder), std::move(callback));
     StartTokenRequest();
-  } else if (NeedsAuthentication() && signin_manager_->AuthInProgress()) {
+  } else if (signin_manager_->AuthInProgress()) {
     // Currently signing in: wait for auth to finish (the refresh token) -->
     //     get OAuth token --> fetch suggestions.
     pending_requests_.emplace(std::move(builder), std::move(callback));
     if (!waiting_for_refresh_token_) {
       // Wait until we get a refresh token.
       waiting_for_refresh_token_ = true;
       token_service_->AddObserver(this);
     }
   } else {
     // Not signed in: fetch suggestions (without authentication).
@@ skipping 243 matching lines @@
       return request_throttler_active_ntp_user_.DemandQuotaForRequest(
           interactive_request);
     case UserClassifier::UserClass::ACTIVE_SUGGESTIONS_CONSUMER:
       return request_throttler_active_suggestions_consumer_
           .DemandQuotaForRequest(interactive_request);
   }
   NOTREACHED();
   return false;
 }
 
-bool RemoteSuggestionsFetcher::NeedsAuthentication() const {
-  return (personalization_ == Personalization::kPersonal ||
-          personalization_ == Personalization::kBoth);
-}
-
-std::string RemoteSuggestionsFetcher::PersonalizationModeString() const {
-  switch (personalization_) {
-    case Personalization::kPersonal:
-      return "Only personalized";
-      break;
-    case Personalization::kBoth:
-      return "Both personalized and non-personalized";
-      break;
-    case Personalization::kNonPersonal:
-      return "Only non-personalized";
-      break;
-  }
-  NOTREACHED();
-  return std::string();
-}
-
 }  // namespace ntp_snippets