Convert //base to use std::unique_ptr

base/feature_list_unittest.cc

 // Copyright 2015 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 "base/feature_list.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/format_macros.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
 const char kFeatureOnByDefaultName[] = "OnByDefault";
@@ skipping 11 matching lines @@
       FeatureList::SplitFeatureListString(feature_list);
   std::sort(features.begin(), features.end());
   return JoinString(features, ",");
 }
 
 }  // namespace
 
 class FeatureListTest : public testing::Test {
  public:
   FeatureListTest() : feature_list_(nullptr) {
-    RegisterFeatureListInstance(make_scoped_ptr(new FeatureList));
+    RegisterFeatureListInstance(WrapUnique(new FeatureList));
   }
   ~FeatureListTest() override { ClearFeatureListInstance(); }
 
-  void RegisterFeatureListInstance(scoped_ptr<FeatureList> feature_list) {
+  void RegisterFeatureListInstance(std::unique_ptr<FeatureList> feature_list) {
     FeatureList::ClearInstanceForTesting();
     feature_list_ = feature_list.get();
     FeatureList::SetInstance(std::move(feature_list));
   }
   void ClearFeatureListInstance() {
     FeatureList::ClearInstanceForTesting();
     feature_list_ = nullptr;
   }
 
   FeatureList* feature_list() { return feature_list_; }
@@ skipping 26 matching lines @@
       {"OnByDefault", "OnByDefault,OffByDefault", false, false},
   };
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     const auto& test_case = test_cases[i];
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: [%s] [%s]", i,
                                     test_case.enable_features,
                                     test_case.disable_features));
 
     ClearFeatureListInstance();
-    scoped_ptr<FeatureList> feature_list(new FeatureList);
+    std::unique_ptr<FeatureList> feature_list(new FeatureList);
     feature_list->InitializeFromCommandLine(test_case.enable_features,
                                             test_case.disable_features);
     RegisterFeatureListInstance(std::move(feature_list));
 
     EXPECT_EQ(test_case.expected_feature_on_state,
               FeatureList::IsEnabled(kFeatureOnByDefault))
         << i;
     EXPECT_EQ(test_case.expected_feature_off_state,
               FeatureList::IsEnabled(kFeatureOffByDefault))
         << i;
@@ skipping 35 matching lines @@
   };
 
   FieldTrial::ActiveGroup active_group;
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     const auto& test_case = test_cases[i];
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]", i));
 
     ClearFeatureListInstance();
 
     FieldTrialList field_trial_list(nullptr);
-    scoped_ptr<FeatureList> feature_list(new FeatureList);
+    std::unique_ptr<FeatureList> feature_list(new FeatureList);
 
     FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("TrialExample1", "A");
     FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("TrialExample2", "B");
     feature_list->RegisterFieldTrialOverride(kFeatureOnByDefaultName,
                                              test_case.trial1_state, trial1);
     feature_list->RegisterFieldTrialOverride(kFeatureOffByDefaultName,
                                              test_case.trial2_state, trial2);
     RegisterFeatureListInstance(std::move(feature_list));
 
     // Initially, neither trial should be active.
@@ skipping 11 matching lines @@
         (test_case.trial2_state == FeatureList::OVERRIDE_ENABLE_FEATURE);
     EXPECT_EQ(expected_enabled_2, FeatureList::IsEnabled(kFeatureOffByDefault));
     // The above should have activated |trial2|.
     EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name()));
     EXPECT_TRUE(FieldTrialList::IsTrialActive(trial2->trial_name()));
   }
 }
 
 TEST_F(FeatureListTest, FieldTrialAssociateUseDefault) {
   FieldTrialList field_trial_list(nullptr);
-  scoped_ptr<FeatureList> feature_list(new FeatureList);
+  std::unique_ptr<FeatureList> feature_list(new FeatureList);
 
   FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("TrialExample1", "A");
   FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("TrialExample2", "B");
   feature_list->RegisterFieldTrialOverride(
       kFeatureOnByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial1);
   feature_list->RegisterFieldTrialOverride(
       kFeatureOffByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial2);
   RegisterFeatureListInstance(std::move(feature_list));
 
   // Initially, neither trial should be active.
@@ skipping 10 matching lines @@
   EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
   // The above should have activated |trial2|.
   EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name()));
   EXPECT_TRUE(FieldTrialList::IsTrialActive(trial2->trial_name()));
 }
 
 TEST_F(FeatureListTest, CommandLineTakesPrecedenceOverFieldTrial) {
   ClearFeatureListInstance();
 
   FieldTrialList field_trial_list(nullptr);
-  scoped_ptr<FeatureList> feature_list(new FeatureList);
+  std::unique_ptr<FeatureList> feature_list(new FeatureList);
 
   // The feature is explicitly enabled on the command-line.
   feature_list->InitializeFromCommandLine(kFeatureOffByDefaultName, "");
 
   // But the FieldTrial would set the feature to disabled.
   FieldTrial* trial = FieldTrialList::CreateFieldTrial("TrialExample2", "A");
   feature_list->RegisterFieldTrialOverride(
       kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE, trial);
   RegisterFeatureListInstance(std::move(feature_list));
 
   EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name()));
   // Command-line should take precedence.
   EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault));
   // Since the feature is on due to the command-line, and not as a result of the
   // field trial, the field trial should not be activated (since the Associate*
   // API wasn't used.)
   EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name()));
 }
 
 TEST_F(FeatureListTest, IsFeatureOverriddenFromCommandLine) {
   ClearFeatureListInstance();
 
   FieldTrialList field_trial_list(nullptr);
-  scoped_ptr<FeatureList> feature_list(new FeatureList);
+  std::unique_ptr<FeatureList> feature_list(new FeatureList);
 
   // No features are overridden from the command line yet
   EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
       kFeatureOnByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE));
   EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
       kFeatureOnByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE));
   EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
       kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE));
   EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine(
       kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE));
@@ skipping 54 matching lines @@
 
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     const auto& test_case = test_cases[i];
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: [%s] [%s]", i,
                                     test_case.enable_features,
                                     test_case.disable_features));
 
     ClearFeatureListInstance();
 
     FieldTrialList field_trial_list(nullptr);
-    scoped_ptr<FeatureList> feature_list(new FeatureList);
+    std::unique_ptr<FeatureList> feature_list(new FeatureList);
     feature_list->InitializeFromCommandLine(test_case.enable_features,
                                             test_case.disable_features);
 
     FieldTrial* enable_trial = nullptr;
     if (feature_list->IsFeatureOverriddenFromCommandLine(
             kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE)) {
       enable_trial = base::FieldTrialList::CreateFieldTrial(kTrialName,
                                                             kForcedOnGroupName);
       feature_list->AssociateReportingFieldTrial(
           kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE,
@@ skipping 22 matching lines @@
       EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault));
       EXPECT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
       EXPECT_EQ(kForcedOnGroupName, enable_trial->group_name());
     }
   }
 }
 
 TEST_F(FeatureListTest, GetFeatureOverrides) {
   ClearFeatureListInstance();
   FieldTrialList field_trial_list(nullptr);
-  scoped_ptr<FeatureList> feature_list(new FeatureList);
+  std::unique_ptr<FeatureList> feature_list(new FeatureList);
   feature_list->InitializeFromCommandLine("A,X", "D");
 
   FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial", "Group");
   feature_list->RegisterFieldTrialOverride(kFeatureOffByDefaultName,
                                            FeatureList::OVERRIDE_ENABLE_FEATURE,
                                            trial);
 
   RegisterFeatureListInstance(std::move(feature_list));
 
   std::string enable_features;
   std::string disable_features;
   FeatureList::GetInstance()->GetFeatureOverrides(&enable_features,
                                                   &disable_features);
   EXPECT_EQ("A,OffByDefault<Trial,X", SortFeatureListString(enable_features));
   EXPECT_EQ("D", SortFeatureListString(disable_features));
 }
 
 TEST_F(FeatureListTest, GetFeatureOverrides_UseDefault) {
   ClearFeatureListInstance();
   FieldTrialList field_trial_list(nullptr);
-  scoped_ptr<FeatureList> feature_list(new FeatureList);
+  std::unique_ptr<FeatureList> feature_list(new FeatureList);
   feature_list->InitializeFromCommandLine("A,X", "D");
 
   FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial", "Group");
   feature_list->RegisterFieldTrialOverride(
       kFeatureOffByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial);
 
   RegisterFeatureListInstance(std::move(feature_list));
 
   std::string enable_features;
   std::string disable_features;
   FeatureList::GetInstance()->GetFeatureOverrides(&enable_features,
                                                   &disable_features);
   EXPECT_EQ("*OffByDefault<Trial,A,X", SortFeatureListString(enable_features));
   EXPECT_EQ("D", SortFeatureListString(disable_features));
 }
 
 TEST_F(FeatureListTest, InitializeFromCommandLine_WithFieldTrials) {
   ClearFeatureListInstance();
   FieldTrialList field_trial_list(nullptr);
   FieldTrialList::CreateFieldTrial("Trial", "Group");
-  scoped_ptr<FeatureList> feature_list(new FeatureList);
+  std::unique_ptr<FeatureList> feature_list(new FeatureList);
   feature_list->InitializeFromCommandLine("A,OffByDefault<Trial,X", "D");
   RegisterFeatureListInstance(std::move(feature_list));
 
   EXPECT_FALSE(FieldTrialList::IsTrialActive("Trial"));
   EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault));
   EXPECT_TRUE(FieldTrialList::IsTrialActive("Trial"));
 }
 
 TEST_F(FeatureListTest, InitializeFromCommandLine_UseDefault) {
   ClearFeatureListInstance();
   FieldTrialList field_trial_list(nullptr);
   FieldTrialList::CreateFieldTrial("T1", "Group");
   FieldTrialList::CreateFieldTrial("T2", "Group");
-  scoped_ptr<FeatureList> feature_list(new FeatureList);
+  std::unique_ptr<FeatureList> feature_list(new FeatureList);
   feature_list->InitializeFromCommandLine(
       "A,*OffByDefault<T1,*OnByDefault<T2,X", "D");
   RegisterFeatureListInstance(std::move(feature_list));
 
   EXPECT_FALSE(FieldTrialList::IsTrialActive("T1"));
   EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
   EXPECT_TRUE(FieldTrialList::IsTrialActive("T1"));
 
   EXPECT_FALSE(FieldTrialList::IsTrialActive("T2"));
   EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault));
   EXPECT_TRUE(FieldTrialList::IsTrialActive("T2"));
 }
 
 TEST_F(FeatureListTest, InitializeInstance) {
   ClearFeatureListInstance();
 
-  scoped_ptr<base::FeatureList> feature_list(new base::FeatureList);
+  std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
   FeatureList::SetInstance(std::move(feature_list));
   EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault));
   EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
 
   // Initialize from command line if we haven't yet.
   FeatureList::InitializeInstance("", kFeatureOnByDefaultName);
   EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault));
   EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
 
   // Do not initialize from commandline if we have already.
   FeatureList::InitializeInstance(kFeatureOffByDefaultName, "");
   EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault));
   EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault));
 }
 
 }  // namespace base