Allow getting _only_ personalized snippets for NTP.

components/ntp_snippets/ntp_snippets_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/ntp_snippets_fetcher.h"
 
 #include <stdlib.h>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 30 matching lines @@
 namespace ntp_snippets {
 
 namespace {
 
 const char kApiScope[] = "https://www.googleapis.com/auth/webhistory";
 const char kSnippetsServer[] =
     "https://chromereader-pa.googleapis.com/v1/fetch";
 const char kSnippetsServerNonAuthorizedFormat[] = "%s?key=%s";
 const char kAuthorizationRequestHeaderFormat[] = "Bearer %s";
 
-// Variation parameter for the variant of fetching to use.
-const char kVariantName[] = "fetching_variant";
+// Variation parameter for personalizing fetching of snippets.
+const char kPersonalizationName[] = "fetching_personalization";
+// Variation parameter for setting whether to restrict to a passed set of hosts.
+const char kHostRestrictionName[] = "fetching_host_restrict";
 
-// Constants listing possible values of the "fetching_variant" parameter.
-const char kVariantRestrictedString[] = "restricted";
-const char kVariantPersonalizedString[] = "personalized";
-const char kVariantRestrictedPersonalizedString[] = "restricted_personalized";
+// 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 char kRequestParameterFormat[] =
+// Constants for possible values of the "fetching_host_restrict" parameter.
+const char kHostRestrictionOnString[] = "on";  // the default value
+const char kHostRestrictionOffString[] = "off";
+
+const char kRequestFormat[] =
     "{"
     "  \"response_detail_level\": \"STANDARD\","
     "%s"  // If authenticated - an obfuscated Gaia ID will be inserted here.
     "  \"advanced_options\": {"
     "    \"local_scoring_params\": {"
     "      \"content_params\": {"
-    "        \"only_return_personalized_results\": false"
+    "        \"only_return_personalized_results\": %s"
     "%s"  // If authenticated - user segment (lang code) will be inserted here.
     "      },"
     "      \"content_restricts\": ["
     "        {"
     "          \"type\": \"METADATA\","
     "          \"value\": \"TITLE\""
     "        },"
     "        {"
     "          \"type\": \"METADATA\","
     "          \"value\": \"SNIPPET\""
@@ skipping 12 matching lines @@
     "  }"
     "}";
 
 const char kGaiaIdFormat[] = "  \"obfuscated_gaia_id\": \"%s\",";
 const char kUserSegmentFormat[] = "        ,\"user_segment\": \"%s\"";
 const char kHostRestrictFormat[] =
     "      {"
     "        \"type\": \"HOST_RESTRICT\","
     "        \"value\": \"%s\""
     "      }";
+const char kTrueString[] = "true";
+const char kFalseString[] = "false";
 
 std::string FetchResultToString(NTPSnippetsFetcher::FetchResult result) {
   switch (result) {
     case NTPSnippetsFetcher::FetchResult::SUCCESS:
       return "OK";
     case NTPSnippetsFetcher::FetchResult::EMPTY_HOSTS:
       return "Cannot fetch for empty hosts list.";
     case NTPSnippetsFetcher::FetchResult::URL_REQUEST_STATUS_ERROR:
       return "URLRequestStatus error";
     case NTPSnippetsFetcher::FetchResult::HTTP_ERROR:
       return "HTTP error";
     case NTPSnippetsFetcher::FetchResult::JSON_PARSE_ERROR:
       return "Received invalid JSON";
     case NTPSnippetsFetcher::FetchResult::INVALID_SNIPPET_CONTENT_ERROR:
       return "Invalid / empty list.";
+    case NTPSnippetsFetcher::FetchResult::OAUTH_TOKEN_ERROR:
+      return "Error in obtaining an OAuth2 access token.";
     case NTPSnippetsFetcher::FetchResult::RESULT_MAX:
       break;
   }
   NOTREACHED();
   return "Unknown error";
 }
 
+std::string BuildRequest(const std::string& obfuscated_gaia_id,
+                         bool only_return_personalized_results,
+                         const std::string& user_segment,
+                         const std::string& host_restricts,
+                         int count_to_fetch) {
+  return base::StringPrintf(
+      kRequestFormat, obfuscated_gaia_id.c_str(),
+      only_return_personalized_results ? kTrueString : kFalseString,
+      user_segment.c_str(), host_restricts.c_str(), count_to_fetch);
+}
+
 }  // namespace
 
 NTPSnippetsFetcher::NTPSnippetsFetcher(
     SigninManagerBase* signin_manager,
     OAuth2TokenService* token_service,
     scoped_refptr<URLRequestContextGetter> url_request_context_getter,
     const ParseJSONCallback& parse_json_callback,
     bool is_stable_channel)
     : OAuth2TokenService::Consumer("ntp_snippets"),
       signin_manager_(signin_manager),
       token_service_(token_service),
       waiting_for_refresh_token_(false),
       url_request_context_getter_(url_request_context_getter),
       parse_json_callback_(parse_json_callback),
       is_stable_channel_(is_stable_channel),
       tick_clock_(new base::DefaultTickClock()),
       weak_ptr_factory_(this) {
   // Parse the variation parameters and set the defaults if missing.
-  std::string variant = variations::GetVariationParamValue(
-      ntp_snippets::kStudyName, kVariantName);
-  if (variant == kVariantRestrictedString) {
-    variant_ = Variant::kRestricted;
-  } else if (variant == kVariantPersonalizedString) {
-    variant_ = Variant::kPersonalized;
+  std::string personalization = variations::GetVariationParamValue(
+      ntp_snippets::kStudyName, kPersonalizationName);
+  if (personalization == kPersonalizationNonPersonalString) {
+    personalization_ = Personalization::kNonPersonal;
+  } else if (personalization == kPersonalizationPersonalString) {
+    personalization_ = Personalization::kPersonal;
   } else {
-    variant_ = Variant::kRestrictedPersonalized;
-    LOG_IF(WARNING,
-           !variant.empty() && variant != kVariantRestrictedPersonalizedString)
-        << "Unknown fetching variant provided: " << variant;
+    personalization_ = Personalization::kBoth;
+    LOG_IF(WARNING, !personalization.empty() &&
+                        personalization != kPersonalizationBothString)
+        << "Unknown value for " << kPersonalizationName << ": "
+        << personalization;
+  }
+
+  std::string host_restriction = variations::GetVariationParamValue(

[Marc Treib, 2016/05/17 14:54:42]

Post-commit comment: The non-host-restricted case will occasionally break right
now, because the NTPSnippetsService (unconditionally) filters by host in
OnSuggestionsChanged.

+      ntp_snippets::kStudyName, kHostRestrictionName);
+  if (host_restriction == kHostRestrictionOffString) {
+    use_host_restriction_ = false;
+  } else {
+    use_host_restriction_ = true;
+    LOG_IF(WARNING, !host_restriction.empty() &&
+                        host_restriction != kHostRestrictionOnString)
+        << "Unknown value for " << kHostRestrictionName << ": "
+        << host_restriction;
   }
 }
 
 NTPSnippetsFetcher::~NTPSnippetsFetcher() {
   if (waiting_for_refresh_token_)
     token_service_->RemoveObserver(this);
 }
 
 void NTPSnippetsFetcher::SetCallback(
     const SnippetsAvailableCallback& callback) {
@@ skipping 74 matching lines @@
     for (const std::string& host : hosts_) {
       if (!host_restricts.empty())
         host_restricts.push_back(',');
       host_restricts += base::StringPrintf(kHostRestrictFormat, host.c_str());
     }
   }
   return host_restricts;
 }
 
 bool NTPSnippetsFetcher::UseHostRestriction() const {
-  return (variant_ == Variant::kRestricted ||
-          variant_ == Variant::kRestrictedPersonalized) &&
+  return use_host_restriction_ &&
          !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kDontRestrict);
 }
 
 bool NTPSnippetsFetcher::UseAuthentication() const {
-  return (variant_ == Variant::kPersonalized ||
-          variant_ == Variant::kRestrictedPersonalized);
+  return (personalization_ == Personalization::kPersonal ||
+          personalization_ == Personalization::kBoth);
 }
 
 void NTPSnippetsFetcher::FetchSnippetsNonAuthenticated() {
   // When not providing OAuth token, we need to pass the Google API key.
   const std::string& key = is_stable_channel_
                                ? google_apis::GetAPIKey()
                                : google_apis::GetNonStableAPIKey();
   GURL url(base::StringPrintf(kSnippetsServerNonAuthorizedFormat,
                               kSnippetsServer, key.c_str()));
 
-  FetchSnippetsImpl(
-      url, std::string(),
-      base::StringPrintf(kRequestParameterFormat, "", "",
-                         GetHostRestricts().c_str(), count_to_fetch_));
+  FetchSnippetsImpl(url, std::string(),
+                    BuildRequest(/*obfuscated_gaia_id=*/std::string(),
+                                 /*only_return_personalized_results=*/false,
+                                 /*user_segment=*/std::string(),
+                                 GetHostRestricts(), count_to_fetch_));
 }
 
 void NTPSnippetsFetcher::FetchSnippetsAuthenticated(
     const std::string& account_id,
     const std::string& oauth_access_token) {
-  std::string auth = base::StringPrintf(kGaiaIdFormat, account_id.c_str());
+  std::string gaia_id = base::StringPrintf(kGaiaIdFormat, account_id.c_str());
   std::string user_segment =
       base::StringPrintf(kUserSegmentFormat, locale_.c_str());
 
   FetchSnippetsImpl(
       GURL(kSnippetsServer),
       base::StringPrintf(kAuthorizationRequestHeaderFormat,
                          oauth_access_token.c_str()),
-      base::StringPrintf(kRequestParameterFormat, auth.c_str(),
-                         user_segment.c_str(), GetHostRestricts().c_str(),
-                         count_to_fetch_));
+      BuildRequest(gaia_id, personalization_ == Personalization::kPersonal,
+                   user_segment, GetHostRestricts(), count_to_fetch_));
 }
 
 void NTPSnippetsFetcher::StartTokenRequest() {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(kApiScope);
   oauth_request_ = token_service_->StartRequest(
       signin_manager_->GetAuthenticatedAccountId(), scopes, this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 10 matching lines @@
 
   FetchSnippetsAuthenticated(oauth_request->GetAccountId(), access_token);
 }
 
 void NTPSnippetsFetcher::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   oauth_request_.reset();
   DLOG(ERROR) << "Unable to get token: " << error.ToString()
               << " - fetching the snippets without authentication.";
-
-  // Fallback to fetching non-authenticated tokens.
-  FetchSnippetsNonAuthenticated();
+  FetchFinished(
+      OptionalSnippets(), FetchResult::OAUTH_TOKEN_ERROR,
+      /*extra_message=*/base::StringPrintf(" (%s)", error.ToString().c_str()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // OAuth2TokenService::Observer overrides
 void NTPSnippetsFetcher::OnRefreshTokenAvailable(
     const std::string& account_id) {
   // Only react on tokens for the account the user has signed in with.
   if (account_id != signin_manager_->GetAuthenticatedAccountId())
     return;
 
@@ skipping 74 matching lines @@
                       tick_clock_->NowTicks() - fetch_start_time_);
   UMA_HISTOGRAM_ENUMERATION("NewTabPage.Snippets.FetchResult",
                             static_cast<int>(result),
                             static_cast<int>(FetchResult::RESULT_MAX));
 
   if (!snippets_available_callback_.is_null())
     snippets_available_callback_.Run(std::move(snippets));
 }
 
 }  // namespace ntp_snippets