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

chrome/browser/chromeos/login/session/user_session_manager.cc

 // Copyright 2014 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/chromeos/login/session/user_session_manager.h"
 
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 185 matching lines @@
 // Callback to GetNSSCertDatabaseForProfile. It starts CertLoader using the
 // provided NSS database. It must be called for primary user only.
 void OnGetNSSCertDatabaseForUser(net::NSSCertDatabase* database) {
   if (!CertLoader::IsInitialized())
     return;
 
   CertLoader::Get()->StartWithNSSDB(database);
 }
 
 // Returns new CommandLine with per-user flags.
-CommandLine CreatePerSessionCommandLine(Profile* profile) {
-  CommandLine user_flags(CommandLine::NO_PROGRAM);
+base::CommandLine CreatePerSessionCommandLine(Profile* profile) {
+  base::CommandLine user_flags(base::CommandLine::NO_PROGRAM);
   about_flags::PrefServiceFlagsStorage flags_storage_(profile->GetPrefs());
   about_flags::ConvertFlagsToSwitches(&flags_storage_, &user_flags,
                                       about_flags::kAddSentinels);
   return user_flags;
 }
 
 // Returns true if restart is needed to apply per-session flags.
 bool NeedRestartToApplyPerSessionFlags(
-    const CommandLine& user_flags,
-    std::set<CommandLine::StringType>* out_command_line_difference) {
+    const base::CommandLine& user_flags,
+    std::set<base::CommandLine::StringType>* out_command_line_difference) {
   // Don't restart browser if it is not first profile in session.
   if (user_manager::UserManager::Get()->GetLoggedInUsers().size() != 1)
     return false;
 
   // Only restart if needed and if not going into managed mode.
   if (user_manager::UserManager::Get()->IsLoggedInAsSupervisedUser())
     return false;
 
   if (about_flags::AreSwitchesIdenticalToCurrentCommandLine(
-          user_flags, *CommandLine::ForCurrentProcess(),
+          user_flags, *base::CommandLine::ForCurrentProcess(),
           out_command_line_difference)) {
     return false;
   }
 
   return true;
 }
 
 bool CanPerformEarlyRestart() {
   // Desktop build is used for development only. Early restart is not supported.
   if (!base::SysInfo::IsRunningOnChromeOS())
@@ skipping 97 matching lines @@
   if (user_manager::UserManager::IsInitialized())
     user_manager::UserManager::Get()->RemoveSessionStateObserver(this);
   net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
 }
 
 void UserSessionManager::CompleteGuestSessionLogin(const GURL& start_url) {
   VLOG(1) << "Completing guest session login";
 
   // For guest session we ask session_manager to restart Chrome with --bwsi
   // flag. We keep only some of the arguments of this process.
-  const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
-  CommandLine command_line(browser_command_line.GetProgram());
+  const base::CommandLine& browser_command_line =
+      *base::CommandLine::ForCurrentProcess();
+  base::CommandLine command_line(browser_command_line.GetProgram());
   std::string cmd_line_str =
       GetOffTheRecordCommandLine(start_url,
                                  StartupUtils::IsOobeCompleted(),
                                  browser_command_line,
                                  &command_line);
 
   // This makes sure that Chrome restarts with no per-session flags. The guest
   // profile will always have empty set of per-session flags. If this is not
   // done and device owner has some per-session flags, when Chrome is relaunched
   // the guest profile session flags will not match the current command line and
   // another restart will be attempted in order to reset the user flags for the
   // guest user.
-  const CommandLine user_flags(CommandLine::NO_PROGRAM);
+  const base::CommandLine user_flags(base::CommandLine::NO_PROGRAM);
   if (!about_flags::AreSwitchesIdenticalToCurrentCommandLine(
-           user_flags,
-           *CommandLine::ForCurrentProcess(),
-           NULL)) {
+          user_flags, *base::CommandLine::ForCurrentProcess(), NULL)) {
     DBusThreadManager::Get()->GetSessionManagerClient()->SetFlagsForUser(
-        chromeos::login::kGuestUserName,
-        CommandLine::StringVector());
+        chromeos::login::kGuestUserName, base::CommandLine::StringVector());
   }
 
   RestartChrome(cmd_line_str);
 }
 
 void UserSessionManager::StartSession(
     const UserContext& user_context,
     StartSessionType start_session_type,
     scoped_refptr<Authenticator> authenticator,
     bool has_auth_cookies,
@@ skipping 204 matching lines @@
 
 bool UserSessionManager::RestartToApplyPerSessionFlagsIfNeed(
     Profile* profile,
     bool early_restart) {
   if (ProfileHelper::IsSigninProfile(profile))
     return false;
 
   if (early_restart && !CanPerformEarlyRestart())
     return false;
 
-  const CommandLine user_flags(CreatePerSessionCommandLine(profile));
-  std::set<CommandLine::StringType> command_line_difference;
+  const base::CommandLine user_flags(CreatePerSessionCommandLine(profile));
+  std::set<base::CommandLine::StringType> command_line_difference;
   if (!NeedRestartToApplyPerSessionFlags(user_flags, &command_line_difference))
     return false;
 
   LogCustomSwitches(command_line_difference);
 
   about_flags::ReportCustomFlags("Login.CustomFlags", command_line_difference);
 
   CommandLine::StringVector flags;
-  // argv[0] is the program name |CommandLine::NO_PROGRAM|.
+  // argv[0] is the program name |base::CommandLine::NO_PROGRAM|.
   flags.assign(user_flags.argv().begin() + 1, user_flags.argv().end());
   LOG(WARNING) << "Restarting to apply per-session flags...";
   DBusThreadManager::Get()->GetSessionManagerClient()->SetFlagsForUser(
       user_manager::UserManager::Get()->GetActiveUser()->email(), flags);
   AttemptRestart(profile);
   return true;
 }
 
 bool UserSessionManager::NeedsToUpdateEasyUnlockKeys() const {
   return EasyUnlockService::IsSignInEnabled() &&
@@ skipping 109 matching lines @@
       login_manager->ContinueSessionRestore();
     } else if (should_restore_session) {
       pending_signin_restore_sessions_.erase((*it)->email());
       RestoreAuthSessionImpl(user_profile, false /* has_auth_cookies */);
     }
   }
 }
 
 void UserSessionManager::OnProfilePrepared(Profile* profile,
                                            bool browser_launched) {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(::switches::kTestName)) {
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          ::switches::kTestName)) {
     // Did not log in (we crashed or are debugging), need to restore Sync.
     // TODO(nkostylev): Make sure that OAuth state is restored correctly for all
     // users once it is fully multi-profile aware. http://crbug.com/238987
     // For now if we have other user pending sessions they'll override OAuth
     // session restore for previous users.
     RestoreAuthenticationSession(profile);
   }
 
   // Restore other user sessions if any.
   RestorePendingUserSessions();
 }
 
 void UserSessionManager::CreateUserSession(const UserContext& user_context,
                                            bool has_auth_cookies) {
   user_context_ = user_context;
   has_auth_cookies_ = has_auth_cookies;
   InitSessionRestoreStrategy();
 }
 
 void UserSessionManager::PreStartSession() {
   // Switch log file as soon as possible.
   if (base::SysInfo::IsRunningOnChromeOS())
-    logging::RedirectChromeLogging(*(CommandLine::ForCurrentProcess()));
+    logging::RedirectChromeLogging(*(base::CommandLine::ForCurrentProcess()));
 }
 
 void UserSessionManager::StartCrosSession() {
   BootTimesLoader* btl = BootTimesLoader::Get();
   btl->AddLoginTimeMarker("StartSession-Start", false);
   DBusThreadManager::Get()->GetSessionManagerClient()->
       StartSession(user_context_.GetUserID());
   btl->AddLoginTimeMarker("StartSession-End", false);
 }
 
@@ skipping 253 matching lines @@
     }
   }
 
   // Only show getting started guide for a new user.
   const bool should_show_getstarted_guide = user_manager->IsCurrentUserNew();
 
   if (can_show_getstarted_guide && should_show_getstarted_guide) {
     // Don't open default Chrome window if we're going to launch the first-run
     // app. Because we dont' want the first-run app to be hidden in the
     // background.
-    CommandLine::ForCurrentProcess()->AppendSwitch(::switches::kSilentLaunch);
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        ::switches::kSilentLaunch);
     first_run::MaybeLaunchDialogAfterSessionStart();
   } else {
     for (size_t i = 0; i < start_urls.size(); ++i) {
-      CommandLine::ForCurrentProcess()->AppendArg(start_urls[i]);
+      base::CommandLine::ForCurrentProcess()->AppendArg(start_urls[i]);
     }
   }
 }
 
 bool UserSessionManager::InitializeUserSession(Profile* profile) {
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
 
   // Kiosk apps has their own session initialization pipeline.
   if (user_manager->IsLoggedInAsKioskApp())
     return false;
 
   if (start_session_type_ == PRIMARY_USER_SESSION) {
     UserFlow* user_flow = ChromeUserManager::Get()->GetCurrentUserFlow();
     WizardController* oobe_controller = WizardController::default_controller();
-    base::CommandLine* cmdline = CommandLine::ForCurrentProcess();
+    base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
     bool skip_post_login_screens =
         user_flow->ShouldSkipPostLoginScreens() ||
         (oobe_controller && oobe_controller->skip_post_login_screens()) ||
         cmdline->HasSwitch(chromeos::switches::kOobeSkipPostLogin);
 
     if (user_manager->IsCurrentUserNew() && !skip_post_login_screens) {
       // Don't specify start URLs if the administrator has configured the start
       // URLs via policy.
       if (!SessionStartupPref::TypeIsManaged(profile->GetPrefs()))
         InitializeStartUrls();
 
       // Mark the device as registered., i.e. the second part of OOBE as
       // completed.
       if (!StartupUtils::IsDeviceRegistered())
         StartupUtils::MarkDeviceRegistered(base::Closure());
 
       ActivateWizard(WizardController::kTermsOfServiceScreenName);
       return false;
     }
   }
 
   LoginUtils::Get()->DoBrowserLaunch(profile,
                                      LoginDisplayHostImpl::default_host());
   return true;
 }
 
 void UserSessionManager::InitSessionRestoreStrategy() {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   bool in_app_mode = chrome::IsRunningInForcedAppMode();
 
   // Are we in kiosk app mode?
   if (in_app_mode) {
     if (command_line->HasSwitch(::switches::kAppModeOAuth2Token)) {
       oauth2_refresh_token_ = command_line->GetSwitchValueASCII(
           ::switches::kAppModeOAuth2Token);
     }
 
     if (command_line->HasSwitch(::switches::kAppModeAuthCode)) {
@@ skipping 24 matching lines @@
   }
 }
 
 void UserSessionManager::RestoreAuthSessionImpl(
     Profile* profile,
     bool restore_from_auth_cookies) {
   CHECK((authenticator_.get() && authenticator_->authentication_context()) ||
         !restore_from_auth_cookies);
 
   if (chrome::IsRunningInForcedAppMode() ||
-      CommandLine::ForCurrentProcess()->HasSwitch(
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kDisableGaiaServices)) {
     return;
   }
 
   exit_after_session_restore_ = false;
 
   // Remove legacy OAuth1 token if we have one. If it's valid, we should already
   // have OAuth2 refresh token in OAuth2TokenService that could be used to
   // retrieve all other tokens and user_context.
   OAuth2LoginManager* login_manager =
@@ skipping 301 matching lines @@
 #if defined(USE_ATHENA)
   athena::StartAthenaSessionWithContext(profile);
 #else
   StartupBrowserCreator browser_creator;
   int return_code;
   chrome::startup::IsFirstRun first_run =
       ::first_run::IsChromeFirstRun() ? chrome::startup::IS_FIRST_RUN
                                       : chrome::startup::IS_NOT_FIRST_RUN;
 
   browser_creator.LaunchBrowser(
-      *CommandLine::ForCurrentProcess(), profile, base::FilePath(),
+      *base::CommandLine::ForCurrentProcess(), profile, base::FilePath(),
       chrome::startup::IS_PROCESS_STARTUP, first_run, &return_code);
 
   // Triggers app launcher start page service to load start page web contents.
   app_list::StartPageService::Get(profile);
 #endif
 
   // Mark login host for deletion after browser starts.  This
   // guarantees that the message loop will be referenced by the
   // browser before it is dereferenced by the login host.
   if (login_host)
@@ skipping 26 matching lines @@
     InputEventsBlocker* /* input_events_blocker */,
     const locale_util::LanguageSwitchResult& /* result */) {
   callback.Run();
 }
 
 void UserSessionManager::RemoveProfileForTesting(Profile* profile) {
   default_ime_states_.erase(profile);
 }
 
 }  // namespace chromeos