NTP: Extract JSON requests from Fetcher.

components/ntp_snippets/remote/ntp_snippets_fetcher_unittest.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/ntp_snippets_fetcher.h"
 
 #include <deque>
 #include <map>
+#include <set>
 #include <utility>
+#include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/ntp_snippets/category.h"
 #include "components/ntp_snippets/features.h"
 #include "components/ntp_snippets/ntp_snippets_constants.h"
 #include "components/ntp_snippets/remote/ntp_snippet.h"
+#include "components/ntp_snippets/remote/ntp_snippets_request_params.h"
 #include "components/ntp_snippets/user_classifier.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/fake_signin_manager.h"
 #include "components/signin/core/browser/test_signin_client.h"
 #include "components/variations/entropy_provider.h"
 #include "components/variations/variations_params_manager.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace ntp_snippets {
 
 namespace {
 
 using testing::_;
 using testing::AllOf;
 using testing::ElementsAre;
 using testing::Eq;
 using testing::Field;
 using testing::IsEmpty;
 using testing::Not;
 using testing::NotNull;
 using testing::Pointee;
 using testing::PrintToString;
 using testing::Return;
 using testing::StartsWith;
-using testing::StrEq;
 using testing::WithArg;
 
 const char kAPIKey[] = "fakeAPIkey";
 const char kTestChromeReaderUrl[] =
     "https://chromereader-pa.googleapis.com/v1/fetch?key=fakeAPIkey";
 const char kTestChromeContentSuggestionsUrl[] =
     "https://chromecontentsuggestions-pa.googleapis.com/v1/suggestions/"
     "fetch?key=fakeAPIkey";
 
 // Artificial time delay for JSON parsing.
@@ skipping 68 matching lines @@
 }
 
 MATCHER_P(FirstCategoryHasInfo, info_matcher, "") {
   if (!arg->has_value() || arg->value().size() == 0) {
     *result_listener << "No category found.";
   }
   return testing::ExplainMatchResult(
       info_matcher, arg->value().front().info, result_listener);
 }
 
-MATCHER_P(EqualsJSON, json, "equals JSON") {
-  std::unique_ptr<base::Value> expected = base::JSONReader::Read(json);
-  if (!expected) {
-    *result_listener << "INTERNAL ERROR: couldn't parse expected JSON";
-    return false;
-  }
-
-  std::string err_msg;
-  int err_line, err_col;
-  std::unique_ptr<base::Value> actual = base::JSONReader::ReadAndReturnError(
-      arg, base::JSON_PARSE_RFC, nullptr, &err_msg, &err_line, &err_col);
-  if (!actual) {
-    *result_listener << "input:" << err_line << ":" << err_col << ": "
-                     << "parse error: " << err_msg;
-    return false;
-  }
-  return base::Value::Equals(actual.get(), expected.get());
-}
-
 class MockSnippetsAvailableCallback {
  public:
   // Workaround for gMock's lack of support for movable arguments.
   void WrappedRun(
       Status status,
       NTPSnippetsFetcher::OptionalFetchedCategories fetched_categories) {
     Run(status, &fetched_categories);
   }
 
   MOCK_METHOD2(
@@ skipping 84 matching lines @@
  public:
   std::unique_ptr<net::URLFetcher> CreateURLFetcher(
       int id, const GURL& url, net::URLFetcher::RequestType request_type,
       net::URLFetcherDelegate* d) override {
     return base::MakeUnique<net::FakeURLFetcher>(
         url, d, /*response_data=*/std::string(), net::HTTP_NOT_FOUND,
         net::URLRequestStatus::FAILED);
   }
 };
 
-void ParseJson(
-    const std::string& json,
-    const ntp_snippets::NTPSnippetsFetcher::SuccessCallback& success_callback,
-    const ntp_snippets::NTPSnippetsFetcher::ErrorCallback& error_callback) {
+void ParseJson(const std::string& json,
+               const SuccessCallback& success_callback,
+               const ErrorCallback& error_callback) {
   base::JSONReader json_reader;
   std::unique_ptr<base::Value> value = json_reader.ReadToValue(json);
   if (value) {
     success_callback.Run(std::move(value));
   } else {
     error_callback.Run(json_reader.GetErrorMessage());
   }
 }
 
-void ParseJsonDelayed(
-    const std::string& json,
-    const ntp_snippets::NTPSnippetsFetcher::SuccessCallback& success_callback,
-    const ntp_snippets::NTPSnippetsFetcher::ErrorCallback& error_callback) {
+void ParseJsonDelayed(const std::string& json,
+                      const SuccessCallback& success_callback,
+                      const ErrorCallback& error_callback) {
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ParseJson, json, std::move(success_callback),
                             std::move(error_callback)),
       base::TimeDelta::FromMilliseconds(kTestJsonParsingLatencyMs));
 }
 
 }  // namespace
 
 class NTPSnippetsFetcherTestBase : public testing::Test {
  public:
@@ skipping 11 matching lines @@
         signin_client_(base::MakeUnique<TestSigninClient>(nullptr)),
         account_tracker_(base::MakeUnique<AccountTrackerService>()),
         fake_signin_manager_(
             base::MakeUnique<FakeSigninManagerBase>(signin_client_.get(),
                                                     account_tracker_.get())),
         fake_token_service_(base::MakeUnique<FakeProfileOAuth2TokenService>()),
         pref_service_(base::MakeUnique<TestingPrefServiceSimple>()),
         test_url_(gurl) {
     RequestThrottler::RegisterProfilePrefs(pref_service_->registry());
     UserClassifier::RegisterProfilePrefs(pref_service_->registry());
-    translate::LanguageModel::RegisterProfilePrefs(pref_service()->registry());
     user_classifier_ = base::MakeUnique<UserClassifier>(pref_service_.get());
     // Increase initial time such that ticks are non-zero.
     mock_task_runner_->FastForwardBy(base::TimeDelta::FromMilliseconds(1234));
     ResetSnippetsFetcher();
   }
 
   void ResetSnippetsFetcher() {
     snippets_fetcher_ = base::MakeUnique<NTPSnippetsFetcher>(
         fake_signin_manager_.get(), fake_token_service_.get(),
         scoped_refptr<net::TestURLRequestContextGetter>(
@@ skipping 11 matching lines @@
                           base::Unretained(callback));
   }
 
   NTPSnippetsFetcher& snippets_fetcher() { return *snippets_fetcher_; }
   MockSnippetsAvailableCallback& mock_callback() { return mock_callback_; }
   void FastForwardUntilNoTasksRemain() {
     mock_task_runner_->FastForwardUntilNoTasksRemain();
   }
   base::HistogramTester& histogram_tester() { return histogram_tester_; }
 
-  NTPSnippetsFetcher::Params test_params() {
-    NTPSnippetsFetcher::Params result;
+  NTPSnippetsRequestParams test_params() {
+    NTPSnippetsRequestParams result;
     result.count_to_fetch = 1;
     result.interactive_request = true;
     return result;
   }
 
   void InitFakeURLFetcherFactory() {
     if (fake_url_fetcher_factory_) {
       return;
     }
     // Instantiation of factory automatically sets itself as URLFetcher's
@@ skipping 30 matching lines @@
   }
 
   void SetFakeResponse(const std::string& response_data,
                        net::HttpStatusCode response_code,
                        net::URLRequestStatus::Status status) {
     InitFakeURLFetcherFactory();
     fake_url_fetcher_factory_->SetFakeResponse(test_url_, response_data,
                                                response_code, status);
   }
 
-  std::unique_ptr<translate::LanguageModel> MakeLanguageModel(
-      const std::vector<std::string>& codes) {
-    std::unique_ptr<translate::LanguageModel> language_model =
-        base::MakeUnique<translate::LanguageModel>(pref_service());
-    // There must be at least 10 visits before the top languages are defined.
-    for (int i = 0; i < 10; i++) {
-      for (const auto& code : codes) {
-        language_model->OnPageVisited(code);
-      }
-    }
-    return language_model;
-  }
-
   TestingPrefServiceSimple* pref_service() const { return pref_service_.get(); }
 
  private:
   std::map<std::string, std::string> default_variation_params_;
   // TODO(fhorschig): Make it a simple member when crbug.com/672010 is resolved.
   std::unique_ptr<variations::testing::VariationParamsManager> params_manager_;
   scoped_refptr<base::TestMockTimeTaskRunner> mock_task_runner_;
   base::ThreadTaskRunnerHandle mock_task_runner_handle_;
   FailingFakeURLFetcherFactory failing_url_fetcher_factory_;
   // Initialized lazily in SetFakeResponse().
@@ skipping 22 matching lines @@
     : public NTPSnippetsFetcherTestBase {
  public:
   NTPSnippetsContentSuggestionsFetcherTest()
       : NTPSnippetsFetcherTestBase(GURL(kTestChromeContentSuggestionsUrl)) {
     SetDefaultVariationParam("content_suggestions_backend",
                              kContentSuggestionsServer);
     ResetSnippetsFetcher();
   }
 };
 
-TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestAuthenticated) {
-  NTPSnippetsFetcher::RequestBuilder builder;
-  NTPSnippetsFetcher::Params params;
-  params.excluded_ids = {"1234567890"};
-  params.count_to_fetch = 25;
-  params.interactive_request = false;
-  builder.SetParams(params)
-      .SetAuthentication("0BFUSGAIA", "headerstuff")
-      .SetPersonalization(NTPSnippetsFetcher::Personalization::kPersonal)
-      .SetUserClassForTesting("ACTIVE_NTP_USER")
-      .SetFetchAPI(NTPSnippetsFetcher::CHROME_READER_API);
-
-  EXPECT_THAT(builder.PreviewRequestHeadersForTesting(),
-              StrEq("Content-Type: application/json; charset=UTF-8\r\n"
-                    "Authorization: headerstuff\r\n"
-                    "\r\n"));
-  EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
-              EqualsJSON("{"
-                         "  \"response_detail_level\": \"STANDARD\","
-                         "  \"obfuscated_gaia_id\": \"0BFUSGAIA\","
-                         "  \"advanced_options\": {"
-                         "    \"local_scoring_params\": {"
-                         "      \"content_params\": {"
-                         "        \"only_return_personalized_results\": true"
-                         "      },"
-                         "      \"content_restricts\": ["
-                         "        {"
-                         "          \"type\": \"METADATA\","
-                         "          \"value\": \"TITLE\""
-                         "        },"
-                         "        {"
-                         "          \"type\": \"METADATA\","
-                         "          \"value\": \"SNIPPET\""
-                         "        },"
-                         "        {"
-                         "          \"type\": \"METADATA\","
-                         "          \"value\": \"THUMBNAIL\""
-                         "        }"
-                         "      ]"
-                         "    },"
-                         "    \"global_scoring_params\": {"
-                         "      \"num_to_return\": 25,"
-                         "      \"sort_type\": 1"
-                         "    }"
-                         "  }"
-                         "}"));
-
-  builder.SetFetchAPI(
-      NTPSnippetsFetcher::FetchAPI::CHROME_CONTENT_SUGGESTIONS_API);
-  EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
-              EqualsJSON("{"
-                         "  \"priority\": \"BACKGROUND_PREFETCH\","
-                         "  \"excludedSuggestionIds\": ["
-                         "    \"1234567890\""
-                         "  ],"
-                         "  \"userActivenessClass\": \"ACTIVE_NTP_USER\""
-                         "}"));
-}
-
-TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestUnauthenticated) {
-  NTPSnippetsFetcher::RequestBuilder builder;
-  NTPSnippetsFetcher::Params params = test_params();
-  params.count_to_fetch = 10;
-  builder.SetParams(params)
-      .SetUserClassForTesting("ACTIVE_NTP_USER")
-      .SetPersonalization(NTPSnippetsFetcher::Personalization::kNonPersonal)
-      .SetFetchAPI(NTPSnippetsFetcher::CHROME_READER_API);
-
-  EXPECT_THAT(builder.PreviewRequestHeadersForTesting(),
-              StrEq("Content-Type: application/json; charset=UTF-8\r\n"
-                    "\r\n"));
-  EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
-              EqualsJSON("{"
-                         "  \"response_detail_level\": \"STANDARD\","
-                         "  \"advanced_options\": {"
-                         "    \"local_scoring_params\": {"
-                         "      \"content_params\": {"
-                         "        \"only_return_personalized_results\": false"
-                         "      },"
-                         "      \"content_restricts\": ["
-                         "        {"
-                         "          \"type\": \"METADATA\","
-                         "          \"value\": \"TITLE\""
-                         "        },"
-                         "        {"
-                         "          \"type\": \"METADATA\","
-                         "          \"value\": \"SNIPPET\""
-                         "        },"
-                         "        {"
-                         "          \"type\": \"METADATA\","
-                         "          \"value\": \"THUMBNAIL\""
-                         "        }"
-                         "      ]"
-                         "    },"
-                         "    \"global_scoring_params\": {"
-                         "      \"num_to_return\": 10,"
-                         "      \"sort_type\": 1"
-                         "    }"
-                         "  }"
-                         "}"));
-
-  builder.SetFetchAPI(
-      NTPSnippetsFetcher::FetchAPI::CHROME_CONTENT_SUGGESTIONS_API);
-  EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
-              EqualsJSON("{"
-                         "  \"priority\": \"USER_ACTION\","
-                         "  \"excludedSuggestionIds\": [],"
-                         "  \"userActivenessClass\": \"ACTIVE_NTP_USER\""
-                         "}"));
-}
-
-TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestExcludedIds) {
-  NTPSnippetsFetcher::RequestBuilder builder;
-  NTPSnippetsFetcher::Params params = test_params();
-  params.interactive_request = false;
-  for (int i = 0; i < 200; ++i) {
-    params.excluded_ids.insert(base::StringPrintf("%03d", i));
-  }
-  builder.SetParams(params)
-      .SetUserClassForTesting("ACTIVE_NTP_USER")
-      .SetPersonalization(NTPSnippetsFetcher::Personalization::kNonPersonal)
-      .SetFetchAPI(
-          NTPSnippetsFetcher::FetchAPI::CHROME_CONTENT_SUGGESTIONS_API);
-
-  EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
-              EqualsJSON("{"
-                         "  \"priority\": \"BACKGROUND_PREFETCH\","
-                         "  \"excludedSuggestionIds\": ["
-                         "    \"000\", \"001\", \"002\", \"003\", \"004\","
-                         "    \"005\", \"006\", \"007\", \"008\", \"009\","
-                         "    \"010\", \"011\", \"012\", \"013\", \"014\","
-                         "    \"015\", \"016\", \"017\", \"018\", \"019\","
-                         "    \"020\", \"021\", \"022\", \"023\", \"024\","
-                         "    \"025\", \"026\", \"027\", \"028\", \"029\","
-                         "    \"030\", \"031\", \"032\", \"033\", \"034\","
-                         "    \"035\", \"036\", \"037\", \"038\", \"039\","
-                         "    \"040\", \"041\", \"042\", \"043\", \"044\","
-                         "    \"045\", \"046\", \"047\", \"048\", \"049\","
-                         "    \"050\", \"051\", \"052\", \"053\", \"054\","
-                         "    \"055\", \"056\", \"057\", \"058\", \"059\","
-                         "    \"060\", \"061\", \"062\", \"063\", \"064\","
-                         "    \"065\", \"066\", \"067\", \"068\", \"069\","
-                         "    \"070\", \"071\", \"072\", \"073\", \"074\","
-                         "    \"075\", \"076\", \"077\", \"078\", \"079\","
-                         "    \"080\", \"081\", \"082\", \"083\", \"084\","
-                         "    \"085\", \"086\", \"087\", \"088\", \"089\","
-                         "    \"090\", \"091\", \"092\", \"093\", \"094\","
-                         "    \"095\", \"096\", \"097\", \"098\", \"099\""
-                         // Truncated to 100 entries. Currently, they happen to
-                         // be those lexically first.
-                         "  ],"
-                         "  \"userActivenessClass\": \"ACTIVE_NTP_USER\""
-                         "}"));
-}
-
-TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestNoUserClass) {
-  NTPSnippetsFetcher::RequestBuilder builder;
-  NTPSnippetsFetcher::Params params = test_params();
-  params.interactive_request = false;
-  builder.SetPersonalization(NTPSnippetsFetcher::Personalization::kNonPersonal)
-      .SetParams(params)
-      .SetFetchAPI(
-          NTPSnippetsFetcher::FetchAPI::CHROME_CONTENT_SUGGESTIONS_API);
-
-  EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
-              EqualsJSON("{"
-                         "  \"priority\": \"BACKGROUND_PREFETCH\","
-                         "  \"excludedSuggestionIds\": []"
-                         "}"));
-}
-
-TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestWithTwoLanguages) {
-  NTPSnippetsFetcher::RequestBuilder builder;
-  std::unique_ptr<translate::LanguageModel> language_model =
-      MakeLanguageModel({"de", "en"});
-  NTPSnippetsFetcher::Params params = test_params();
-  params.language_code = "en";
-  builder.SetParams(params)
-      .SetLanguageModel(language_model.get())
-      .SetPersonalization(NTPSnippetsFetcher::Personalization::kNonPersonal)
-      .SetFetchAPI(
-          NTPSnippetsFetcher::FetchAPI::CHROME_CONTENT_SUGGESTIONS_API);
-
-  EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
-              EqualsJSON("{"
-                         "  \"priority\": \"USER_ACTION\","
-                         "  \"uiLanguage\": \"en\","
-                         "  \"excludedSuggestionIds\": [],"
-                         "  \"topLanguages\": ["
-                         "    {"
-                         "      \"language\" : \"en\","
-                         "      \"frequency\" : 0.5"
-                         "    },"
-                         "    {"
-                         "      \"language\" : \"de\","
-                         "      \"frequency\" : 0.5"
-                         "    }"
-                         "  ]"
-                         "}"));
-}
-
-TEST_F(ChromeReaderSnippetsFetcherTest, BuildRequestWithUILanguageOnly) {
-  NTPSnippetsFetcher::RequestBuilder builder;
-  std::unique_ptr<translate::LanguageModel> language_model =
-      MakeLanguageModel({"en"});
-  NTPSnippetsFetcher::Params params = test_params();
-  params.language_code = "en";
-  builder.SetParams(params)
-      .SetLanguageModel(language_model.get())
-      .SetPersonalization(NTPSnippetsFetcher::Personalization::kNonPersonal)
-      .SetFetchAPI(
-          NTPSnippetsFetcher::FetchAPI::CHROME_CONTENT_SUGGESTIONS_API);
-
-  EXPECT_THAT(builder.PreviewRequestBodyForTesting(),
-              EqualsJSON("{"
-                         "  \"priority\": \"USER_ACTION\","
-                         "  \"uiLanguage\": \"en\","
-                         "  \"excludedSuggestionIds\": [],"
-                         "  \"topLanguages\": [{"
-                         "    \"language\" : \"en\","
-                         "    \"frequency\" : 1.0"
-                         "  }]"
-                         "}"));
-}
-
 TEST_F(ChromeReaderSnippetsFetcherTest, ShouldNotFetchOnCreation) {
   // The lack of registered baked in responses would cause any fetch to fail.
   FastForwardUntilNoTasksRemain();
   EXPECT_THAT(histogram_tester().GetAllSamples(
                   "NewTabPage.Snippets.FetchHttpResponseOrErrorCode"),
               IsEmpty());
   EXPECT_THAT(histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchTime"),
               IsEmpty());
   EXPECT_THAT(snippets_fetcher().last_status(), IsEmpty());
 }
@@ skipping 247 matching lines @@
       "    \"ampUrl\" : \"http://localhost/amp\","
       "    \"faviconUrl\" : \"http://localhost/favicon.ico\" "
       "  }]"
       "}]}";
   SetFakeResponse(/*response_data=*/kJsonStr, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   NTPSnippetsFetcher::OptionalFetchedCategories fetched_categories;
   EXPECT_CALL(mock_callback(), Run(IsSuccess(), _))
       .WillOnce(MoveArgument1PointeeTo(&fetched_categories));
 
-  NTPSnippetsFetcher::Params params = test_params();
+  NTPSnippetsRequestParams params = test_params();
   params.exclusive_category =
       base::Optional<Category>(Category::FromRemoteCategory(2));
+
   snippets_fetcher().FetchSnippets(
       params, ToSnippetsAvailableCallback(&mock_callback()));
   FastForwardUntilNoTasksRemain();
 
   ASSERT_TRUE(fetched_categories);
   ASSERT_THAT(fetched_categories->size(), Eq(1u));
   const auto& category = (*fetched_categories)[0];
   EXPECT_THAT(category.category.id(), Eq(Category::FromRemoteCategory(2).id()));
   ASSERT_THAT(category.snippets.size(), Eq(1u));
   EXPECT_THAT(category.snippets[0]->url().spec(), Eq("http://localhost/foo2"));
 }
 
+// TODO(fhorschig): Check for behavioral changes instead of state.
 TEST_F(ChromeReaderSnippetsFetcherTest, PersonalizesDependingOnVariations) {
   // Default setting should be both personalization options.
-  EXPECT_THAT(snippets_fetcher().personalization(),
-              Eq(NTPSnippetsFetcher::Personalization::kBoth));
+  EXPECT_THAT(snippets_fetcher().personalization(), Eq(Personalization::kBoth));
 
   SetVariationParam("fetching_personalization", "personal");
   ResetSnippetsFetcher();
   EXPECT_THAT(snippets_fetcher().personalization(),
-              Eq(NTPSnippetsFetcher::Personalization::kPersonal));
+              Eq(Personalization::kPersonal));
 
   SetVariationParam("fetching_personalization", "non_personal");
   ResetSnippetsFetcher();
   EXPECT_THAT(snippets_fetcher().personalization(),
-              Eq(NTPSnippetsFetcher::Personalization::kNonPersonal));
+              Eq(Personalization::kNonPersonal));
 
   SetVariationParam("fetching_personalization", "both");
   ResetSnippetsFetcher();
-  EXPECT_THAT(snippets_fetcher().personalization(),
-              Eq(NTPSnippetsFetcher::Personalization::kBoth));
+  EXPECT_THAT(snippets_fetcher().personalization(), Eq(Personalization::kBoth));
 }
 
 TEST_F(ChromeReaderSnippetsFetcherTest, ShouldFetchSuccessfullyEmptyList) {
   const std::string kJsonStr = "{\"recos\": []}";
   SetFakeResponse(/*response_data=*/kJsonStr, net::HTTP_OK,
                   net::URLRequestStatus::SUCCESS);
   EXPECT_CALL(mock_callback(), Run(IsSuccess(), IsEmptyArticleList()));
   snippets_fetcher().FetchSnippets(
       test_params(), ToSnippetsAvailableCallback(&mock_callback()));
   FastForwardUntilNoTasksRemain();
   EXPECT_THAT(snippets_fetcher().last_status(), Eq("OK"));
   EXPECT_THAT(snippets_fetcher().last_json(), Eq(kJsonStr));
   EXPECT_THAT(
       histogram_tester().GetAllSamples("NewTabPage.Snippets.FetchResult"),
       ElementsAre(base::Bucket(/*min=*/0, /*count=*/1)));
   EXPECT_THAT(histogram_tester().GetAllSamples(
                   "NewTabPage.Snippets.FetchHttpResponseOrErrorCode"),
               ElementsAre(base::Bucket(/*min=*/200, /*count=*/1)));
 }
 
 TEST_F(ChromeReaderSnippetsFetcherTest, RetryOnInteractiveRequests) {
   DelegateCallingTestURLFetcherFactory fetcher_factory;
-  NTPSnippetsFetcher::Params params = test_params();
+  NTPSnippetsRequestParams params = test_params();
   params.interactive_request = true;
 
   snippets_fetcher().FetchSnippets(
       params, ToSnippetsAvailableCallback(&mock_callback()));
 
   net::TestURLFetcher* fetcher = fetcher_factory.GetLastCreatedFetcher();
   ASSERT_THAT(fetcher, NotNull());
   EXPECT_THAT(fetcher->GetMaxRetriesOn5xx(), Eq(2));
 }
 
 TEST_F(ChromeReaderSnippetsFetcherTest,
        RetriesConfigurableOnNonInteractiveRequests) {
   struct ExpectationForVariationParam {
     std::string param_value;
     int expected_value;
     std::string description;
   };
   const std::vector<ExpectationForVariationParam> retry_config_expectation = {
       {"", 0, "Do not retry by default"},
       {"0", 0, "Do not retry on param value 0"},
       {"-1", 0, "Do not retry on negative param values."},
       {"4", 4, "Retry as set in param value."}};
 
-  NTPSnippetsFetcher::Params params = test_params();
+  NTPSnippetsRequestParams params = test_params();
   params.interactive_request = false;
 
   for (const auto& retry_config : retry_config_expectation) {
     DelegateCallingTestURLFetcherFactory fetcher_factory;
     SetVariationParametersForFeatures(
         {{"background_5xx_retries_count", retry_config.param_value}},
         {ntp_snippets::kArticleSuggestionsFeature.name});
 
     snippets_fetcher().FetchSnippets(
         params, ToSnippetsAvailableCallback(&mock_callback()));
@@ skipping 158 matching lines @@
     const NTPSnippetsFetcher::OptionalFetchedCategories& fetched_categories) {
   if (fetched_categories) {
     // Matchers above aren't any more precise than this, so this is sufficient
     // for test-failure diagnostics.
     return os << "list with " << fetched_categories->size() << " elements";
   }
   return os << "null";
 }
 
 }  // namespace ntp_snippets