Re-write many calls to WrapUnique() with MakeUnique()

components/variations/service/variations_service_unittest.cc

 // Copyright (c) 2012 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/variations/service/variations_service.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 260 matching lines @@
 TEST_F(VariationsServiceTest, CreateTrialsFromSeed) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Create a local base::FieldTrialList, to hold the field trials created in
   // this test.
   base::FieldTrialList field_trial_list(nullptr);
 
   // Create a variations service.
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.SetCreateTrialsFromSeedCalledForTesting(false);
 
   // Store a seed.
   service.StoreSeed(SerializeSeed(CreateTestSeed()), std::string(),
                     std::string(), base::Time::Now(), false, false);
   prefs.SetInt64(prefs::kVariationsLastFetchTime,
                  base::Time::Now().ToInternalValue());
 
   // Check that field trials are created from the seed. Since the test study has
   // only 1 experiment with 100% probability weight, we must be part of it.
   EXPECT_TRUE(service.CreateTrialsFromSeed(base::FeatureList::GetInstance()));
   EXPECT_EQ(kTestSeedExperimentName,
             base::FieldTrialList::FindFullName(kTestSeedStudyName));
 }
 
 TEST_F(VariationsServiceTest, CreateTrialsFromSeedNoLastFetchTime) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Create a local base::FieldTrialList, to hold the field trials created in
   // this test.
   base::FieldTrialList field_trial_list(nullptr);
 
   // Create a variations service
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.SetCreateTrialsFromSeedCalledForTesting(false);
 
   // Store a seed. To simulate a first run, |prefs::kVariationsLastFetchTime|
   // is left empty.
   service.StoreSeed(SerializeSeed(CreateTestSeed()), std::string(),
                     std::string(), base::Time::Now(), false, false);
   EXPECT_EQ(0, prefs.GetInt64(prefs::kVariationsLastFetchTime));
 
   // Check that field trials are created from the seed. Since the test study has
   // only 1 experiment with 100% probability weight, we must be part of it.
   EXPECT_TRUE(service.CreateTrialsFromSeed(base::FeatureList::GetInstance()));
   EXPECT_EQ(base::FieldTrialList::FindFullName(kTestSeedStudyName),
             kTestSeedExperimentName);
 }
 
 TEST_F(VariationsServiceTest, CreateTrialsFromOutdatedSeed) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Create a local base::FieldTrialList, to hold the field trials created in
   // this test.
   base::FieldTrialList field_trial_list(nullptr);
 
   // Create a variations service.
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.SetCreateTrialsFromSeedCalledForTesting(false);
 
   // Store a seed, with a fetch time 31 days in the past.
   const base::Time seed_date =
       base::Time::Now() - base::TimeDelta::FromDays(31);
   service.StoreSeed(SerializeSeed(CreateTestSeed()), std::string(),
                     std::string(), seed_date, false, false);
   prefs.SetInt64(prefs::kVariationsLastFetchTime, seed_date.ToInternalValue());
 
   // Check that field trials are not created from the seed.
   EXPECT_FALSE(service.CreateTrialsFromSeed(base::FeatureList::GetInstance()));
   EXPECT_TRUE(base::FieldTrialList::FindFullName(kTestSeedStudyName).empty());
 }
 
 TEST_F(VariationsServiceTest, GetVariationsServerURL) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   const std::string default_variations_url =
       VariationsService::GetDefaultVariationsServerURLForTesting();
 
   std::string value;
   std::unique_ptr<TestVariationsServiceClient> client =
-      base::WrapUnique(new TestVariationsServiceClient());
+      base::MakeUnique<TestVariationsServiceClient>();
   TestVariationsServiceClient* raw_client = client.get();
   VariationsService service(
       std::move(client),
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs, NULL, UIStringOverrider());
   GURL url = service.GetVariationsServerURL(&prefs, std::string());
   EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
                                base::CompareCase::SENSITIVE));
   EXPECT_FALSE(net::GetValueForKeyInQuery(url, "restrict", &value));
 
   prefs.SetString(prefs::kVariationsRestrictParameter, "restricted");
   url = service.GetVariationsServerURL(&prefs, std::string());
   EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
                                base::CompareCase::SENSITIVE));
@@ skipping 14 matching lines @@
   EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
                                base::CompareCase::SENSITIVE));
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value));
   EXPECT_EQ("override", value);
 }
 
 TEST_F(VariationsServiceTest, VariationsURLHasOSNameParam) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   const GURL url = service.GetVariationsServerURL(&prefs, std::string());
 
   std::string value;
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "osname", &value));
   EXPECT_FALSE(value.empty());
 }
 
 TEST_F(VariationsServiceTest, RequestsInitiallyNotAllowed) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Pass ownership to TestVariationsService, but keep a weak pointer to
   // manipulate it for this test.
   std::unique_ptr<web_resource::TestRequestAllowedNotifier> test_notifier =
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs));
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs);
   web_resource::TestRequestAllowedNotifier* raw_notifier = test_notifier.get();
   TestVariationsService test_service(std::move(test_notifier), &prefs);
 
   // Force the notifier to initially disallow requests.
   raw_notifier->SetRequestsAllowedOverride(false);
   test_service.StartRepeatedVariationsSeedFetch();
   EXPECT_FALSE(test_service.fetch_attempted());
 
   raw_notifier->NotifyObserver();
   EXPECT_TRUE(test_service.fetch_attempted());
 }
 
 TEST_F(VariationsServiceTest, RequestsInitiallyAllowed) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Pass ownership to TestVariationsService, but keep a weak pointer to
   // manipulate it for this test.
   std::unique_ptr<web_resource::TestRequestAllowedNotifier> test_notifier =
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs));
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs);
   web_resource::TestRequestAllowedNotifier* raw_notifier = test_notifier.get();
   TestVariationsService test_service(std::move(test_notifier), &prefs);
 
   raw_notifier->SetRequestsAllowedOverride(true);
   test_service.StartRepeatedVariationsSeedFetch();
   EXPECT_TRUE(test_service.fetch_attempted());
 }
 
 TEST_F(VariationsServiceTest, SeedStoredWhenOKStatus) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.set_intercepts_fetch(false);
 
   net::TestURLFetcherFactory factory;
   service.DoActualFetch();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   SimulateServerResponse(net::HTTP_OK, fetcher);
   fetcher->SetResponseString(SerializeSeed(CreateTestSeed()));
 
   EXPECT_FALSE(service.seed_stored());
   service.OnURLFetchComplete(fetcher);
   EXPECT_TRUE(service.seed_stored());
 }
 
 TEST_F(VariationsServiceTest, SeedNotStoredWhenNonOKStatus) {
   const int non_ok_status_codes[] = {
     net::HTTP_NO_CONTENT,
     net::HTTP_NOT_MODIFIED,
     net::HTTP_NOT_FOUND,
     net::HTTP_INTERNAL_SERVER_ERROR,
     net::HTTP_SERVICE_UNAVAILABLE,
   };
 
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.set_intercepts_fetch(false);
   for (size_t i = 0; i < arraysize(non_ok_status_codes); ++i) {
     net::TestURLFetcherFactory factory;
     service.DoActualFetch();
     EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
 
     net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
     SimulateServerResponse(non_ok_status_codes[i], fetcher);
     service.OnURLFetchComplete(fetcher);
 
     EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
   }
 }
 
 TEST_F(VariationsServiceTest, RequestGzipCompressedSeed) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   net::TestURLFetcherFactory factory;
 
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.set_intercepts_fetch(false);
   service.DoActualFetch();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   net::HttpRequestHeaders headers;
   fetcher->GetExtraRequestHeaders(&headers);
   std::string field;
   ASSERT_TRUE(headers.GetHeader("A-IM", &field));
   EXPECT_EQ("gzip", field);
@@ skipping 15 matching lines @@
     {"IM:deflate,x-bm,gzip", false, false, false},
   };
 
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   std::string serialized_seed = SerializeSeed(CreateTestSeed());
   net::TestURLFetcherFactory factory;
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     TestVariationsService service(
-        base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
         &prefs);
     service.set_intercepts_fetch(false);
     service.DoActualFetch();
     net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
 
     if (cases[i].im.empty())
       SimulateServerResponse(net::HTTP_OK, fetcher);
     else
       SimulateServerResponseWithHeader(net::HTTP_OK, fetcher, &cases[i].im);
     fetcher->SetResponseString(serialized_seed);
     service.OnURLFetchComplete(fetcher);
 
     EXPECT_EQ(cases[i].seed_stored, service.seed_stored());
     EXPECT_EQ(cases[i].delta_compressed, service.delta_compressed_seed());
     EXPECT_EQ(cases[i].gzip_compressed, service.gzip_compressed_seed());
   }
 }
 
 TEST_F(VariationsServiceTest, CountryHeader) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.set_intercepts_fetch(false);
 
   net::TestURLFetcherFactory factory;
   service.DoActualFetch();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   scoped_refptr<net::HttpResponseHeaders> headers =
       SimulateServerResponse(net::HTTP_OK, fetcher);
   headers->AddHeader("X-Country: test");
   fetcher->SetResponseString(SerializeSeed(CreateTestSeed()));
 
   EXPECT_FALSE(service.seed_stored());
   service.OnURLFetchComplete(fetcher);
   EXPECT_TRUE(service.seed_stored());
   EXPECT_EQ("test", service.stored_country());
 }
 
 TEST_F(VariationsServiceTest, Observer) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   VariationsService service(
-      base::WrapUnique(new TestVariationsServiceClient()),
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<TestVariationsServiceClient>(),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs, NULL, UIStringOverrider());
 
   struct {
     int normal_count;
     int best_effort_count;
     int critical_count;
     int expected_best_effort_notifications;
     int expected_crtical_notifications;
   } cases[] = {
       {0, 0, 0, 0, 0},
@@ skipping 78 matching lines @@
       {"badversion,ca", "20.0.0.0", "us", "20.0.0.0,us", "us",
        VariationsService::LOAD_COUNTRY_INVALID_PREF_HAS_SEED},
       {"badversion,ca", "20.0.0.0", nullptr, "", "",
        VariationsService::LOAD_COUNTRY_INVALID_PREF_NO_SEED},
   };
 
   for (const auto& test : test_cases) {
     TestingPrefServiceSimple prefs;
     VariationsService::RegisterPrefs(prefs.registry());
     VariationsService service(
-        base::WrapUnique(new TestVariationsServiceClient()),
-        base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        base::MakeUnique<TestVariationsServiceClient>(),
+        base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
         &prefs, NULL, UIStringOverrider());
 
     if (test.pref_value_before) {
       base::ListValue list_value;
       for (const std::string& component :
            base::SplitString(test.pref_value_before, ",", base::TRIM_WHITESPACE,
                              base::SPLIT_WANT_ALL)) {
         list_value.AppendString(component);
       }
       prefs.Set(prefs::kVariationsPermanentConsistencyCountry, list_value);
@@ skipping 50 matching lines @@
       {"", "ca", kPrefCa, true},
       {"", "", "", false},
       {"19.0.0.0,us", "ca", kPrefCa, true},
       {"19.0.0.0,us", "us", "19.0.0.0,us", false},
   };
 
   for (const auto& test : test_cases) {
     TestingPrefServiceSimple prefs;
     VariationsService::RegisterPrefs(prefs.registry());
     TestVariationsService service(
-        base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
         &prefs);
 
     if (!test.pref_value_before.empty()) {
       base::ListValue list_value;
       for (const std::string& component :
            base::SplitString(test.pref_value_before, ",", base::TRIM_WHITESPACE,
                              base::SPLIT_WANT_ALL)) {
         list_value.AppendString(component);
       }
       prefs.Set(prefs::kVariationsPermanentConsistencyCountry, list_value);
@@ skipping 13 matching lines @@
     }
     const base::ListValue* pref_value =
         prefs.GetList(prefs::kVariationsPermanentConsistencyCountry);
     EXPECT_EQ(ListValueToString(expected_list_value),
               ListValueToString(*pref_value))
         << test.pref_value_before << ", " << test.country_code_override;
   }
 }
 
 }  // namespace variations