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 31 matching lines @@
 
 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";

[Marc Treib, 2016/05/12 08:59:16]

Also here: s/variant/personalization, or whatever you end up calling it.

[jkrcal, 2016/05/12 09:57:29]

Done.

+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";
+const char kVariantNonPersonalizedString[] = "non-personalized";
+const char kVariantAllString[] = "all";
+
+// Constants listing possible values of the "fetching_host_restrict" parameter.
+const char kHostRestrictionOnString[] = "on";
+const char kHostRestrictionOffString[] = "off";
 
 const char kRequestParameterFormat[] =
     "{"
     "  \"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\""
     "      },"
     "      \"content_restricts\": {"
     "        \"type\": \"METADATA\","
     "        \"value\": \"SNIPPET\""
     "      },"
@@ skipping 10 matching lines @@
     "  }"
     "}";
 
 const char kGaiaIdFormat[] = "  \"obfuscated_gaia_id\": \"%s\",";
 const char kUserSegmentFormat[] = "        ,\"user_segment\": \"%s\"";
 const char kHostRestrictFormat[] =
     "      ,\"content_selectors\": {"
     "        \"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:
@@ skipping 22 matching lines @@
       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;
+  if (variant == kVariantNonPersonalizedString) {
+    variant_ = Variant::kNonPersonalized;
   } else if (variant == kVariantPersonalizedString) {
     variant_ = Variant::kPersonalized;
   } else {
-    variant_ = Variant::kRestrictedPersonalized;
-    LOG_IF(WARNING,
-           !variant.empty() && variant != kVariantRestrictedPersonalizedString)
-        << "Unknown fetching variant provided: " << variant;
+    variant_ = Variant::kAll;
+    LOG_IF(WARNING, !variant.empty() && variant != kVariantAllString)
+        << "Unknown value for fetching_variant: " << variant;
+  }
+
+  std::string host_restriction = variations::GetVariationParamValue(
+      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 fetching_host_restrict: " << host_restriction;
   }
 }
 
 NTPSnippetsFetcher::~NTPSnippetsFetcher() {
   if (waiting_for_refresh_token_)
     token_service_->RemoveObserver(this);
 }
 
 void NTPSnippetsFetcher::SetCallback(
     const SnippetsAvailableCallback& callback) {
@@ skipping 71 matching lines @@
 std::string NTPSnippetsFetcher::GetHostRestricts() const {
   std::string host_restricts;
   if (UseHostRestriction()) {
     for (const std::string& host : hosts_)
       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 (variant_ == Variant::kPersonalized || variant_ == Variant::kAll);
 }
 
 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_));
+      base::StringPrintf(kRequestParameterFormat, /*obfuscated_gaia_id=*/"",
+                         /* only_return_personalized_results=*/kFalseString,
+                         /*user_segment=*/"", GetHostRestricts().c_str(),
+                         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());

[Marc Treib, 2016/05/12 08:59:16]

nit: rename to gaia_id or something? It's not authentication.

[jkrcal, 2016/05/12 09:57:29]

Done.

   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(),

[Marc Treib, 2016/05/12 08:59:16]

Maybe make a BuildRequestParameter helper function?

[jkrcal, 2016/05/12 09:57:28]

Done.

+                         variant_ == Variant::kAll ? kFalseString : kTrueString,

[Marc Treib, 2016/05/12 08:59:16]

Ah, so when we get here, the variant can't be kNonPersonalized anymore, right?
Still, I'd find it easier to read if this said
variant_ == kPersonalized ? kTrue : kFalse
which should be equivalent, right?

[jkrcal, 2016/05/12 09:57:29]

Done.

                          user_segment.c_str(), GetHostRestricts().c_str(),
                          count_to_fetch_));
 }
 
 void NTPSnippetsFetcher::StartTokenRequest() {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(kApiScope);
   oauth_request_ = token_service_->StartRequest(
       signin_manager_->GetAuthenticatedAccountId(), scopes, this);
 }
@@ skipping 109 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