chrome/browser/about_flags_unittest.cc

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