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

chrome/browser/component_updater/recovery_component_installer.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/component_updater/recovery_component_installer.h"
 
 #include <stdint.h>
 #include <string>
 
 #include "base/base_paths.h"
@@ skipping 44 matching lines @@
 enum ChromeRecoveryExitCode {
   EXIT_CODE_RECOVERY_SUCCEEDED = 0,
   EXIT_CODE_RECOVERY_SKIPPED = 1,
   EXIT_CODE_ELEVATION_NEEDED = 2,
 };
 
 #if !defined(OS_CHROMEOS)
 // Checks if elevated recovery simulation switch was present on the command
 // line. This is for testing purpose.
 bool SimulatingElevatedRecovery() {
-  return CommandLine::ForCurrentProcess()->
-      HasSwitch(switches::kSimulateElevatedRecovery);
+  return base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kSimulateElevatedRecovery);
 }
 #endif
 
 #if defined(OS_WIN)
 scoped_ptr<base::DictionaryValue> ReadManifest(const base::FilePath& manifest) {
   JSONFileValueSerializer serializer(manifest);
   std::string error;
   scoped_ptr<base::Value> root(serializer.Deserialize(NULL, &error));
   if (root.get() && root->IsType(base::Value::TYPE_DICTIONARY)) {
     return scoped_ptr<base::DictionaryValue>(
@@ skipping 13 matching lines @@
   std::string name;
   manifest->GetStringASCII("name", &name);
   if (name != kRecoveryManifestName)
     return;
   std::string proposed_version;
   manifest->GetStringASCII("version", &proposed_version);
   const Version version(proposed_version.c_str());
   if (!version.IsValid())
     return;
 
-  CommandLine cmdline(main_file);
+  base::CommandLine cmdline(main_file);
   std::string arguments;
   if (manifest->GetStringASCII("x-recovery-args", &arguments))
     cmdline.AppendArg(arguments);
   std::string add_version;
   if (manifest->GetStringASCII("x-recovery-add-version", &add_version) &&
       add_version == "yes") {
     cmdline.AppendSwitchASCII("version", version.GetString());
   }
 
   base::LaunchOptions options;
@@ skipping 27 matching lines @@
 
   void OnUpdateError(int error) override;
 
   bool Install(const base::DictionaryValue& manifest,
                const base::FilePath& unpack_path) override;
 
   bool GetInstalledFile(const std::string& file,
                         base::FilePath* installed_file) override;
 
  private:
-  bool RunInstallCommand(const CommandLine& cmdline,
+  bool RunInstallCommand(const base::CommandLine& cmdline,
                          const base::FilePath& installer_folder) const;
 
   Version current_version_;
   PrefService* prefs_;
 };
 
 void SimulateElevatedRecoveryHelper(PrefService* prefs) {
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, true);
 }
 
@@ skipping 51 matching lines @@
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&SetPrefsForElevatedRecoveryInstall,
                    installer_folder,
                    prefs));
   }
   base::CloseProcessHandle(process_handle);
 }
 
 bool RecoveryComponentInstaller::RunInstallCommand(
-    const CommandLine& cmdline, const base::FilePath& installer_folder) const {
+    const base::CommandLine& cmdline,
+    const base::FilePath& installer_folder) const {
   base::ProcessHandle process_handle;
   base::LaunchOptions options;
   options.start_hidden = true;
   if (!base::LaunchProcess(cmdline, options, &process_handle))
     return false;
 
   // Let worker pool thread wait for us so we don't block Chrome shutdown.
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&WaitForInstallToComplete,
                  process_handle, installer_folder, prefs_),
       true);
 
   // Returns true regardless of install result since from updater service
   // perspective the install is done, even we may need to do elevated
   // install later.
   return true;
 }
 #else
 bool RecoveryComponentInstaller::RunInstallCommand(
-    const CommandLine& cmdline, const base::FilePath&) const {
+    const base::CommandLine& cmdline,
+    const base::FilePath&) const {
   return base::LaunchProcess(cmdline, base::LaunchOptions(), NULL);
 }
 #endif
 
 bool RecoveryComponentInstaller::Install(const base::DictionaryValue& manifest,
                                          const base::FilePath& unpack_path) {
   std::string name;
   manifest.GetStringASCII("name", &name);
   if (name != kRecoveryManifestName)
     return false;
@@ skipping 16 matching lines @@
     return false;
   if (!base::Move(unpack_path, path)) {
     DVLOG(1) << "Recovery component move failed.";
     return false;
   }
 
   base::FilePath main_file = path.Append(kRecoveryFileName);
   if (!base::PathExists(main_file))
     return false;
   // Run the recovery component.
-  CommandLine cmdline(main_file);
+  base::CommandLine cmdline(main_file);
   std::string arguments;
   if (manifest.GetStringASCII("x-recovery-args", &arguments))
     cmdline.AppendArg(arguments);
   std::string add_version;
   if (manifest.GetStringASCII("x-recovery-add-version", &add_version) &&
       add_version == "yes") {
     cmdline.AppendSwitchASCII("version", current_version_.GetString());
   }
 
   if (!RunInstallCommand(cmdline, path)) {
@@ skipping 52 matching lines @@
 #endif
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, false);
 }
 
 void DeclinedElevatedRecoveryInstall(PrefService* prefs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   prefs->SetBoolean(prefs::kRecoveryComponentNeedsElevation, false);
 }
 
 }  // namespace component_updater