RemoteSuggestionsFetcher: Remove ChromeReader integration

components/ntp_snippets/remote/json_request.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/json_request.h"
 
 #include <algorithm>
 #include <utility>
 #include <vector>
 
@@ skipping 200 matching lines @@
 
 void JsonRequest::OnJsonError(const std::string& error) {
   std::string json_string;
   url_fetcher_->GetResponseAsString(&json_string);
   LOG(WARNING) << "Received invalid JSON (" << error << "): " << json_string;
   std::move(request_completed_callback_)
       .Run(/*result=*/nullptr, FetchResult::JSON_PARSE_ERROR,
            /*error_details=*/base::StringPrintf(" (error %s)", error.c_str()));
 }
 
-JsonRequest::Builder::Builder()
-    : fetch_api_(CHROME_READER_API),
-      language_model_(nullptr) {}
+JsonRequest::Builder::Builder() : language_model_(nullptr) {}
 JsonRequest::Builder::Builder(JsonRequest::Builder&&) = default;
 JsonRequest::Builder::~Builder() = default;
 
 std::unique_ptr<JsonRequest> JsonRequest::Builder::Build() const {
   DCHECK(!url_.is_empty());
   DCHECK(url_request_context_getter_);
   DCHECK(clock_);
   auto request = base::MakeUnique<JsonRequest>(params_.exclusive_category,
                                                clock_, parse_json_callback_);
   std::string body = BuildBody();
   std::string headers = BuildHeaders();
   request->url_fetcher_ = BuildURLFetcher(request.get(), headers, body);
 
   // Log the request for debugging network issues.
   VLOG(1) << "Sending a NTP snippets request to " << url_ << ":\n"
           << headers << "\n"
           << body;
 
   return request;
 }
 
 JsonRequest::Builder& JsonRequest::Builder::SetAuthentication(
     const std::string& account_id,
     const std::string& auth_header) {
   obfuscated_gaia_id_ = account_id;
   auth_header_ = auth_header;
   return *this;
 }
 
-JsonRequest::Builder& JsonRequest::Builder::SetFetchAPI(FetchAPI fetch_api) {
-  fetch_api_ = fetch_api;
-  return *this;
-}
-
 JsonRequest::Builder& JsonRequest::Builder::SetLanguageModel(
     const translate::LanguageModel* language_model) {
   language_model_ = language_model;
   return *this;
 }
 
 JsonRequest::Builder& JsonRequest::Builder::SetParams(
     const RequestParams& params) {
   params_ = params;
   return *this;
@@ skipping 42 matching lines @@
   variations::AppendVariationHeaders(url_,
                                      false,  // incognito
                                      false,  // uma_enabled
                                      is_signed_in, &headers);
   return headers.ToString();
 }
 
 std::string JsonRequest::Builder::BuildBody() const {
   auto request = base::MakeUnique<base::DictionaryValue>();
   std::string user_locale = PosixLocaleFromBCP47Language(params_.language_code);
-  switch (fetch_api_) {
-    case CHROME_READER_API: {
-      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));
-      }
+  if (!user_locale.empty()) {
+    request->SetString("uiLanguage", user_locale);
+  }
 
-      auto local_scoring_params = base::MakeUnique<base::DictionaryValue>();
-      local_scoring_params->Set("content_restricts",
-                                std::move(content_restricts));
+  request->SetString("priority", params_.interactive_request
+                                     ? "USER_ACTION"
+                                     : "BACKGROUND_PREFETCH");
 
-      auto global_scoring_params = base::MakeUnique<base::DictionaryValue>();
-      global_scoring_params->SetInteger("num_to_return",
-                                        params_.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));
-
-      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_);
-      }
-      if (!user_locale.empty()) {
-        request->SetString("user_locale", user_locale);
-      }
-      break;
-    }
-
-    case CHROME_CONTENT_SUGGESTIONS_API: {
-      if (!user_locale.empty()) {
-        request->SetString("uiLanguage", user_locale);
-      }
-
-      request->SetString("priority", params_.interactive_request
-                                         ? "USER_ACTION"
-                                         : "BACKGROUND_PREFETCH");
-
-      auto excluded = base::MakeUnique<base::ListValue>();
-      for (const auto& id : params_.excluded_ids) {
-        excluded->AppendString(id);
-        if (excluded->GetSize() >= kMaxExcludedIds) {
-          break;
-        }
-      }
-      request->Set("excludedSuggestionIds", std::move(excluded));
-
-      if (!user_class_.empty()) {
-        request->SetString("userActivenessClass", user_class_);
-      }
-
-      translate::LanguageModel::LanguageInfo ui_language;
-      translate::LanguageModel::LanguageInfo other_top_language;
-      PrepareLanguages(&ui_language, &other_top_language);
-
-      if (ui_language.frequency == 0 && other_top_language.frequency == 0) {
-        break;
-      }
-
-      auto language_list = base::MakeUnique<base::ListValue>();
-      if (ui_language.frequency > 0) {
-        AppendLanguageInfoToList(language_list.get(), ui_language);
-      }
-      if (other_top_language.frequency > 0) {
-        AppendLanguageInfoToList(language_list.get(), other_top_language);
-      }
-      request->Set("topLanguages", std::move(language_list));
-
-      // TODO(sfiera): Support count_to_fetch.
+  auto excluded = base::MakeUnique<base::ListValue>();
+  for (const auto& id : params_.excluded_ids) {
+    excluded->AppendString(id);
+    if (excluded->GetSize() >= kMaxExcludedIds) {
       break;
     }
   }
+  request->Set("excludedSuggestionIds", std::move(excluded));
+
+  if (!user_class_.empty()) {
+    request->SetString("userActivenessClass", user_class_);
+  }
+
+  translate::LanguageModel::LanguageInfo ui_language;
+  translate::LanguageModel::LanguageInfo other_top_language;
+  PrepareLanguages(&ui_language, &other_top_language);
+  if (ui_language.frequency != 0 || other_top_language.frequency != 0) {
+    auto language_list = base::MakeUnique<base::ListValue>();
+    if (ui_language.frequency > 0) {
+      AppendLanguageInfoToList(language_list.get(), ui_language);
+    }
+    if (other_top_language.frequency > 0) {
+      AppendLanguageInfoToList(language_list.get(), other_top_language);
+    }
+    request->Set("topLanguages", std::move(language_list));
+  }
+
+  // TODO(sfiera): Support count_to_fetch.
 
   std::string request_json;
   bool success = base::JSONWriter::WriteWithOptions(
       *request, base::JSONWriter::OPTIONS_PRETTY_PRINT, &request_json);
   DCHECK(success);
   return request_json;
 }
 
 std::unique_ptr<net::URLFetcher> JsonRequest::Builder::BuildURLFetcher(
     net::URLFetcherDelegate* delegate,
@@ skipping 79 matching lines @@
           "NewTabPage.Languages.UILanguageRatioInTwoTopLanguages",
           ratio_ui_in_both_languages * 100);
       break;
     }
   }
 }
 
 }  // namespace internal
 
 }  // namespace ntp_snippets