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

chrome/browser/ui/startup/startup_browser_creator.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/ui/startup/startup_browser_creator.h"
 
 #include <algorithm>   // For max().
 #include <set>
 
 #include "apps/app_load_service.h"
@@ skipping 254 matching lines @@
 void StartupBrowserCreator::AddFirstRunTab(const GURL& url) {
   first_run_tabs_.push_back(url);
 }
 
 // static
 bool StartupBrowserCreator::InSynchronousProfileLaunch() {
   return in_synchronous_profile_launch_;
 }
 
 bool StartupBrowserCreator::LaunchBrowser(
-    const CommandLine& command_line,
+    const base::CommandLine& command_line,
     Profile* profile,
     const base::FilePath& cur_dir,
     chrome::startup::IsProcessStartup process_startup,
     chrome::startup::IsFirstRun is_first_run,
     int* return_code) {
-
   in_synchronous_profile_launch_ =
       process_startup == chrome::startup::IS_PROCESS_STARTUP;
   DCHECK(profile);
 
   // Continue with the incognito profile from here on if Incognito mode
   // is forced.
   if (IncognitoModePrefs::ShouldLaunchIncognito(command_line,
                                                 profile->GetPrefs())) {
     profile = profile->GetOffTheRecordProfile();
   } else if (command_line.HasSwitch(switches::kIncognito)) {
@@ skipping 54 matching lines @@
     PrefService* pref_service = g_browser_process->local_state();
     was_restarted = pref_service->GetBoolean(prefs::kWasRestarted);
     pref_service->SetBoolean(prefs::kWasRestarted, false);
     was_restarted_read_ = true;
   }
   return was_restarted;
 }
 
 // static
 SessionStartupPref StartupBrowserCreator::GetSessionStartupPref(
-    const CommandLine& command_line,
+    const base::CommandLine& command_line,
     Profile* profile) {
   DCHECK(profile);
   PrefService* prefs = profile->GetPrefs();
   SessionStartupPref pref = SessionStartupPref::GetStartupPref(prefs);
 
   // IsChromeFirstRun() looks for a sentinel file to determine whether the user
   // is starting Chrome for the first time. On Chrome OS, the sentinel is stored
   // in a location shared by all users and the check is meaningless. Query the
   // UserManager instead to determine whether the user is new.
 #if defined(OS_CHROMEOS)
@@ skipping 49 matching lines @@
   return pref;
 }
 
 // static
 void StartupBrowserCreator::ClearLaunchedProfilesForTesting() {
   profile_launch_observer.Get().Clear();
 }
 
 // static
 std::vector<GURL> StartupBrowserCreator::GetURLsFromCommandLine(
-    const CommandLine& command_line,
+    const base::CommandLine& command_line,
     const base::FilePath& cur_dir,
     Profile* profile) {
   std::vector<GURL> urls;
 
-  const CommandLine::StringVector& params = command_line.GetArgs();
+  const base::CommandLine::StringVector& params = command_line.GetArgs();
   for (size_t i = 0; i < params.size(); ++i) {
     base::FilePath param = base::FilePath(params[i]);
     // Handle Vista way of searching - "? <search-term>"
     if ((param.value().size() > 2) && (param.value()[0] == '?') &&
         (param.value()[1] == ' ')) {
       GURL url(GetDefaultSearchURLForSearchTerms(
           TemplateURLServiceFactory::GetForProfile(profile),
           param.LossyDisplayName().substr(2)));
       if (url.is_valid()) {
         urls.push_back(url);
@@ skipping 32 matching lines @@
           (url.spec().compare(url::kAboutBlankURL) == 0)) {
         urls.push_back(url);
       }
     }
   }
   return urls;
 }
 
 // static
 bool StartupBrowserCreator::ProcessCmdLineImpl(
-    const CommandLine& command_line,
+    const base::CommandLine& command_line,
     const base::FilePath& cur_dir,
     bool process_startup,
     Profile* last_used_profile,
     const Profiles& last_opened_profiles,
     int* return_code,
     StartupBrowserCreator* browser_creator) {
   VLOG(2) << "ProcessCmdLineImpl : BEGIN";
   DCHECK(last_used_profile);
   if (process_startup) {
     if (command_line.HasSwitch(switches::kDisablePromptOnRepost))
@@ skipping 129 matching lines @@
     // background page of apps. Tracked at http://crbug.com/175381
     if (chrome::GetTotalBrowserCountForProfile(last_used_profile) != 0)
       return true;
   }
 
   VLOG(2) << "ProcessCmdLineImpl: PLACE 4.B";
   // Check for --load-and-launch-app.
   if (command_line.HasSwitch(apps::kLoadAndLaunchApp) &&
       !IncognitoModePrefs::ShouldLaunchIncognito(
           command_line, last_used_profile->GetPrefs())) {
-    CommandLine::StringType path = command_line.GetSwitchValueNative(
-        apps::kLoadAndLaunchApp);
+    base::CommandLine::StringType path =
+        command_line.GetSwitchValueNative(apps::kLoadAndLaunchApp);
 
     if (!apps::AppLoadService::Get(last_used_profile)->LoadAndLaunch(
             base::FilePath(path), command_line, cur_dir)) {
       return false;
     }
 
     // Return early here since we don't want to open a browser window.
     // The exception is when there are no browser windows, since we don't want
     // chrome to shut down.
     // TODO(jackhou): Do this properly once keep-alive is handled by the
@@ skipping 81 matching lines @@
     // when Chrome was closed. In this case, pick a different open profile
     // to be the active one, since the Guest profile is never added to the list
     // of open profiles.
     if (switches::IsNewAvatarMenu() && last_used_profile->IsGuestSession()) {
       DCHECK(!last_opened_profiles[0]->IsGuestSession());
       last_used_profile = last_opened_profiles[0];
     }
 
     // Launch the last used profile with the full command line, and the other
     // opened profiles without the URLs to launch.
-    CommandLine command_line_without_urls(command_line.GetProgram());
-    const CommandLine::SwitchMap& switches = command_line.GetSwitches();
-    for (CommandLine::SwitchMap::const_iterator switch_it = switches.begin();
+    base::CommandLine command_line_without_urls(command_line.GetProgram());
+    const base::CommandLine::SwitchMap& switches = command_line.GetSwitches();
+    for (base::CommandLine::SwitchMap::const_iterator switch_it =
+             switches.begin();
          switch_it != switches.end(); ++switch_it) {
       command_line_without_urls.AppendSwitchNative(switch_it->first,
                                                    switch_it->second);
     }
     VLOG(2) << "ProcessCmdLineImpl: PLACE 7.B";
     // Launch the profiles in the order they became active.
     for (Profiles::const_iterator it = last_opened_profiles.begin();
          it != last_opened_profiles.end(); ++it) {
       DCHECK(!(*it)->IsGuestSession());
       // Don't launch additional profiles which would only open a new tab
@@ skipping 16 matching lines @@
     VLOG(2) << "ProcessCmdLineImpl: PLACE 8.B";
     // This must be done after all profiles have been launched so the observer
     // knows about all profiles to wait for before activating this one.
     profile_launch_observer.Get().set_profile_to_activate(last_used_profile);
   }
   VLOG(2) << "ProcessCmdLineImpl: END";
   return true;
 }
 
 // static
-bool StartupBrowserCreator::ProcessLoadApps(const CommandLine& command_line,
-                                            const base::FilePath& cur_dir,
-                                            Profile* profile) {
-  CommandLine::StringType path_list =
+bool StartupBrowserCreator::ProcessLoadApps(
+    const base::CommandLine& command_line,
+    const base::FilePath& cur_dir,
+    Profile* profile) {
+  base::CommandLine::StringType path_list =
       command_line.GetSwitchValueNative(extensions::switches::kLoadApps);
 
-  base::StringTokenizerT<CommandLine::StringType,
-                         CommandLine::StringType::const_iterator>
+  base::StringTokenizerT<base::CommandLine::StringType,
+                         base::CommandLine::StringType::const_iterator>
       tokenizer(path_list, FILE_PATH_LITERAL(","));
 
   if (!tokenizer.GetNext())
     return false;
 
   base::FilePath app_absolute_dir =
       base::MakeAbsoluteFilePath(base::FilePath(tokenizer.token()));
   if (!apps::AppLoadService::Get(profile)->LoadAndLaunch(
           app_absolute_dir, command_line, cur_dir)) {
     return false;
   }
 
   while (tokenizer.GetNext()) {
     app_absolute_dir =
         base::MakeAbsoluteFilePath(base::FilePath(tokenizer.token()));
 
     if (!apps::AppLoadService::Get(profile)->Load(app_absolute_dir)) {
       return false;
     }
   }
 
   return true;
 }
 
 // static
 void StartupBrowserCreator::ProcessCommandLineOnProfileCreated(
-    const CommandLine& command_line,
+    const base::CommandLine& command_line,
     const base::FilePath& cur_dir,
     Profile* profile,
     Profile::CreateStatus status) {
   if (status == Profile::CREATE_STATUS_INITIALIZED)
     ProcessCmdLineImpl(command_line, cur_dir, false, profile, Profiles(), NULL,
                        NULL);
 }
 
 // static
 void StartupBrowserCreator::ProcessCommandLineAlreadyRunning(
-    const CommandLine& command_line,
+    const base::CommandLine& command_line,
     const base::FilePath& cur_dir,
     const base::FilePath& profile_path) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   Profile* profile = profile_manager->GetProfileByPath(profile_path);
 
   // The profile isn't loaded yet and so needs to be loaded asynchronously.
   if (!profile) {
     profile_manager->CreateProfileAsync(profile_path,
         base::Bind(&StartupBrowserCreator::ProcessCommandLineOnProfileCreated,
                    command_line, cur_dir), base::string16(), base::string16(),
                    std::string());
     return;
   }
 
   ProcessCmdLineImpl(command_line, cur_dir, false, profile, Profiles(), NULL,
                      NULL);
 }
 
 // static
 bool StartupBrowserCreator::ActivatedProfile() {
   return profile_launch_observer.Get().activated_profile();
 }
 
 bool HasPendingUncleanExit(Profile* profile) {
   return profile->GetLastSessionExitType() == Profile::EXIT_CRASHED &&
       !profile_launch_observer.Get().HasBeenLaunched(profile);
 }
 
 base::FilePath GetStartupProfilePath(const base::FilePath& user_data_dir,
-                                     const CommandLine& command_line) {
+                                     const base::CommandLine& command_line) {
   if (command_line.HasSwitch(switches::kProfileDirectory)) {
     return user_data_dir.Append(
         command_line.GetSwitchValuePath(switches::kProfileDirectory));
   }
 
   // If we are showing the app list then chrome isn't shown so load the app
   // list's profile rather than chrome's.
   if (command_line.HasSwitch(switches::kShowAppList)) {
     return AppListService::Get(chrome::HOST_DESKTOP_TYPE_NATIVE)->
         GetProfilePath(user_data_dir);
   }
 
   return g_browser_process->profile_manager()->GetLastUsedProfileDir(
       user_data_dir);
 }