1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <stdint.h>
6
7 #include "base/files/file_path.h"
8 #include "base/memory/scoped_vector.h"
9 #include "base/path_service.h"
10 #include "base/prefs/pref_registry_simple.h"
11 #include "base/prefs/testing_pref_service.h"
12 #include "base/strings/string_number_conversions.h"
13 #include "base/strings/stringprintf.h"
14 #include "base/strings/utf_string_conversions.h"
15 #include "base/values.h"
16 #include "chrome/browser/about_flags.h"
17 #include "chrome/browser/pref_service_flags_storage.h"
18 #include "chrome/common/chrome_switches.h"
19 #include "chrome/common/pref_names.h"
20 #include "chrome/grit/chromium_strings.h"
21 #include "testing/gtest/include/gtest/gtest.h"
22 #include "third_party/libxml/chromium/libxml_utils.h"
23
24 namespace {
25
26 const char kFlags1[] = "flag1";
27 const char kFlags2[] = "flag2";
28 const char kFlags3[] = "flag3";
29 const char kFlags4[] = "flag4";
30 const char kFlags5[] = "flag5";
31
32 const char kSwitch1[] = "switch";
33 const char kSwitch2[] = "switch2";
34 const char kSwitch3[] = "switch3";
35 const char kValueForSwitch2[] = "value_for_switch2";
36
37 const char kMultiSwitch1[] = "multi_switch1";
38 const char kMultiSwitch2[] = "multi_switch2";
39 const char kValueForMultiSwitch2[] = "value_for_multi_switch2";
40
41 const char kEnableDisableValue1[] = "value1";
42 const char kEnableDisableValue2[] = "value2";
43
44 typedef base::HistogramBase::Sample Sample;
45 typedef std::map<std::string, Sample> SwitchToIdMap;
46
47 // This is a helper function to the ReadEnumFromHistogramsXml().
48 // Extracts single enum (with integer values) from histograms.xml.
49 // Expects |reader| to point at given enum.
50 // Returns map { value => label }.
51 // Returns empty map on error.
ParseEnumFromHistogramsXml(const std::string & enum_name,XmlReader * reader)52 std::map<Sample, std::string> ParseEnumFromHistogramsXml(
53 const std::string& enum_name,
54 XmlReader* reader) {
55 int entries_index = -1;
56
57 std::map<Sample, std::string> result;
58 bool success = true;
59
60 while (true) {
61 const std::string node_name = reader->NodeName();
62 if (node_name == "enum" && reader->IsClosingElement())
63 break;
64
65 if (node_name == "int") {
66 ++entries_index;
67 std::string value_str;
68 std::string label;
69 const bool has_value = reader->NodeAttribute("value", &value_str);
70 const bool has_label = reader->NodeAttribute("label", &label);
71 if (!has_value) {
72 ADD_FAILURE() << "Bad " << enum_name << " enum entry (at index "
73 << entries_index << ", label='" << label
74 << "'): No 'value' attribute.";
75 success = false;
76 }
77 if (!has_label) {
78 ADD_FAILURE() << "Bad " << enum_name << " enum entry (at index "
79 << entries_index << ", value_str='" << value_str
80 << "'): No 'label' attribute.";
81 success = false;
82 }
83
84 Sample value;
85 if (has_value && !base::StringToInt(value_str, &value)) {
86 ADD_FAILURE() << "Bad " << enum_name << " enum entry (at index "
87 << entries_index << ", label='" << label
88 << "', value_str='" << value_str
89 << "'): 'value' attribute is not integer.";
90 success = false;
91 }
92 if (result.count(value)) {
93 ADD_FAILURE() << "Bad " << enum_name << " enum entry (at index "
94 << entries_index << ", label='" << label
95 << "', value_str='" << value_str
96 << "'): duplicate value '" << value_str
97 << "' found in enum. The previous one has label='"
98 << result[value] << "'.";
99 success = false;
100 }
101 if (success) {
102 result[value] = label;
103 }
104 }
105 // All enum entries are on the same level, so it is enough to iterate
106 // until possible.
107 reader->Next();
108 }
109 return (success ? result : std::map<Sample, std::string>());
110 }
111
112 // Find and read given enum (with integer values) from histograms.xml.
113 // |enum_name| - enum name.
114 // |histograms_xml| - must be loaded histograms.xml file.
115 //
116 // Returns map { value => label } so that:
117 // <int value="9" label="enable-pinch-virtual-viewport"/>
118 // becomes:
119 // { 9 => "enable-pinch-virtual-viewport" }
120 // Returns empty map on error.
ReadEnumFromHistogramsXml(const std::string & enum_name,XmlReader * histograms_xml)121 std::map<Sample, std::string> ReadEnumFromHistogramsXml(
122 const std::string& enum_name,
123 XmlReader* histograms_xml) {
124 std::map<Sample, std::string> login_custom_flags;
125
126 // Implement simple depth first search.
127 while (true) {
128 const std::string node_name = histograms_xml->NodeName();
129 if (node_name == "enum") {
130 std::string name;
131 if (histograms_xml->NodeAttribute("name", &name) && name == enum_name) {
132 if (!login_custom_flags.empty()) {
133 EXPECT_TRUE(login_custom_flags.empty())
134 << "Duplicate enum '" << enum_name << "' found in histograms.xml";
135 return std::map<Sample, std::string>();
136 }
137
138 const bool got_into_enum = histograms_xml->Read();
139 if (got_into_enum) {
140 login_custom_flags =
141 ParseEnumFromHistogramsXml(enum_name, histograms_xml);
142 EXPECT_FALSE(login_custom_flags.empty())
143 << "Bad enum '" << enum_name
144 << "' found in histograms.xml (format error).";
145 } else {
146 EXPECT_TRUE(got_into_enum)
147 << "Bad enum '" << enum_name
148 << "' (looks empty) found in histograms.xml.";
149 }
150 if (login_custom_flags.empty())
151 return std::map<Sample, std::string>();
152 }
153 }
154 // Go deeper if possible (stops at the closing tag of the deepest node).
155 if (histograms_xml->Read())
156 continue;
157
158 // Try next node on the same level (skips closing tag).
159 if (histograms_xml->Next())
160 continue;
161
162 // Go up until next node on the same level exists.
163 while (histograms_xml->Depth() && !histograms_xml->SkipToElement()) {
164 }
165
166 // Reached top. histograms.xml consists of the single top level node
167 // 'histogram-configuration', so this is the end.
168 if (!histograms_xml->Depth())
169 break;
170 }
171 EXPECT_FALSE(login_custom_flags.empty())
172 << "Enum '" << enum_name << "' is not found in histograms.xml.";
173 return login_custom_flags;
174 }
175
FilePathStringTypeToString(const base::FilePath::StringType & path)176 std::string FilePathStringTypeToString(const base::FilePath::StringType& path) {
177 #if defined(OS_WIN)
178 return base::UTF16ToUTF8(path);
179 #else
180 return path;
181 #endif
182 }
183
GetAllSwitchesForTesting()184 std::set<std::string> GetAllSwitchesForTesting() {
185 std::set<std::string> result;
186
187 size_t num_experiments = 0;
188 const about_flags::Experiment* experiments =
189 about_flags::testing::GetExperiments(&num_experiments);
190
191 for (size_t i = 0; i < num_experiments; ++i) {
192 const about_flags::Experiment& experiment = experiments[i];
193 if (experiment.type == about_flags::Experiment::SINGLE_VALUE) {
194 result.insert(experiment.command_line_switch);
195 } else if (experiment.type == about_flags::Experiment::MULTI_VALUE) {
196 for (int j = 0; j < experiment.num_choices; ++j) {
197 result.insert(experiment.choices[j].command_line_switch);
198 }
199 } else {
200 DCHECK_EQ(experiment.type, about_flags::Experiment::ENABLE_DISABLE_VALUE);
201 result.insert(experiment.command_line_switch);
202 result.insert(experiment.disable_command_line_switch);
203 }
204 }
205 return result;
206 }
207
208 } // anonymous namespace
209
210 namespace about_flags {
211
212 const Experiment::Choice kMultiChoices[] = {
213 { IDS_PRODUCT_NAME, "", "" },
214 { IDS_PRODUCT_NAME, kMultiSwitch1, "" },
215 { IDS_PRODUCT_NAME, kMultiSwitch2, kValueForMultiSwitch2 },
216 };
217
218 // The experiments that are set for these tests. The 3rd experiment is not
219 // supported on the current platform, all others are.
220 static Experiment kExperiments[] = {
221 {
222 kFlags1,
223 IDS_PRODUCT_NAME,
224 IDS_PRODUCT_NAME,
225 0, // Ends up being mapped to the current platform.
226 Experiment::SINGLE_VALUE,
227 kSwitch1,
228 "",
229 NULL,
230 NULL,
231 NULL,
232 0
233 },
234 {
235 kFlags2,
236 IDS_PRODUCT_NAME,
237 IDS_PRODUCT_NAME,
238 0, // Ends up being mapped to the current platform.
239 Experiment::SINGLE_VALUE,
240 kSwitch2,
241 kValueForSwitch2,
242 NULL,
243 NULL,
244 NULL,
245 0
246 },
247 {
248 kFlags3,
249 IDS_PRODUCT_NAME,
250 IDS_PRODUCT_NAME,
251 0, // This ends up enabling for an OS other than the current.
252 Experiment::SINGLE_VALUE,
253 kSwitch3,
254 "",
255 NULL,
256 NULL,
257 NULL,
258 0
259 },
260 {
261 kFlags4,
262 IDS_PRODUCT_NAME,
263 IDS_PRODUCT_NAME,
264 0, // Ends up being mapped to the current platform.
265 Experiment::MULTI_VALUE,
266 "",
267 "",
268 "",
269 "",
270 kMultiChoices,
271 arraysize(kMultiChoices)
272 },
273 {
274 kFlags5,
275 IDS_PRODUCT_NAME,
276 IDS_PRODUCT_NAME,
277 0, // Ends up being mapped to the current platform.
278 Experiment::ENABLE_DISABLE_VALUE,
279 kSwitch1,
280 kEnableDisableValue1,
281 kSwitch2,
282 kEnableDisableValue2,
283 NULL,
284 3
285 },
286 };
287
288 class AboutFlagsTest : public ::testing::Test {
289 protected:
AboutFlagsTest()290 AboutFlagsTest() : flags_storage_(&prefs_) {
291 prefs_.registry()->RegisterListPref(prefs::kEnabledLabsExperiments);
292 testing::ClearState();
293 }
294
SetUp()295 virtual void SetUp() OVERRIDE {
296 for (size_t i = 0; i < arraysize(kExperiments); ++i)
297 kExperiments[i].supported_platforms = GetCurrentPlatform();
298
299 int os_other_than_current = 1;
300 while (os_other_than_current == GetCurrentPlatform())
301 os_other_than_current <<= 1;
302 kExperiments[2].supported_platforms = os_other_than_current;
303
304 testing::SetExperiments(kExperiments, arraysize(kExperiments));
305 }
306
TearDown()307 virtual void TearDown() OVERRIDE {
308 testing::SetExperiments(NULL, 0);
309 }
310
311 TestingPrefServiceSimple prefs_;
312 PrefServiceFlagsStorage flags_storage_;
313 };
314
315
TEST_F(AboutFlagsTest,NoChangeNoRestart)316 TEST_F(AboutFlagsTest, NoChangeNoRestart) {
317 EXPECT_FALSE(IsRestartNeededToCommitChanges());
318 SetExperimentEnabled(&flags_storage_, kFlags1, false);
319 EXPECT_FALSE(IsRestartNeededToCommitChanges());
320 }
321
TEST_F(AboutFlagsTest,ChangeNeedsRestart)322 TEST_F(AboutFlagsTest, ChangeNeedsRestart) {
323 EXPECT_FALSE(IsRestartNeededToCommitChanges());
324 SetExperimentEnabled(&flags_storage_, kFlags1, true);
325 EXPECT_TRUE(IsRestartNeededToCommitChanges());
326 }
327
TEST_F(AboutFlagsTest,MultiFlagChangeNeedsRestart)328 TEST_F(AboutFlagsTest, MultiFlagChangeNeedsRestart) {
329 const Experiment& experiment = kExperiments[3];
330 ASSERT_EQ(kFlags4, experiment.internal_name);
331 EXPECT_FALSE(IsRestartNeededToCommitChanges());
332 // Enable the 2nd choice of the multi-value.
333 SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
334 EXPECT_TRUE(IsRestartNeededToCommitChanges());
335 testing::ClearState();
336 EXPECT_FALSE(IsRestartNeededToCommitChanges());
337 // Enable the default choice now.
338 SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
339 EXPECT_TRUE(IsRestartNeededToCommitChanges());
340 }
341
TEST_F(AboutFlagsTest,AddTwoFlagsRemoveOne)342 TEST_F(AboutFlagsTest, AddTwoFlagsRemoveOne) {
343 // Add two experiments, check they're there.
344 SetExperimentEnabled(&flags_storage_, kFlags1, true);
345 SetExperimentEnabled(&flags_storage_, kFlags2, true);
346
347 const base::ListValue* experiments_list = prefs_.GetList(
348 prefs::kEnabledLabsExperiments);
349 ASSERT_TRUE(experiments_list != NULL);
350
351 ASSERT_EQ(2u, experiments_list->GetSize());
352
353 std::string s0;
354 ASSERT_TRUE(experiments_list->GetString(0, &s0));
355 std::string s1;
356 ASSERT_TRUE(experiments_list->GetString(1, &s1));
357
358 EXPECT_TRUE(s0 == kFlags1 || s1 == kFlags1);
359 EXPECT_TRUE(s0 == kFlags2 || s1 == kFlags2);
360
361 // Remove one experiment, check the other's still around.
362 SetExperimentEnabled(&flags_storage_, kFlags2, false);
363
364 experiments_list = prefs_.GetList(prefs::kEnabledLabsExperiments);
365 ASSERT_TRUE(experiments_list != NULL);
366 ASSERT_EQ(1u, experiments_list->GetSize());
367 ASSERT_TRUE(experiments_list->GetString(0, &s0));
368 EXPECT_TRUE(s0 == kFlags1);
369 }
370
TEST_F(AboutFlagsTest,AddTwoFlagsRemoveBoth)371 TEST_F(AboutFlagsTest, AddTwoFlagsRemoveBoth) {
372 // Add two experiments, check the pref exists.
373 SetExperimentEnabled(&flags_storage_, kFlags1, true);
374 SetExperimentEnabled(&flags_storage_, kFlags2, true);
375 const base::ListValue* experiments_list = prefs_.GetList(
376 prefs::kEnabledLabsExperiments);
377 ASSERT_TRUE(experiments_list != NULL);
378
379 // Remove both, the pref should have been removed completely.
380 SetExperimentEnabled(&flags_storage_, kFlags1, false);
381 SetExperimentEnabled(&flags_storage_, kFlags2, false);
382 experiments_list = prefs_.GetList(prefs::kEnabledLabsExperiments);
383 EXPECT_TRUE(experiments_list == NULL || experiments_list->GetSize() == 0);
384 }
385
TEST_F(AboutFlagsTest,ConvertFlagsToSwitches)386 TEST_F(AboutFlagsTest, ConvertFlagsToSwitches) {
387 SetExperimentEnabled(&flags_storage_, kFlags1, true);
388
389 CommandLine command_line(CommandLine::NO_PROGRAM);
390 command_line.AppendSwitch("foo");
391
392 EXPECT_TRUE(command_line.HasSwitch("foo"));
393 EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
394
395 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
396
397 EXPECT_TRUE(command_line.HasSwitch("foo"));
398 EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
399 EXPECT_TRUE(command_line.HasSwitch(switches::kFlagSwitchesBegin));
400 EXPECT_TRUE(command_line.HasSwitch(switches::kFlagSwitchesEnd));
401
402 CommandLine command_line2(CommandLine::NO_PROGRAM);
403
404 ConvertFlagsToSwitches(&flags_storage_, &command_line2, kNoSentinels);
405
406 EXPECT_TRUE(command_line2.HasSwitch(kSwitch1));
407 EXPECT_FALSE(command_line2.HasSwitch(switches::kFlagSwitchesBegin));
408 EXPECT_FALSE(command_line2.HasSwitch(switches::kFlagSwitchesEnd));
409 }
410
CreateSwitch(const std::string & value)411 CommandLine::StringType CreateSwitch(const std::string& value) {
412 #if defined(OS_WIN)
413 return base::ASCIIToUTF16(value);
414 #else
415 return value;
416 #endif
417 }
418
TEST_F(AboutFlagsTest,CompareSwitchesToCurrentCommandLine)419 TEST_F(AboutFlagsTest, CompareSwitchesToCurrentCommandLine) {
420 SetExperimentEnabled(&flags_storage_, kFlags1, true);
421
422 const std::string kDoubleDash("--");
423
424 CommandLine command_line(CommandLine::NO_PROGRAM);
425 command_line.AppendSwitch("foo");
426
427 CommandLine new_command_line(CommandLine::NO_PROGRAM);
428 ConvertFlagsToSwitches(&flags_storage_, &new_command_line, kAddSentinels);
429
430 EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
431 new_command_line, command_line, NULL));
432 {
433 std::set<CommandLine::StringType> difference;
434 EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
435 new_command_line, command_line, &difference));
436 EXPECT_EQ(1U, difference.size());
437 EXPECT_EQ(1U, difference.count(CreateSwitch(kDoubleDash + kSwitch1)));
438 }
439
440 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
441
442 EXPECT_TRUE(AreSwitchesIdenticalToCurrentCommandLine(
443 new_command_line, command_line, NULL));
444 {
445 std::set<CommandLine::StringType> difference;
446 EXPECT_TRUE(AreSwitchesIdenticalToCurrentCommandLine(
447 new_command_line, command_line, &difference));
448 EXPECT_TRUE(difference.empty());
449 }
450
451 // Now both have flags but different.
452 SetExperimentEnabled(&flags_storage_, kFlags1, false);
453 SetExperimentEnabled(&flags_storage_, kFlags2, true);
454
455 CommandLine another_command_line(CommandLine::NO_PROGRAM);
456 ConvertFlagsToSwitches(&flags_storage_, &another_command_line, kAddSentinels);
457
458 EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
459 new_command_line, another_command_line, NULL));
460 {
461 std::set<CommandLine::StringType> difference;
462 EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
463 new_command_line, another_command_line, &difference));
464 EXPECT_EQ(2U, difference.size());
465 EXPECT_EQ(1U, difference.count(CreateSwitch(kDoubleDash + kSwitch1)));
466 EXPECT_EQ(1U,
467 difference.count(CreateSwitch(kDoubleDash + kSwitch2 + "=" +
468 kValueForSwitch2)));
469 }
470 }
471
TEST_F(AboutFlagsTest,RemoveFlagSwitches)472 TEST_F(AboutFlagsTest, RemoveFlagSwitches) {
473 std::map<std::string, CommandLine::StringType> switch_list;
474 switch_list[kSwitch1] = CommandLine::StringType();
475 switch_list[switches::kFlagSwitchesBegin] = CommandLine::StringType();
476 switch_list[switches::kFlagSwitchesEnd] = CommandLine::StringType();
477 switch_list["foo"] = CommandLine::StringType();
478
479 SetExperimentEnabled(&flags_storage_, kFlags1, true);
480
481 // This shouldn't do anything before ConvertFlagsToSwitches() wasn't called.
482 RemoveFlagsSwitches(&switch_list);
483 ASSERT_EQ(4u, switch_list.size());
484 EXPECT_TRUE(switch_list.find(kSwitch1) != switch_list.end());
485 EXPECT_TRUE(switch_list.find(switches::kFlagSwitchesBegin) !=
486 switch_list.end());
487 EXPECT_TRUE(switch_list.find(switches::kFlagSwitchesEnd) !=
488 switch_list.end());
489 EXPECT_TRUE(switch_list.find("foo") != switch_list.end());
490
491 // Call ConvertFlagsToSwitches(), then RemoveFlagsSwitches() again.
492 CommandLine command_line(CommandLine::NO_PROGRAM);
493 command_line.AppendSwitch("foo");
494 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
495 RemoveFlagsSwitches(&switch_list);
496
497 // Now the about:flags-related switch should have been removed.
498 ASSERT_EQ(1u, switch_list.size());
499 EXPECT_TRUE(switch_list.find("foo") != switch_list.end());
500 }
501
502 // Tests enabling experiments that aren't supported on the current platform.
TEST_F(AboutFlagsTest,PersistAndPrune)503 TEST_F(AboutFlagsTest, PersistAndPrune) {
504 // Enable experiments 1 and 3.
505 SetExperimentEnabled(&flags_storage_, kFlags1, true);
506 SetExperimentEnabled(&flags_storage_, kFlags3, true);
507 CommandLine command_line(CommandLine::NO_PROGRAM);
508 EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
509 EXPECT_FALSE(command_line.HasSwitch(kSwitch3));
510
511 // Convert the flags to switches. Experiment 3 shouldn't be among the switches
512 // as it is not applicable to the current platform.
513 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
514 EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
515 EXPECT_FALSE(command_line.HasSwitch(kSwitch3));
516
517 // Experiment 3 should show still be persisted in preferences though.
518 const base::ListValue* experiments_list =
519 prefs_.GetList(prefs::kEnabledLabsExperiments);
520 ASSERT_TRUE(experiments_list);
521 EXPECT_EQ(2U, experiments_list->GetSize());
522 std::string s0;
523 ASSERT_TRUE(experiments_list->GetString(0, &s0));
524 EXPECT_EQ(kFlags1, s0);
525 std::string s1;
526 ASSERT_TRUE(experiments_list->GetString(1, &s1));
527 EXPECT_EQ(kFlags3, s1);
528 }
529
530 // Tests that switches which should have values get them in the command
531 // line.
TEST_F(AboutFlagsTest,CheckValues)532 TEST_F(AboutFlagsTest, CheckValues) {
533 // Enable experiments 1 and 2.
534 SetExperimentEnabled(&flags_storage_, kFlags1, true);
535 SetExperimentEnabled(&flags_storage_, kFlags2, true);
536 CommandLine command_line(CommandLine::NO_PROGRAM);
537 EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
538 EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
539
540 // Convert the flags to switches.
541 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
542 EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
543 EXPECT_EQ(std::string(), command_line.GetSwitchValueASCII(kSwitch1));
544 EXPECT_TRUE(command_line.HasSwitch(kSwitch2));
545 EXPECT_EQ(std::string(kValueForSwitch2),
546 command_line.GetSwitchValueASCII(kSwitch2));
547
548 // Confirm that there is no '=' in the command line for simple switches.
549 std::string switch1_with_equals = std::string("--") +
550 std::string(kSwitch1) +
551 std::string("=");
552 #if defined(OS_WIN)
553 EXPECT_EQ(std::wstring::npos,
554 command_line.GetCommandLineString().find(
555 base::ASCIIToWide(switch1_with_equals)));
556 #else
557 EXPECT_EQ(std::string::npos,
558 command_line.GetCommandLineString().find(switch1_with_equals));
559 #endif
560
561 // And confirm there is a '=' for switches with values.
562 std::string switch2_with_equals = std::string("--") +
563 std::string(kSwitch2) +
564 std::string("=");
565 #if defined(OS_WIN)
566 EXPECT_NE(std::wstring::npos,
567 command_line.GetCommandLineString().find(
568 base::ASCIIToWide(switch2_with_equals)));
569 #else
570 EXPECT_NE(std::string::npos,
571 command_line.GetCommandLineString().find(switch2_with_equals));
572 #endif
573
574 // And it should persist.
575 const base::ListValue* experiments_list =
576 prefs_.GetList(prefs::kEnabledLabsExperiments);
577 ASSERT_TRUE(experiments_list);
578 EXPECT_EQ(2U, experiments_list->GetSize());
579 std::string s0;
580 ASSERT_TRUE(experiments_list->GetString(0, &s0));
581 EXPECT_EQ(kFlags1, s0);
582 std::string s1;
583 ASSERT_TRUE(experiments_list->GetString(1, &s1));
584 EXPECT_EQ(kFlags2, s1);
585 }
586
587 // Tests multi-value type experiments.
TEST_F(AboutFlagsTest,MultiValues)588 TEST_F(AboutFlagsTest, MultiValues) {
589 const Experiment& experiment = kExperiments[3];
590 ASSERT_EQ(kFlags4, experiment.internal_name);
591
592 // Initially, the first "deactivated" option of the multi experiment should
593 // be set.
594 {
595 CommandLine command_line(CommandLine::NO_PROGRAM);
596 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
597 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
598 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
599 }
600
601 // Enable the 2nd choice of the multi-value.
602 SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
603 {
604 CommandLine command_line(CommandLine::NO_PROGRAM);
605 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
606 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
607 EXPECT_TRUE(command_line.HasSwitch(kMultiSwitch2));
608 EXPECT_EQ(std::string(kValueForMultiSwitch2),
609 command_line.GetSwitchValueASCII(kMultiSwitch2));
610 }
611
612 // Disable the multi-value experiment.
613 SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
614 {
615 CommandLine command_line(CommandLine::NO_PROGRAM);
616 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
617 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
618 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
619 }
620 }
621
TEST_F(AboutFlagsTest,EnableDisableValues)622 TEST_F(AboutFlagsTest, EnableDisableValues) {
623 const Experiment& experiment = kExperiments[4];
624 ASSERT_EQ(kFlags5, experiment.internal_name);
625
626 // Nothing selected.
627 {
628 CommandLine command_line(CommandLine::NO_PROGRAM);
629 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
630 EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
631 EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
632 }
633
634 // "Enable" option selected.
635 SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(1), true);
636 {
637 CommandLine command_line(CommandLine::NO_PROGRAM);
638 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
639 EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
640 EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
641 EXPECT_EQ(kEnableDisableValue1, command_line.GetSwitchValueASCII(kSwitch1));
642 }
643
644 // "Disable" option selected.
645 SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
646 {
647 CommandLine command_line(CommandLine::NO_PROGRAM);
648 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
649 EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
650 EXPECT_TRUE(command_line.HasSwitch(kSwitch2));
651 EXPECT_EQ(kEnableDisableValue2, command_line.GetSwitchValueASCII(kSwitch2));
652 }
653
654 // "Default" option selected, same as nothing selected.
655 SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
656 {
657 CommandLine command_line(CommandLine::NO_PROGRAM);
658 ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
659 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
660 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
661 }
662 }
663
664 // Makes sure there are no separators in any of the experiment names.
TEST_F(AboutFlagsTest,NoSeparators)665 TEST_F(AboutFlagsTest, NoSeparators) {
666 testing::SetExperiments(NULL, 0);
667 size_t count;
668 const Experiment* experiments = testing::GetExperiments(&count);
669 for (size_t i = 0; i < count; ++i) {
670 std::string name = experiments->internal_name;
671 EXPECT_EQ(std::string::npos, name.find(testing::kMultiSeparator)) << i;
672 }
673 }
674
675 class AboutFlagsHistogramTest : public ::testing::Test {
676 protected:
677 // This is a helper function to check that all IDs in enum LoginCustomFlags in
678 // histograms.xml are unique.
SetSwitchToHistogramIdMapping(const std::string & switch_name,const Sample switch_histogram_id,std::map<std::string,Sample> * out_map)679 void SetSwitchToHistogramIdMapping(const std::string& switch_name,
680 const Sample switch_histogram_id,
681 std::map<std::string, Sample>* out_map) {
682 const std::pair<std::map<std::string, Sample>::iterator, bool> status =
683 out_map->insert(std::make_pair(switch_name, switch_histogram_id));
684 if (!status.second) {
685 EXPECT_TRUE(status.first->second == switch_histogram_id)
686 << "Duplicate switch '" << switch_name
687 << "' found in enum 'LoginCustomFlags' in histograms.xml.";
688 }
689 }
690
691 // This method generates a hint for the user for what string should be added
692 // to the enum LoginCustomFlags to make in consistent.
GetHistogramEnumEntryText(const std::string & switch_name,Sample value)693 std::string GetHistogramEnumEntryText(const std::string& switch_name,
694 Sample value) {
695 return base::StringPrintf(
696 "<int value=\"%d\" label=\"%s\"/>", value, switch_name.c_str());
697 }
698 };
699
TEST_F(AboutFlagsHistogramTest,CheckHistograms)700 TEST_F(AboutFlagsHistogramTest, CheckHistograms) {
701 base::FilePath histograms_xml_file_path;
702 ASSERT_TRUE(
703 PathService::Get(base::DIR_SOURCE_ROOT, &histograms_xml_file_path));
704 histograms_xml_file_path = histograms_xml_file_path.AppendASCII("tools")
705 .AppendASCII("metrics")
706 .AppendASCII("histograms")
707 .AppendASCII("histograms.xml");
708
709 XmlReader histograms_xml;
710 ASSERT_TRUE(histograms_xml.LoadFile(
711 FilePathStringTypeToString(histograms_xml_file_path.value())));
712 std::map<Sample, std::string> login_custom_flags =
713 ReadEnumFromHistogramsXml("LoginCustomFlags", &histograms_xml);
714 ASSERT_TRUE(login_custom_flags.size())
715 << "Error reading enum 'LoginCustomFlags' from histograms.xml.";
716
717 // Build reverse map {switch_name => id} from login_custom_flags.
718 SwitchToIdMap histograms_xml_switches_ids;
719
720 EXPECT_TRUE(login_custom_flags.count(kBadSwitchFormatHistogramId))
721 << "Entry for UMA ID of incorrect command-line flag is not found in "
722 "histograms.xml enum LoginCustomFlags. "
723 "Consider adding entry:\n"
724 << " " << GetHistogramEnumEntryText("BAD_FLAG_FORMAT", 0);
725 // Check that all LoginCustomFlags entries have correct values.
726 for (std::map<Sample, std::string>::const_iterator it =
727 login_custom_flags.begin();
728 it != login_custom_flags.end();
729 ++it) {
730 if (it->first == kBadSwitchFormatHistogramId) {
731 // Add eror value with empty name.
732 SetSwitchToHistogramIdMapping(
733 "", it->first, &histograms_xml_switches_ids);
734 continue;
735 }
736 const Sample uma_id = GetSwitchUMAId(it->second);
737 EXPECT_EQ(uma_id, it->first)
738 << "histograms.xml enum LoginCustomFlags "
739 "entry '" << it->second << "' has incorrect value=" << it->first
740 << ", but " << uma_id << " is expected. Consider changing entry to:\n"
741 << " " << GetHistogramEnumEntryText(it->second, uma_id);
742 SetSwitchToHistogramIdMapping(
743 it->second, it->first, &histograms_xml_switches_ids);
744 }
745
746 // Check that all flags in about_flags.cc have entries in login_custom_flags.
747 std::set<std::string> all_switches = GetAllSwitchesForTesting();
748 for (std::set<std::string>::const_iterator it = all_switches.begin();
749 it != all_switches.end();
750 ++it) {
751 // Skip empty placeholders.
752 if (it->empty())
753 continue;
754 const Sample uma_id = GetSwitchUMAId(*it);
755 EXPECT_NE(kBadSwitchFormatHistogramId, uma_id)
756 << "Command-line switch '" << *it
757 << "' from about_flags.cc has UMA ID equal to reserved value "
758 "kBadSwitchFormatHistogramId=" << kBadSwitchFormatHistogramId
759 << ". Please modify switch name.";
760 SwitchToIdMap::iterator enum_entry =
761 histograms_xml_switches_ids.lower_bound(*it);
762
763 // Ignore case here when switch ID is incorrect - it has already been
764 // reported in the previous loop.
765 EXPECT_TRUE(enum_entry != histograms_xml_switches_ids.end() &&
766 enum_entry->first == *it)
767 << "histograms.xml enum LoginCustomFlags doesn't contain switch '"
768 << *it << "' (value=" << uma_id
769 << " expected). Consider adding entry:\n"
770 << " " << GetHistogramEnumEntryText(*it, uma_id);
771 }
772 }
773
774 } // namespace about_flags
775