OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/feature_list.h" | 5 #include "base/feature_list.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <algorithm> | 9 #include <algorithm> |
10 #include <utility> | 10 #include <utility> |
11 | 11 |
12 #include "base/format_macros.h" | 12 #include "base/format_macros.h" |
13 #include "base/macros.h" | 13 #include "base/macros.h" |
| 14 #include "base/memory/ptr_util.h" |
14 #include "base/metrics/field_trial.h" | 15 #include "base/metrics/field_trial.h" |
15 #include "base/strings/string_util.h" | 16 #include "base/strings/string_util.h" |
16 #include "base/strings/stringprintf.h" | 17 #include "base/strings/stringprintf.h" |
17 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
18 | 19 |
19 namespace base { | 20 namespace base { |
20 | 21 |
21 namespace { | 22 namespace { |
22 | 23 |
23 const char kFeatureOnByDefaultName[] = "OnByDefault"; | 24 const char kFeatureOnByDefaultName[] = "OnByDefault"; |
(...skipping 11 matching lines...) Expand all Loading... |
35 FeatureList::SplitFeatureListString(feature_list); | 36 FeatureList::SplitFeatureListString(feature_list); |
36 std::sort(features.begin(), features.end()); | 37 std::sort(features.begin(), features.end()); |
37 return JoinString(features, ","); | 38 return JoinString(features, ","); |
38 } | 39 } |
39 | 40 |
40 } // namespace | 41 } // namespace |
41 | 42 |
42 class FeatureListTest : public testing::Test { | 43 class FeatureListTest : public testing::Test { |
43 public: | 44 public: |
44 FeatureListTest() : feature_list_(nullptr) { | 45 FeatureListTest() : feature_list_(nullptr) { |
45 RegisterFeatureListInstance(make_scoped_ptr(new FeatureList)); | 46 RegisterFeatureListInstance(WrapUnique(new FeatureList)); |
46 } | 47 } |
47 ~FeatureListTest() override { ClearFeatureListInstance(); } | 48 ~FeatureListTest() override { ClearFeatureListInstance(); } |
48 | 49 |
49 void RegisterFeatureListInstance(scoped_ptr<FeatureList> feature_list) { | 50 void RegisterFeatureListInstance(std::unique_ptr<FeatureList> feature_list) { |
50 FeatureList::ClearInstanceForTesting(); | 51 FeatureList::ClearInstanceForTesting(); |
51 feature_list_ = feature_list.get(); | 52 feature_list_ = feature_list.get(); |
52 FeatureList::SetInstance(std::move(feature_list)); | 53 FeatureList::SetInstance(std::move(feature_list)); |
53 } | 54 } |
54 void ClearFeatureListInstance() { | 55 void ClearFeatureListInstance() { |
55 FeatureList::ClearInstanceForTesting(); | 56 FeatureList::ClearInstanceForTesting(); |
56 feature_list_ = nullptr; | 57 feature_list_ = nullptr; |
57 } | 58 } |
58 | 59 |
59 FeatureList* feature_list() { return feature_list_; } | 60 FeatureList* feature_list() { return feature_list_; } |
(...skipping 26 matching lines...) Expand all Loading... |
86 {"OnByDefault", "OnByDefault,OffByDefault", false, false}, | 87 {"OnByDefault", "OnByDefault,OffByDefault", false, false}, |
87 }; | 88 }; |
88 | 89 |
89 for (size_t i = 0; i < arraysize(test_cases); ++i) { | 90 for (size_t i = 0; i < arraysize(test_cases); ++i) { |
90 const auto& test_case = test_cases[i]; | 91 const auto& test_case = test_cases[i]; |
91 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: [%s] [%s]", i, | 92 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: [%s] [%s]", i, |
92 test_case.enable_features, | 93 test_case.enable_features, |
93 test_case.disable_features)); | 94 test_case.disable_features)); |
94 | 95 |
95 ClearFeatureListInstance(); | 96 ClearFeatureListInstance(); |
96 scoped_ptr<FeatureList> feature_list(new FeatureList); | 97 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
97 feature_list->InitializeFromCommandLine(test_case.enable_features, | 98 feature_list->InitializeFromCommandLine(test_case.enable_features, |
98 test_case.disable_features); | 99 test_case.disable_features); |
99 RegisterFeatureListInstance(std::move(feature_list)); | 100 RegisterFeatureListInstance(std::move(feature_list)); |
100 | 101 |
101 EXPECT_EQ(test_case.expected_feature_on_state, | 102 EXPECT_EQ(test_case.expected_feature_on_state, |
102 FeatureList::IsEnabled(kFeatureOnByDefault)) | 103 FeatureList::IsEnabled(kFeatureOnByDefault)) |
103 << i; | 104 << i; |
104 EXPECT_EQ(test_case.expected_feature_off_state, | 105 EXPECT_EQ(test_case.expected_feature_off_state, |
105 FeatureList::IsEnabled(kFeatureOffByDefault)) | 106 FeatureList::IsEnabled(kFeatureOffByDefault)) |
106 << i; | 107 << i; |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
142 }; | 143 }; |
143 | 144 |
144 FieldTrial::ActiveGroup active_group; | 145 FieldTrial::ActiveGroup active_group; |
145 for (size_t i = 0; i < arraysize(test_cases); ++i) { | 146 for (size_t i = 0; i < arraysize(test_cases); ++i) { |
146 const auto& test_case = test_cases[i]; | 147 const auto& test_case = test_cases[i]; |
147 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]", i)); | 148 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]", i)); |
148 | 149 |
149 ClearFeatureListInstance(); | 150 ClearFeatureListInstance(); |
150 | 151 |
151 FieldTrialList field_trial_list(nullptr); | 152 FieldTrialList field_trial_list(nullptr); |
152 scoped_ptr<FeatureList> feature_list(new FeatureList); | 153 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
153 | 154 |
154 FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("TrialExample1", "A"); | 155 FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("TrialExample1", "A"); |
155 FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("TrialExample2", "B"); | 156 FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("TrialExample2", "B"); |
156 feature_list->RegisterFieldTrialOverride(kFeatureOnByDefaultName, | 157 feature_list->RegisterFieldTrialOverride(kFeatureOnByDefaultName, |
157 test_case.trial1_state, trial1); | 158 test_case.trial1_state, trial1); |
158 feature_list->RegisterFieldTrialOverride(kFeatureOffByDefaultName, | 159 feature_list->RegisterFieldTrialOverride(kFeatureOffByDefaultName, |
159 test_case.trial2_state, trial2); | 160 test_case.trial2_state, trial2); |
160 RegisterFeatureListInstance(std::move(feature_list)); | 161 RegisterFeatureListInstance(std::move(feature_list)); |
161 | 162 |
162 // Initially, neither trial should be active. | 163 // Initially, neither trial should be active. |
(...skipping 11 matching lines...) Expand all Loading... |
174 (test_case.trial2_state == FeatureList::OVERRIDE_ENABLE_FEATURE); | 175 (test_case.trial2_state == FeatureList::OVERRIDE_ENABLE_FEATURE); |
175 EXPECT_EQ(expected_enabled_2, FeatureList::IsEnabled(kFeatureOffByDefault)); | 176 EXPECT_EQ(expected_enabled_2, FeatureList::IsEnabled(kFeatureOffByDefault)); |
176 // The above should have activated |trial2|. | 177 // The above should have activated |trial2|. |
177 EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name())); | 178 EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name())); |
178 EXPECT_TRUE(FieldTrialList::IsTrialActive(trial2->trial_name())); | 179 EXPECT_TRUE(FieldTrialList::IsTrialActive(trial2->trial_name())); |
179 } | 180 } |
180 } | 181 } |
181 | 182 |
182 TEST_F(FeatureListTest, FieldTrialAssociateUseDefault) { | 183 TEST_F(FeatureListTest, FieldTrialAssociateUseDefault) { |
183 FieldTrialList field_trial_list(nullptr); | 184 FieldTrialList field_trial_list(nullptr); |
184 scoped_ptr<FeatureList> feature_list(new FeatureList); | 185 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
185 | 186 |
186 FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("TrialExample1", "A"); | 187 FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("TrialExample1", "A"); |
187 FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("TrialExample2", "B"); | 188 FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("TrialExample2", "B"); |
188 feature_list->RegisterFieldTrialOverride( | 189 feature_list->RegisterFieldTrialOverride( |
189 kFeatureOnByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial1); | 190 kFeatureOnByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial1); |
190 feature_list->RegisterFieldTrialOverride( | 191 feature_list->RegisterFieldTrialOverride( |
191 kFeatureOffByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial2); | 192 kFeatureOffByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial2); |
192 RegisterFeatureListInstance(std::move(feature_list)); | 193 RegisterFeatureListInstance(std::move(feature_list)); |
193 | 194 |
194 // Initially, neither trial should be active. | 195 // Initially, neither trial should be active. |
(...skipping 10 matching lines...) Expand all Loading... |
205 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); | 206 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
206 // The above should have activated |trial2|. | 207 // The above should have activated |trial2|. |
207 EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name())); | 208 EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name())); |
208 EXPECT_TRUE(FieldTrialList::IsTrialActive(trial2->trial_name())); | 209 EXPECT_TRUE(FieldTrialList::IsTrialActive(trial2->trial_name())); |
209 } | 210 } |
210 | 211 |
211 TEST_F(FeatureListTest, CommandLineTakesPrecedenceOverFieldTrial) { | 212 TEST_F(FeatureListTest, CommandLineTakesPrecedenceOverFieldTrial) { |
212 ClearFeatureListInstance(); | 213 ClearFeatureListInstance(); |
213 | 214 |
214 FieldTrialList field_trial_list(nullptr); | 215 FieldTrialList field_trial_list(nullptr); |
215 scoped_ptr<FeatureList> feature_list(new FeatureList); | 216 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
216 | 217 |
217 // The feature is explicitly enabled on the command-line. | 218 // The feature is explicitly enabled on the command-line. |
218 feature_list->InitializeFromCommandLine(kFeatureOffByDefaultName, ""); | 219 feature_list->InitializeFromCommandLine(kFeatureOffByDefaultName, ""); |
219 | 220 |
220 // But the FieldTrial would set the feature to disabled. | 221 // But the FieldTrial would set the feature to disabled. |
221 FieldTrial* trial = FieldTrialList::CreateFieldTrial("TrialExample2", "A"); | 222 FieldTrial* trial = FieldTrialList::CreateFieldTrial("TrialExample2", "A"); |
222 feature_list->RegisterFieldTrialOverride( | 223 feature_list->RegisterFieldTrialOverride( |
223 kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE, trial); | 224 kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE, trial); |
224 RegisterFeatureListInstance(std::move(feature_list)); | 225 RegisterFeatureListInstance(std::move(feature_list)); |
225 | 226 |
226 EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name())); | 227 EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name())); |
227 // Command-line should take precedence. | 228 // Command-line should take precedence. |
228 EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); | 229 EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
229 // Since the feature is on due to the command-line, and not as a result of the | 230 // Since the feature is on due to the command-line, and not as a result of the |
230 // field trial, the field trial should not be activated (since the Associate* | 231 // field trial, the field trial should not be activated (since the Associate* |
231 // API wasn't used.) | 232 // API wasn't used.) |
232 EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name())); | 233 EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name())); |
233 } | 234 } |
234 | 235 |
235 TEST_F(FeatureListTest, IsFeatureOverriddenFromCommandLine) { | 236 TEST_F(FeatureListTest, IsFeatureOverriddenFromCommandLine) { |
236 ClearFeatureListInstance(); | 237 ClearFeatureListInstance(); |
237 | 238 |
238 FieldTrialList field_trial_list(nullptr); | 239 FieldTrialList field_trial_list(nullptr); |
239 scoped_ptr<FeatureList> feature_list(new FeatureList); | 240 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
240 | 241 |
241 // No features are overridden from the command line yet | 242 // No features are overridden from the command line yet |
242 EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( | 243 EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
243 kFeatureOnByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE)); | 244 kFeatureOnByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE)); |
244 EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( | 245 EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
245 kFeatureOnByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE)); | 246 kFeatureOnByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE)); |
246 EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( | 247 EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
247 kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE)); | 248 kFeatureOffByDefaultName, FeatureList::OVERRIDE_DISABLE_FEATURE)); |
248 EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( | 249 EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
249 kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE)); | 250 kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE)); |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
304 | 305 |
305 for (size_t i = 0; i < arraysize(test_cases); ++i) { | 306 for (size_t i = 0; i < arraysize(test_cases); ++i) { |
306 const auto& test_case = test_cases[i]; | 307 const auto& test_case = test_cases[i]; |
307 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: [%s] [%s]", i, | 308 SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]: [%s] [%s]", i, |
308 test_case.enable_features, | 309 test_case.enable_features, |
309 test_case.disable_features)); | 310 test_case.disable_features)); |
310 | 311 |
311 ClearFeatureListInstance(); | 312 ClearFeatureListInstance(); |
312 | 313 |
313 FieldTrialList field_trial_list(nullptr); | 314 FieldTrialList field_trial_list(nullptr); |
314 scoped_ptr<FeatureList> feature_list(new FeatureList); | 315 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
315 feature_list->InitializeFromCommandLine(test_case.enable_features, | 316 feature_list->InitializeFromCommandLine(test_case.enable_features, |
316 test_case.disable_features); | 317 test_case.disable_features); |
317 | 318 |
318 FieldTrial* enable_trial = nullptr; | 319 FieldTrial* enable_trial = nullptr; |
319 if (feature_list->IsFeatureOverriddenFromCommandLine( | 320 if (feature_list->IsFeatureOverriddenFromCommandLine( |
320 kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE)) { | 321 kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE)) { |
321 enable_trial = base::FieldTrialList::CreateFieldTrial(kTrialName, | 322 enable_trial = base::FieldTrialList::CreateFieldTrial(kTrialName, |
322 kForcedOnGroupName); | 323 kForcedOnGroupName); |
323 feature_list->AssociateReportingFieldTrial( | 324 feature_list->AssociateReportingFieldTrial( |
324 kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE, | 325 kFeatureOffByDefaultName, FeatureList::OVERRIDE_ENABLE_FEATURE, |
(...skipping 22 matching lines...) Expand all Loading... |
347 EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); | 348 EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
348 EXPECT_TRUE(FieldTrialList::IsTrialActive(kTrialName)); | 349 EXPECT_TRUE(FieldTrialList::IsTrialActive(kTrialName)); |
349 EXPECT_EQ(kForcedOnGroupName, enable_trial->group_name()); | 350 EXPECT_EQ(kForcedOnGroupName, enable_trial->group_name()); |
350 } | 351 } |
351 } | 352 } |
352 } | 353 } |
353 | 354 |
354 TEST_F(FeatureListTest, GetFeatureOverrides) { | 355 TEST_F(FeatureListTest, GetFeatureOverrides) { |
355 ClearFeatureListInstance(); | 356 ClearFeatureListInstance(); |
356 FieldTrialList field_trial_list(nullptr); | 357 FieldTrialList field_trial_list(nullptr); |
357 scoped_ptr<FeatureList> feature_list(new FeatureList); | 358 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
358 feature_list->InitializeFromCommandLine("A,X", "D"); | 359 feature_list->InitializeFromCommandLine("A,X", "D"); |
359 | 360 |
360 FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial", "Group"); | 361 FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial", "Group"); |
361 feature_list->RegisterFieldTrialOverride(kFeatureOffByDefaultName, | 362 feature_list->RegisterFieldTrialOverride(kFeatureOffByDefaultName, |
362 FeatureList::OVERRIDE_ENABLE_FEATURE, | 363 FeatureList::OVERRIDE_ENABLE_FEATURE, |
363 trial); | 364 trial); |
364 | 365 |
365 RegisterFeatureListInstance(std::move(feature_list)); | 366 RegisterFeatureListInstance(std::move(feature_list)); |
366 | 367 |
367 std::string enable_features; | 368 std::string enable_features; |
368 std::string disable_features; | 369 std::string disable_features; |
369 FeatureList::GetInstance()->GetFeatureOverrides(&enable_features, | 370 FeatureList::GetInstance()->GetFeatureOverrides(&enable_features, |
370 &disable_features); | 371 &disable_features); |
371 EXPECT_EQ("A,OffByDefault<Trial,X", SortFeatureListString(enable_features)); | 372 EXPECT_EQ("A,OffByDefault<Trial,X", SortFeatureListString(enable_features)); |
372 EXPECT_EQ("D", SortFeatureListString(disable_features)); | 373 EXPECT_EQ("D", SortFeatureListString(disable_features)); |
373 } | 374 } |
374 | 375 |
375 TEST_F(FeatureListTest, GetFeatureOverrides_UseDefault) { | 376 TEST_F(FeatureListTest, GetFeatureOverrides_UseDefault) { |
376 ClearFeatureListInstance(); | 377 ClearFeatureListInstance(); |
377 FieldTrialList field_trial_list(nullptr); | 378 FieldTrialList field_trial_list(nullptr); |
378 scoped_ptr<FeatureList> feature_list(new FeatureList); | 379 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
379 feature_list->InitializeFromCommandLine("A,X", "D"); | 380 feature_list->InitializeFromCommandLine("A,X", "D"); |
380 | 381 |
381 FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial", "Group"); | 382 FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial", "Group"); |
382 feature_list->RegisterFieldTrialOverride( | 383 feature_list->RegisterFieldTrialOverride( |
383 kFeatureOffByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial); | 384 kFeatureOffByDefaultName, FeatureList::OVERRIDE_USE_DEFAULT, trial); |
384 | 385 |
385 RegisterFeatureListInstance(std::move(feature_list)); | 386 RegisterFeatureListInstance(std::move(feature_list)); |
386 | 387 |
387 std::string enable_features; | 388 std::string enable_features; |
388 std::string disable_features; | 389 std::string disable_features; |
389 FeatureList::GetInstance()->GetFeatureOverrides(&enable_features, | 390 FeatureList::GetInstance()->GetFeatureOverrides(&enable_features, |
390 &disable_features); | 391 &disable_features); |
391 EXPECT_EQ("*OffByDefault<Trial,A,X", SortFeatureListString(enable_features)); | 392 EXPECT_EQ("*OffByDefault<Trial,A,X", SortFeatureListString(enable_features)); |
392 EXPECT_EQ("D", SortFeatureListString(disable_features)); | 393 EXPECT_EQ("D", SortFeatureListString(disable_features)); |
393 } | 394 } |
394 | 395 |
395 TEST_F(FeatureListTest, InitializeFromCommandLine_WithFieldTrials) { | 396 TEST_F(FeatureListTest, InitializeFromCommandLine_WithFieldTrials) { |
396 ClearFeatureListInstance(); | 397 ClearFeatureListInstance(); |
397 FieldTrialList field_trial_list(nullptr); | 398 FieldTrialList field_trial_list(nullptr); |
398 FieldTrialList::CreateFieldTrial("Trial", "Group"); | 399 FieldTrialList::CreateFieldTrial("Trial", "Group"); |
399 scoped_ptr<FeatureList> feature_list(new FeatureList); | 400 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
400 feature_list->InitializeFromCommandLine("A,OffByDefault<Trial,X", "D"); | 401 feature_list->InitializeFromCommandLine("A,OffByDefault<Trial,X", "D"); |
401 RegisterFeatureListInstance(std::move(feature_list)); | 402 RegisterFeatureListInstance(std::move(feature_list)); |
402 | 403 |
403 EXPECT_FALSE(FieldTrialList::IsTrialActive("Trial")); | 404 EXPECT_FALSE(FieldTrialList::IsTrialActive("Trial")); |
404 EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); | 405 EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
405 EXPECT_TRUE(FieldTrialList::IsTrialActive("Trial")); | 406 EXPECT_TRUE(FieldTrialList::IsTrialActive("Trial")); |
406 } | 407 } |
407 | 408 |
408 TEST_F(FeatureListTest, InitializeFromCommandLine_UseDefault) { | 409 TEST_F(FeatureListTest, InitializeFromCommandLine_UseDefault) { |
409 ClearFeatureListInstance(); | 410 ClearFeatureListInstance(); |
410 FieldTrialList field_trial_list(nullptr); | 411 FieldTrialList field_trial_list(nullptr); |
411 FieldTrialList::CreateFieldTrial("T1", "Group"); | 412 FieldTrialList::CreateFieldTrial("T1", "Group"); |
412 FieldTrialList::CreateFieldTrial("T2", "Group"); | 413 FieldTrialList::CreateFieldTrial("T2", "Group"); |
413 scoped_ptr<FeatureList> feature_list(new FeatureList); | 414 std::unique_ptr<FeatureList> feature_list(new FeatureList); |
414 feature_list->InitializeFromCommandLine( | 415 feature_list->InitializeFromCommandLine( |
415 "A,*OffByDefault<T1,*OnByDefault<T2,X", "D"); | 416 "A,*OffByDefault<T1,*OnByDefault<T2,X", "D"); |
416 RegisterFeatureListInstance(std::move(feature_list)); | 417 RegisterFeatureListInstance(std::move(feature_list)); |
417 | 418 |
418 EXPECT_FALSE(FieldTrialList::IsTrialActive("T1")); | 419 EXPECT_FALSE(FieldTrialList::IsTrialActive("T1")); |
419 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); | 420 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
420 EXPECT_TRUE(FieldTrialList::IsTrialActive("T1")); | 421 EXPECT_TRUE(FieldTrialList::IsTrialActive("T1")); |
421 | 422 |
422 EXPECT_FALSE(FieldTrialList::IsTrialActive("T2")); | 423 EXPECT_FALSE(FieldTrialList::IsTrialActive("T2")); |
423 EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); | 424 EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
424 EXPECT_TRUE(FieldTrialList::IsTrialActive("T2")); | 425 EXPECT_TRUE(FieldTrialList::IsTrialActive("T2")); |
425 } | 426 } |
426 | 427 |
427 TEST_F(FeatureListTest, InitializeInstance) { | 428 TEST_F(FeatureListTest, InitializeInstance) { |
428 ClearFeatureListInstance(); | 429 ClearFeatureListInstance(); |
429 | 430 |
430 scoped_ptr<base::FeatureList> feature_list(new base::FeatureList); | 431 std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList); |
431 FeatureList::SetInstance(std::move(feature_list)); | 432 FeatureList::SetInstance(std::move(feature_list)); |
432 EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); | 433 EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
433 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); | 434 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
434 | 435 |
435 // Initialize from command line if we haven't yet. | 436 // Initialize from command line if we haven't yet. |
436 FeatureList::InitializeInstance("", kFeatureOnByDefaultName); | 437 FeatureList::InitializeInstance("", kFeatureOnByDefaultName); |
437 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); | 438 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
438 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); | 439 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
439 | 440 |
440 // Do not initialize from commandline if we have already. | 441 // Do not initialize from commandline if we have already. |
441 FeatureList::InitializeInstance(kFeatureOffByDefaultName, ""); | 442 FeatureList::InitializeInstance(kFeatureOffByDefaultName, ""); |
442 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); | 443 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
443 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); | 444 EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
444 } | 445 } |
445 | 446 |
446 } // namespace base | 447 } // namespace base |
OLD | NEW |