Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

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>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/feature_list.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/test/histogram_tester.h"
 #include "base/version.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/variations/pref_names.h"
 #include "components/variations/proto/study.pb.h"
@@ skipping 45 matching lines @@
  private:
   std::string restrict_parameter_;
 
   DISALLOW_COPY_AND_ASSIGN(TestVariationsServiceClient);
 };
 
 // A test class used to validate expected functionality in VariationsService.
 class TestVariationsService : public VariationsService {
  public:
   TestVariationsService(
-      scoped_ptr<web_resource::TestRequestAllowedNotifier> test_notifier,
+      std::unique_ptr<web_resource::TestRequestAllowedNotifier> test_notifier,
       PrefService* local_state)
-      : VariationsService(make_scoped_ptr(new TestVariationsServiceClient()),
+      : VariationsService(base::WrapUnique(new TestVariationsServiceClient()),
                           std::move(test_notifier),
                           local_state,
                           NULL,
                           UIStringOverrider()),
         intercepts_fetch_(true),
         fetch_attempted_(false),
         seed_stored_(false),
         delta_compressed_seed_(false),
         gzip_compressed_seed_(false) {
     // Set this so StartRepeatedVariationsSeedFetch can be called in tests.
@@ skipping 166 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(VariationsServiceTest);
 };
 
 TEST_F(VariationsServiceTest, CreateTrialsFromSeed) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Setup base::FeatureList.
   base::FeatureList::ClearInstanceForTesting();
-  base::FeatureList::SetInstance(make_scoped_ptr(new base::FeatureList()));
+  base::FeatureList::SetInstance(base::WrapUnique(new base::FeatureList()));
 
   // 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(
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::WrapUnique(new 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(base::FieldTrialList::FindFullName(kTestSeedStudyName),
             kTestSeedExperimentName);
 }
 
 TEST_F(VariationsServiceTest, CreateTrialsFromSeedNoLastFetchTime) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Setup base::FeatureList.
   base::FeatureList::ClearInstanceForTesting();
-  base::FeatureList::SetInstance(make_scoped_ptr(new base::FeatureList()));
+  base::FeatureList::SetInstance(base::WrapUnique(new base::FeatureList()));
 
   // 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(
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::WrapUnique(new 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());
 
   // Setup base::FeatureList.
   base::FeatureList::ClearInstanceForTesting();
-  base::FeatureList::SetInstance(make_scoped_ptr(new base::FeatureList()));
+  base::FeatureList::SetInstance(base::WrapUnique(new base::FeatureList()));
 
   // 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(
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::WrapUnique(new 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;
-  scoped_ptr<TestVariationsServiceClient> client =
-      make_scoped_ptr(new TestVariationsServiceClient());
+  std::unique_ptr<TestVariationsServiceClient> client =
+      base::WrapUnique(new TestVariationsServiceClient());
   TestVariationsServiceClient* raw_client = client.get();
   VariationsService service(
       std::move(client),
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::WrapUnique(new 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(
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::WrapUnique(new 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.
-  scoped_ptr<web_resource::TestRequestAllowedNotifier> test_notifier =
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs));
+  std::unique_ptr<web_resource::TestRequestAllowedNotifier> test_notifier =
+      base::WrapUnique(new 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.
-  scoped_ptr<web_resource::TestRequestAllowedNotifier> test_notifier =
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs));
+  std::unique_ptr<web_resource::TestRequestAllowedNotifier> test_notifier =
+      base::WrapUnique(new 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(
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::WrapUnique(new 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(
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::WrapUnique(new 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(
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::WrapUnique(new 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(
-        make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        base::WrapUnique(new 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(
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::WrapUnique(new 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(
-      make_scoped_ptr(new TestVariationsServiceClient()),
-      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::WrapUnique(new TestVariationsServiceClient()),
+      base::WrapUnique(new 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(
-        make_scoped_ptr(new TestVariationsServiceClient()),
-        make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        base::WrapUnique(new TestVariationsServiceClient()),
+        base::WrapUnique(new 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(
-        make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        base::WrapUnique(new 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