Make callers of CommandLine use it via the base:: namespace.

chrome/browser/about_flags_unittest.cc

 // Copyright (c) 2011 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 <stdint.h>
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/memory/scoped_vector.h"
 #include "base/path_service.h"
@@ skipping 367 matching lines @@
   // Remove both, the pref should have been removed completely.
   SetExperimentEnabled(&flags_storage_, kFlags1, false);
   SetExperimentEnabled(&flags_storage_, kFlags2, false);
   experiments_list = prefs_.GetList(prefs::kEnabledLabsExperiments);
   EXPECT_TRUE(experiments_list == NULL || experiments_list->GetSize() == 0);
 }
 
 TEST_F(AboutFlagsTest, ConvertFlagsToSwitches) {
   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 
-  CommandLine command_line(CommandLine::NO_PROGRAM);
+  base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitch("foo");
 
   EXPECT_TRUE(command_line.HasSwitch("foo"));
   EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
 
   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 
   EXPECT_TRUE(command_line.HasSwitch("foo"));
   EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
   EXPECT_TRUE(command_line.HasSwitch(switches::kFlagSwitchesBegin));
   EXPECT_TRUE(command_line.HasSwitch(switches::kFlagSwitchesEnd));
 
-  CommandLine command_line2(CommandLine::NO_PROGRAM);
+  base::CommandLine command_line2(base::CommandLine::NO_PROGRAM);
 
   ConvertFlagsToSwitches(&flags_storage_, &command_line2, kNoSentinels);
 
   EXPECT_TRUE(command_line2.HasSwitch(kSwitch1));
   EXPECT_FALSE(command_line2.HasSwitch(switches::kFlagSwitchesBegin));
   EXPECT_FALSE(command_line2.HasSwitch(switches::kFlagSwitchesEnd));
 }
 
-CommandLine::StringType CreateSwitch(const std::string& value) {
+base::CommandLine::StringType CreateSwitch(const std::string& value) {
 #if defined(OS_WIN)
   return base::ASCIIToUTF16(value);
 #else
   return value;
 #endif
 }
 
 TEST_F(AboutFlagsTest, CompareSwitchesToCurrentCommandLine) {
   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 
   const std::string kDoubleDash("--");
 
-  CommandLine command_line(CommandLine::NO_PROGRAM);
+  base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitch("foo");
 
-  CommandLine new_command_line(CommandLine::NO_PROGRAM);
+  base::CommandLine new_command_line(base::CommandLine::NO_PROGRAM);
   ConvertFlagsToSwitches(&flags_storage_, &new_command_line, kAddSentinels);
 
   EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
       new_command_line, command_line, NULL));
   {
-    std::set<CommandLine::StringType> difference;
+    std::set<base::CommandLine::StringType> difference;
     EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
         new_command_line, command_line, &difference));
     EXPECT_EQ(1U, difference.size());
     EXPECT_EQ(1U, difference.count(CreateSwitch(kDoubleDash + kSwitch1)));
   }
 
   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 
   EXPECT_TRUE(AreSwitchesIdenticalToCurrentCommandLine(
       new_command_line, command_line, NULL));
   {
-    std::set<CommandLine::StringType> difference;
+    std::set<base::CommandLine::StringType> difference;
     EXPECT_TRUE(AreSwitchesIdenticalToCurrentCommandLine(
         new_command_line, command_line, &difference));
     EXPECT_TRUE(difference.empty());
   }
 
   // Now both have flags but different.
   SetExperimentEnabled(&flags_storage_, kFlags1, false);
   SetExperimentEnabled(&flags_storage_, kFlags2, true);
 
-  CommandLine another_command_line(CommandLine::NO_PROGRAM);
+  base::CommandLine another_command_line(base::CommandLine::NO_PROGRAM);
   ConvertFlagsToSwitches(&flags_storage_, &another_command_line, kAddSentinels);
 
   EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
       new_command_line, another_command_line, NULL));
   {
-    std::set<CommandLine::StringType> difference;
+    std::set<base::CommandLine::StringType> difference;
     EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(
         new_command_line, another_command_line, &difference));
     EXPECT_EQ(2U, difference.size());
     EXPECT_EQ(1U, difference.count(CreateSwitch(kDoubleDash + kSwitch1)));
     EXPECT_EQ(1U,
               difference.count(CreateSwitch(kDoubleDash + kSwitch2 + "=" +
                                             kValueForSwitch2)));
   }
 }
 
 TEST_F(AboutFlagsTest, RemoveFlagSwitches) {
-  std::map<std::string, CommandLine::StringType> switch_list;
-  switch_list[kSwitch1] = CommandLine::StringType();
-  switch_list[switches::kFlagSwitchesBegin] = CommandLine::StringType();
-  switch_list[switches::kFlagSwitchesEnd] = CommandLine::StringType();
-  switch_list["foo"] = CommandLine::StringType();
+  std::map<std::string, base::CommandLine::StringType> switch_list;
+  switch_list[kSwitch1] = base::CommandLine::StringType();
+  switch_list[switches::kFlagSwitchesBegin] = base::CommandLine::StringType();
+  switch_list[switches::kFlagSwitchesEnd] = base::CommandLine::StringType();
+  switch_list["foo"] = base::CommandLine::StringType();
 
   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 
   // This shouldn't do anything before ConvertFlagsToSwitches() wasn't called.
   RemoveFlagsSwitches(&switch_list);
   ASSERT_EQ(4u, switch_list.size());
   EXPECT_TRUE(switch_list.find(kSwitch1) != switch_list.end());
   EXPECT_TRUE(switch_list.find(switches::kFlagSwitchesBegin) !=
               switch_list.end());
   EXPECT_TRUE(switch_list.find(switches::kFlagSwitchesEnd) !=
               switch_list.end());
   EXPECT_TRUE(switch_list.find("foo") != switch_list.end());
 
   // Call ConvertFlagsToSwitches(), then RemoveFlagsSwitches() again.
-  CommandLine command_line(CommandLine::NO_PROGRAM);
+  base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitch("foo");
   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
   RemoveFlagsSwitches(&switch_list);
 
   // Now the about:flags-related switch should have been removed.
   ASSERT_EQ(1u, switch_list.size());
   EXPECT_TRUE(switch_list.find("foo") != switch_list.end());
 }
 
 // Tests enabling experiments that aren't supported on the current platform.
 TEST_F(AboutFlagsTest, PersistAndPrune) {
   // Enable experiments 1 and 3.
   SetExperimentEnabled(&flags_storage_, kFlags1, true);
   SetExperimentEnabled(&flags_storage_, kFlags3, true);
-  CommandLine command_line(CommandLine::NO_PROGRAM);
+  base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
   EXPECT_FALSE(command_line.HasSwitch(kSwitch3));
 
   // Convert the flags to switches. Experiment 3 shouldn't be among the switches
   // as it is not applicable to the current platform.
   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
   EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
   EXPECT_FALSE(command_line.HasSwitch(kSwitch3));
 
   // Experiment 3 should show still be persisted in preferences though.
   const base::ListValue* experiments_list =
       prefs_.GetList(prefs::kEnabledLabsExperiments);
   ASSERT_TRUE(experiments_list);
   EXPECT_EQ(2U, experiments_list->GetSize());
   std::string s0;
   ASSERT_TRUE(experiments_list->GetString(0, &s0));
   EXPECT_EQ(kFlags1, s0);
   std::string s1;
   ASSERT_TRUE(experiments_list->GetString(1, &s1));
   EXPECT_EQ(kFlags3, s1);
 }
 
 // Tests that switches which should have values get them in the command
 // line.
 TEST_F(AboutFlagsTest, CheckValues) {
   // Enable experiments 1 and 2.
   SetExperimentEnabled(&flags_storage_, kFlags1, true);
   SetExperimentEnabled(&flags_storage_, kFlags2, true);
-  CommandLine command_line(CommandLine::NO_PROGRAM);
+  base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
   EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
 
   // Convert the flags to switches.
   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
   EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
   EXPECT_EQ(std::string(), command_line.GetSwitchValueASCII(kSwitch1));
   EXPECT_TRUE(command_line.HasSwitch(kSwitch2));
   EXPECT_EQ(std::string(kValueForSwitch2),
             command_line.GetSwitchValueASCII(kSwitch2));
@@ skipping 38 matching lines @@
 }
 
 // Tests multi-value type experiments.
 TEST_F(AboutFlagsTest, MultiValues) {
   const Experiment& experiment = kExperiments[3];
   ASSERT_EQ(kFlags4, experiment.internal_name);
 
   // Initially, the first "deactivated" option of the multi experiment should
   // be set.
   {
-    CommandLine command_line(CommandLine::NO_PROGRAM);
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
   }
 
   // Enable the 2nd choice of the multi-value.
   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
   {
-    CommandLine command_line(CommandLine::NO_PROGRAM);
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_TRUE(command_line.HasSwitch(kMultiSwitch2));
     EXPECT_EQ(std::string(kValueForMultiSwitch2),
               command_line.GetSwitchValueASCII(kMultiSwitch2));
   }
 
   // Disable the multi-value experiment.
   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
   {
-    CommandLine command_line(CommandLine::NO_PROGRAM);
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
   }
 }
 
 TEST_F(AboutFlagsTest, EnableDisableValues) {
   const Experiment& experiment = kExperiments[4];
   ASSERT_EQ(kFlags5, experiment.internal_name);
 
   // Nothing selected.
   {
-    CommandLine command_line(CommandLine::NO_PROGRAM);
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
   }
 
   // "Enable" option selected.
   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(1), true);
   {
-    CommandLine command_line(CommandLine::NO_PROGRAM);
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
     EXPECT_EQ(kEnableDisableValue1, command_line.GetSwitchValueASCII(kSwitch1));
   }
 
   // "Disable" option selected.
   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
   {
-    CommandLine command_line(CommandLine::NO_PROGRAM);
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
     EXPECT_TRUE(command_line.HasSwitch(kSwitch2));
     EXPECT_EQ(kEnableDisableValue2, command_line.GetSwitchValueASCII(kSwitch2));
   }
 
   // "Default" option selected, same as nothing selected.
   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
   {
-    CommandLine command_line(CommandLine::NO_PROGRAM);
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
   }
 }
 
 // Makes sure there are no separators in any of the experiment names.
 TEST_F(AboutFlagsTest, NoSeparators) {
   testing::SetExperiments(NULL, 0);
   size_t count;
@@ skipping 93 matching lines @@
     EXPECT_TRUE(enum_entry != histograms_xml_switches_ids.end() &&
                 enum_entry->first == flag)
         << "histograms.xml enum LoginCustomFlags doesn't contain switch '"
         << flag << "' (value=" << uma_id
         << " expected). Consider adding entry:\n"
         << "  " << GetHistogramEnumEntryText(flag, uma_id);
   }
 }
 
 }  // namespace about_flags