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

chrome/browser/about_flags.cc

 // Copyright (c) 2012 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 "chrome/browser/about_flags.h"
 
 #include <iterator>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 101 matching lines @@
     {kOsAndroid, "Android"},
     {kOsCrOSOwnerOnly, "Chrome OS (owner only)"},
   };
   for (size_t i = 0; i < arraysize(kBitsToOs); ++i) {
     if (bitmask & kBitsToOs[i].bit)
       list->Append(new base::StringValue(kBitsToOs[i].name));
   }
 }
 
 // Convert switch constants to proper CommandLine::StringType strings.
-CommandLine::StringType GetSwitchString(const std::string& flag) {
-  CommandLine cmd_line(CommandLine::NO_PROGRAM);
+base::CommandLine::StringType GetSwitchString(const std::string& flag) {
+  base::CommandLine cmd_line(base::CommandLine::NO_PROGRAM);
   cmd_line.AppendSwitch(flag);
   DCHECK_EQ(2U, cmd_line.argv().size());
   return cmd_line.argv()[1];
 }
 
 // Scoops flags from a command line.
-std::set<CommandLine::StringType> ExtractFlagsFromCommandLine(
-    const CommandLine& cmdline) {
-  std::set<CommandLine::StringType> flags;
+std::set<base::CommandLine::StringType> ExtractFlagsFromCommandLine(
+    const base::CommandLine& cmdline) {
+  std::set<base::CommandLine::StringType> flags;
   // First do the ones between --flag-switches-begin and --flag-switches-end.
-  CommandLine::StringVector::const_iterator first =
+  base::CommandLine::StringVector::const_iterator first =
       std::find(cmdline.argv().begin(), cmdline.argv().end(),
                 GetSwitchString(switches::kFlagSwitchesBegin));
-  CommandLine::StringVector::const_iterator last =
+  base::CommandLine::StringVector::const_iterator last =
       std::find(cmdline.argv().begin(), cmdline.argv().end(),
                 GetSwitchString(switches::kFlagSwitchesEnd));
   if (first != cmdline.argv().end() && last != cmdline.argv().end())
     flags.insert(first + 1, last);
 #if defined(OS_CHROMEOS)
   // Then add those between --policy-switches-begin and --policy-switches-end.
   first = std::find(cmdline.argv().begin(), cmdline.argv().end(),
                     GetSwitchString(chromeos::switches::kPolicySwitchesBegin));
   last = std::find(cmdline.argv().begin(), cmdline.argv().end(),
                    GetSwitchString(chromeos::switches::kPolicySwitchesEnd));
@@ skipping 1946 matching lines @@
 };
 
 const Experiment* experiments = kExperiments;
 size_t num_experiments = arraysize(kExperiments);
 
 // Stores and encapsulates the little state that about:flags has.
 class FlagsState {
  public:
   FlagsState() : needs_restart_(false) {}
   void ConvertFlagsToSwitches(FlagsStorage* flags_storage,
-                              CommandLine* command_line,
+                              base::CommandLine* command_line,
                               SentinelsMode sentinels);
   bool IsRestartNeededToCommitChanges();
   void SetExperimentEnabled(
       FlagsStorage* flags_storage,
       const std::string& internal_name,
       bool enable);
   void RemoveFlagsSwitches(
-      std::map<std::string, CommandLine::StringType>* switch_list);
+      std::map<std::string, base::CommandLine::StringType>* switch_list);
   void ResetAllFlags(FlagsStorage* flags_storage);
   void reset();
 
   // Returns the singleton instance of this class
   static FlagsState* GetInstance() {
     return Singleton<FlagsState>::get();
   }
 
  private:
   bool needs_restart_;
@@ skipping 161 matching lines @@
       IDS_GENERIC_EXPERIMENT_CHOICE_DISABLED,
     };
     description_id = kEnableDisableDescriptionIds[index];
   } else {
     description_id = choices[index].description_id;
   }
   return l10n_util::GetStringUTF16(description_id);
 }
 
 void ConvertFlagsToSwitches(FlagsStorage* flags_storage,
-                            CommandLine* command_line,
+                            base::CommandLine* command_line,
                             SentinelsMode sentinels) {
   FlagsState::GetInstance()->ConvertFlagsToSwitches(flags_storage,
                                                     command_line,
                                                     sentinels);
 }
 
 bool AreSwitchesIdenticalToCurrentCommandLine(
-    const CommandLine& new_cmdline,
-    const CommandLine& active_cmdline,
-    std::set<CommandLine::StringType>* out_difference) {
-  std::set<CommandLine::StringType> new_flags =
+    const base::CommandLine& new_cmdline,
+    const base::CommandLine& active_cmdline,
+    std::set<base::CommandLine::StringType>* out_difference) {
+  std::set<base::CommandLine::StringType> new_flags =
       ExtractFlagsFromCommandLine(new_cmdline);
-  std::set<CommandLine::StringType> active_flags =
+  std::set<base::CommandLine::StringType> active_flags =
       ExtractFlagsFromCommandLine(active_cmdline);
 
   bool result = false;
   // Needed because std::equal doesn't check if the 2nd set is empty.
   if (new_flags.size() == active_flags.size()) {
     result =
         std::equal(new_flags.begin(), new_flags.end(), active_flags.begin());
   }
 
   if (out_difference && !result) {
@@ skipping 67 matching lines @@
 }
 
 void SetExperimentEnabled(FlagsStorage* flags_storage,
                           const std::string& internal_name,
                           bool enable) {
   FlagsState::GetInstance()->SetExperimentEnabled(flags_storage,
                                                   internal_name, enable);
 }
 
 void RemoveFlagsSwitches(
-    std::map<std::string, CommandLine::StringType>* switch_list) {
+    std::map<std::string, base::CommandLine::StringType>* switch_list) {
   FlagsState::GetInstance()->RemoveFlagsSwitches(switch_list);
 }
 
 void ResetAllFlags(FlagsStorage* flags_storage) {
   FlagsState::GetInstance()->ResetAllFlags(flags_storage);
 }
 
 int GetCurrentPlatform() {
 #if defined(OS_MACOSX)
   return kOsMac;
@@ skipping 66 matching lines @@
 
 void SetFlagToSwitchMapping(const std::string& key,
                             const std::string& switch_name,
                             const std::string& switch_value,
                             NameToSwitchAndValueMap* name_to_switch_map) {
   DCHECK(name_to_switch_map->end() == name_to_switch_map->find(key));
   (*name_to_switch_map)[key] = std::make_pair(switch_name, switch_value);
 }
 
 void FlagsState::ConvertFlagsToSwitches(FlagsStorage* flags_storage,
-                                        CommandLine* command_line,
+                                        base::CommandLine* command_line,
                                         SentinelsMode sentinels) {
   if (command_line->HasSwitch(switches::kNoExperiments))
     return;
 
   std::set<std::string> enabled_experiments;
 
   GetSanitizedEnabledFlagsForCurrentPlatform(flags_storage,
                                              &enabled_experiments);
 
   NameToSwitchAndValueMap name_to_switch_map;
@@ skipping 117 matching lines @@
           // experiment for this choice was enabled.
         }
       }
     }
   }
 
   flags_storage->SetFlags(enabled_experiments);
 }
 
 void FlagsState::RemoveFlagsSwitches(
-    std::map<std::string, CommandLine::StringType>* switch_list) {
+    std::map<std::string, base::CommandLine::StringType>* switch_list) {
   for (const auto& entry : flags_switches_)
     switch_list->erase(entry.first);
 }
 
 void FlagsState::ResetAllFlags(FlagsStorage* flags_storage) {
   needs_restart_ = true;
 
   std::set<std::string> no_experiments;
   flags_storage->SetFlags(no_experiments);
 }
@@ skipping 28 matching lines @@
 }
 
 const Experiment* GetExperiments(size_t* count) {
   *count = num_experiments;
   return experiments;
 }
 
 }  // namespace testing
 
 }  // namespace about_flags