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

chrome/browser/shell_integration_linux.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/shell_integration_linux.h"
 
 #include <fcntl.h>
 
 #if defined(USE_GLIB)
 #include <glib.h>
@@ skipping 273 matching lines @@
   }
   quoted += '"';
 
   return quoted;
 }
 
 // Quote a command line so it is suitable for use as the Exec key in a desktop
 // file. Note: This should be used instead of GetCommandLineString, which does
 // not properly quote the string; this function is designed for the Exec key.
 std::string QuoteCommandLineForDesktopFileExec(
-    const CommandLine& command_line) {
+    const base::CommandLine& command_line) {
   // http://standards.freedesktop.org/desktop-entry-spec/latest/ar01s06.html
 
   std::string quoted_path = "";
-  const CommandLine::StringVector& argv = command_line.argv();
-  for (CommandLine::StringVector::const_iterator i = argv.begin();
+  const base::CommandLine::StringVector& argv = command_line.argv();
+  for (base::CommandLine::StringVector::const_iterator i = argv.begin();
        i != argv.end(); ++i) {
     if (i != argv.begin())
       quoted_path += " ";
     quoted_path += QuoteArgForDesktopFileExec(*i);
   }
 
   return quoted_path;
 }
 
 const char kDesktopEntry[] = "Desktop Entry";
@@ skipping 26 matching lines @@
     return false;
 
   base::FilePath chrome_version_path = chrome_dir.Append(script);
   *chrome_version = chrome_version_path.value();
 
   // Check if this is different to the one on path.
   std::vector<std::string> argv;
   argv.push_back("which");
   argv.push_back(script);
   std::string path_version;
-  if (base::GetAppOutput(CommandLine(argv), &path_version)) {
+  if (base::GetAppOutput(base::CommandLine(argv), &path_version)) {
     // Remove trailing newline
     path_version.erase(path_version.length() - 1, 1);
     base::FilePath path_version_path(path_version);
     return (chrome_version_path != path_version_path);
   }
   return false;
 }
 
 // Value returned by xdg-settings if it can't understand our request.
 const int EXIT_XDG_SETTINGS_SYNTAX_ERROR = 1;
@@ skipping 57 matching lines @@
   if (protocol.empty()) {
     argv.push_back(kXdgSettingsDefaultBrowser);
   } else {
     argv.push_back(kXdgSettingsDefaultSchemeHandler);
     argv.push_back(protocol);
   }
   argv.push_back(shell_integration_linux::GetDesktopName(env.get()));
 
   std::string reply;
   int success_code;
-  bool ran_ok = base::GetAppOutputWithExitCode(CommandLine(argv), &reply,
+  bool ran_ok = base::GetAppOutputWithExitCode(base::CommandLine(argv), &reply,
                                                &success_code);
   if (ran_ok && success_code == EXIT_XDG_SETTINGS_SYNTAX_ERROR) {
     if (GetChromeVersionOfScript(kXdgSettings, &argv[0])) {
-      ran_ok = base::GetAppOutputWithExitCode(CommandLine(argv), &reply,
+      ran_ok = base::GetAppOutputWithExitCode(base::CommandLine(argv), &reply,
                                               &success_code);
     }
   }
 
   if (!ran_ok || success_code != EXIT_SUCCESS) {
     // xdg-settings failed: we can't determine or set the default browser.
     return ShellIntegration::UNKNOWN_DEFAULT;
   }
 
   // Allow any reply that starts with "yes".
@@ skipping 95 matching lines @@
 
 // static
 bool ShellIntegration::IsFirefoxDefaultBrowser() {
   std::vector<std::string> argv;
   argv.push_back(kXdgSettings);
   argv.push_back("get");
   argv.push_back(kXdgSettingsDefaultBrowser);
 
   std::string browser;
   // We don't care about the return value here.
-  base::GetAppOutput(CommandLine(argv), &browser);
+  base::GetAppOutput(base::CommandLine(argv), &browser);
   return browser.find("irefox") != std::string::npos;
 }
 
 namespace shell_integration_linux {
 
 bool GetDataWriteLocation(base::Environment* env, base::FilePath* search_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   std::string xdg_data_home;
   std::string home;
@@ skipping 25 matching lines @@
     }
   } else {
     search_paths.push_back(base::FilePath("/usr/local/share"));
     search_paths.push_back(base::FilePath("/usr/share"));
   }
 
   return search_paths;
 }
 
 std::string GetProgramClassName() {
-  DCHECK(CommandLine::InitializedForCurrentProcess());
+  DCHECK(base::CommandLine::InitializedForCurrentProcess());
   // Get the res_name component from argv[0].
-  const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
   std::string class_name = command_line->GetProgram().BaseName().value();
   if (!class_name.empty())
     class_name[0] = base::ToUpperASCII(class_name[0]);
   return class_name;
 }
 
 std::string GetDesktopName(base::Environment* env) {
 #if defined(GOOGLE_CHROME_BUILD)
   chrome::VersionInfo::Channel product_channel(
       chrome::VersionInfo::GetChannel());
@@ skipping 158 matching lines @@
 std::string GetDesktopFileContents(
     const base::FilePath& chrome_exe_path,
     const std::string& app_name,
     const GURL& url,
     const std::string& extension_id,
     const base::string16& title,
     const std::string& icon_name,
     const base::FilePath& profile_path,
     const std::string& categories,
     bool no_display) {
-  CommandLine cmd_line = ShellIntegration::CommandLineArgsForLauncher(
-      url, extension_id, profile_path);
+  base::CommandLine cmd_line =
+      ShellIntegration::CommandLineArgsForLauncher(url, extension_id,
+                                                   profile_path);
   cmd_line.SetProgram(chrome_exe_path);
   return GetDesktopFileContentsForCommand(cmd_line, app_name, url, title,
                                           icon_name, categories, no_display);
 }
 
 std::string GetDesktopFileContentsForCommand(
-    const CommandLine& command_line,
+    const base::CommandLine& command_line,
     const std::string& app_name,
     const GURL& url,
     const base::string16& title,
     const std::string& icon_name,
     const std::string& categories,
     bool no_display) {
 #if defined(USE_GLIB)
   // Although not required by the spec, Nautilus on Ubuntu Karmic creates its
   // launchers with an xdg-open shebang. Follow that convention.
   std::string output_buffer = std::string(kXdgOpenShebang) + "\n";
@@ skipping 218 matching lines @@
   }
 
   gfx::ImageFamily icon_images;
   ResourceBundle& resource_bundle = ResourceBundle::GetSharedInstance();
   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_16));
   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_32));
   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_48));
   icon_images.Add(*resource_bundle.GetImageSkiaNamed(IDR_APP_LIST_256));
   std::string icon_name = CreateShortcutIcon(icon_images, desktop_name);
 
-  CommandLine command_line(chrome_exe_path);
+  base::CommandLine command_line(chrome_exe_path);
   command_line.AppendSwitch(switches::kShowAppList);
   std::string contents =
       GetDesktopFileContentsForCommand(command_line,
                                        wm_class,
                                        GURL(),
                                        base::UTF8ToUTF16(title),
                                        icon_name,
                                        kAppListCategories,
                                        false);
   return CreateShortcutInApplicationsMenu(
@@ skipping 43 matching lines @@
     for (std::vector<base::FilePath>::const_iterator it =
          shortcut_filenames_app_menu.begin();
          it != shortcut_filenames_app_menu.end(); ++it) {
       DeleteShortcutInApplicationsMenu(*it,
                                        base::FilePath(kDirectoryFilename));
     }
   }
 }
 
 }  // namespace shell_integration_linux