Generate snippets request JSON with base::Value.

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"
 #include "base/files/file_util.h"
+#include "base/json/json_writer.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/default_tick_clock.h"
 #include "base/values.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/ntp_snippets/ntp_snippets_constants.h"
@@ skipping 33 matching lines @@
 
 // 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
 
 // 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\": %s"
-    "%s"  // If authenticated - user segment (lang code) will be inserted here.
-    "      },"
-    "      \"content_restricts\": ["
-    "        {"
-    "          \"type\": \"METADATA\","
-    "          \"value\": \"TITLE\""
-    "        },"
-    "        {"
-    "          \"type\": \"METADATA\","
-    "          \"value\": \"SNIPPET\""
-    "        },"
-    "        {"
-    "          \"type\": \"METADATA\","
-    "          \"value\": \"THUMBNAIL\""
-    "        }"
-    "      ],"
-    "      \"content_selectors\": [%s]"
-    "    },"
-    "    \"global_scoring_params\": {"
-    "      \"num_to_return\": %i,"
-    "      \"sort_type\": 1"
-    "    }"
-    "  }"
-    "}";
-
-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),
@@ skipping 78 matching lines @@
       // Wait until we get a refresh token.
       waiting_for_refresh_token_ = true;
       token_service_->AddObserver(this);
     }
   } else {
     // Not signed in: fetch snippets (without authentication).
     FetchSnippetsNonAuthenticated();
   }
 }
 
+// static
+std::string NTPSnippetsFetcher::BuildRequest(
+    const std::string& obfuscated_gaia_id,
+    bool only_return_personalized_results,
+    const std::string& user_segment,
+    const std::set<std::string>& host_restricts,
+    int count_to_fetch) {
+  auto content_params = base::MakeUnique<base::DictionaryValue>();
+  content_params->SetBoolean("only_return_personalized_results",
+                             only_return_personalized_results);
+  if (!user_segment.empty()) {
+    content_params->SetString("user_segment", user_segment);
+  }
+
+  auto content_restricts = base::MakeUnique<base::ListValue>();
+  for (const auto& metadata : {"TITLE", "SNIPPET", "THUMBNAIL"}) {
+    auto entry = base::MakeUnique<base::DictionaryValue>();
+    entry->SetString("type", "METADATA");
+    entry->SetString("value", metadata);
+    content_restricts->Append(std::move(entry));
+  }
+
+  auto content_selectors = base::MakeUnique<base::ListValue>();
+  for (const auto& host : host_restricts) {
+    auto entry = base::MakeUnique<base::DictionaryValue>();
+    entry->SetString("type", "HOST_RESTRICT");
+    entry->SetString("value", host);
+    content_selectors->Append(std::move(entry));
+  }
+
+  auto local_scoring_params = base::MakeUnique<base::DictionaryValue>();
+  local_scoring_params->Set("content_params", std::move(content_params));
+  local_scoring_params->Set("content_restricts", std::move(content_restricts));
+  local_scoring_params->Set("content_selectors", std::move(content_selectors));
+
+  auto global_scoring_params = base::MakeUnique<base::DictionaryValue>();
+  global_scoring_params->SetInteger("num_to_return", count_to_fetch);
+  global_scoring_params->SetInteger("sort_type", 1);
+
+  auto advanced = base::MakeUnique<base::DictionaryValue>();
+  advanced->Set("local_scoring_params", std::move(local_scoring_params));
+  advanced->Set("global_scoring_params", std::move(global_scoring_params));
+
+  auto request = base::MakeUnique<base::DictionaryValue>();
+  request->SetString("response_detail_level", "STANDARD");
+  request->Set("advanced_options", std::move(advanced));
+  if (!obfuscated_gaia_id.empty()) {
+    request->SetString("obfuscated_gaia_id", obfuscated_gaia_id);
+  }
+
+  std::string request_json;
+  bool success = base::JSONWriter::WriteWithOptions(
+      *request, base::JSONWriter::OPTIONS_PRETTY_PRINT, &request_json);
+  DCHECK(success);
+  return request_json;
+}
+
 void NTPSnippetsFetcher::FetchSnippetsImpl(const GURL& url,
                                            const std::string& auth_header,
                                            const std::string& request) {
   url_fetcher_ = URLFetcher::Create(url, URLFetcher::POST, this);
 
   url_fetcher_->SetRequestContext(url_request_context_getter_.get());
   url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                              net::LOAD_DO_NOT_SAVE_COOKIES);
 
   data_use_measurement::DataUseUserData::AttachToFetcher(
       url_fetcher_.get(), data_use_measurement::DataUseUserData::NTP_SNIPPETS);
 
   HttpRequestHeaders headers;
   if (!auth_header.empty())
     headers.SetHeader("Authorization", auth_header);
   headers.SetHeader("Content-Type", "application/json; charset=UTF-8");
   url_fetcher_->SetExtraRequestHeaders(headers.ToString());
   url_fetcher_->SetUploadData("application/json", request);
   // Fetchers are sometimes cancelled because a network change was detected.
   url_fetcher_->SetAutomaticallyRetryOnNetworkChanges(3);
   // Try to make fetching the files bit more robust even with poor connection.
   url_fetcher_->SetMaxRetriesOn5xx(3);
   url_fetcher_->Start();
 }
 
-std::string NTPSnippetsFetcher::GetHostRestricts() const {
-  std::string host_restricts;
-  if (UsesHostRestrictions()) {
-    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::UsesHostRestrictions() const {
   return use_host_restriction_ &&
          !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kDontRestrict);
 }
 
 bool NTPSnippetsFetcher::UsesAuthentication() const {
   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(),
-                    BuildRequest(/*obfuscated_gaia_id=*/std::string(),
-                                 /*only_return_personalized_results=*/false,
-                                 /*user_segment=*/std::string(),
-                                 GetHostRestricts(), count_to_fetch_));
+  FetchSnippetsImpl(
+      url, std::string(),
+      BuildRequest(/*obfuscated_gaia_id=*/std::string(),
+                   /*only_return_personalized_results=*/false,
+                   /*user_segment=*/std::string(),
+                   UsesHostRestrictions() ? hosts_ : std::set<std::string>(),
+                   count_to_fetch_));
 }
 
 void NTPSnippetsFetcher::FetchSnippetsAuthenticated(
     const std::string& account_id,
     const std::string& oauth_access_token) {
-  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()),
-      BuildRequest(gaia_id, personalization_ == Personalization::kPersonal,
-                   user_segment, GetHostRestricts(), count_to_fetch_));
+      BuildRequest(account_id, personalization_ == Personalization::kPersonal,
+                   locale_,
+                   UsesHostRestrictions() ? hosts_ : std::set<std::string>(),
+                   count_to_fetch_));
 }
 
 void NTPSnippetsFetcher::StartTokenRequest() {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(kApiScope);
   oauth_request_ = token_service_->StartRequest(
       signin_manager_->GetAuthenticatedAccountId(), scopes, this);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 107 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