Prefix CommandLine usege with base namespace (Part 1: base/)

base/process/process_util_unittest.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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 346 matching lines @@
   std::string message;
   for (int i = 0; i < 1025; i++) {  // 1025 so it does not end on a kilo-byte
                                     // boundary.
     message += "Hello!";
   }
   // cmd.exe's echo always adds a \r\n to its output.
   std::string expected(message);
   expected += "\r\n";
 
   FilePath cmd(L"cmd.exe");
-  CommandLine cmd_line(cmd);
+  base::CommandLine cmd_line(cmd);
   cmd_line.AppendArg("/c");
   cmd_line.AppendArg("echo " + message + "");
   std::string output;
   ASSERT_TRUE(base::GetAppOutput(cmd_line, &output));
   EXPECT_EQ(expected, output);
 
   // Let's make sure stderr is ignored.
-  CommandLine other_cmd_line(cmd);
+  base::CommandLine other_cmd_line(cmd);
   other_cmd_line.AppendArg("/c");
   // http://msdn.microsoft.com/library/cc772622.aspx
   cmd_line.AppendArg("echo " + message + " >&2");
   output.clear();
   ASSERT_TRUE(base::GetAppOutput(other_cmd_line, &output));
   EXPECT_EQ("", output);
 }
 
 // TODO(estade): if possible, port this test.
 TEST_F(ProcessUtilTest, LaunchAsUser) {
   base::UserTokenHandle token;
   ASSERT_TRUE(OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &token));
   base::LaunchOptions options;
   options.as_user = token;
   EXPECT_TRUE(base::LaunchProcess(MakeCmdLine("SimpleChildProcess"), options,
                                   NULL));
 }
 
 static const char kEventToTriggerHandleSwitch[] = "event-to-trigger-handle";
 
 MULTIPROCESS_TEST_MAIN(TriggerEventChildProcess) {
   std::string handle_value_string =
-      CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
+      base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           kEventToTriggerHandleSwitch);
   CHECK(!handle_value_string.empty());
 
   uint64 handle_value_uint64;
   CHECK(base::StringToUint64(handle_value_string, &handle_value_uint64));
   // Give ownership of the handle to |event|.
   base::WaitableEvent event(reinterpret_cast<HANDLE>(handle_value_uint64));
 
   event.Signal();
 
   return 0;
 }
 
 TEST_F(ProcessUtilTest, InheritSpecifiedHandles) {
   // Manually create the event, so that it can be inheritable.
   SECURITY_ATTRIBUTES security_attributes = {};
   security_attributes.nLength = static_cast<DWORD>(sizeof(security_attributes));
   security_attributes.lpSecurityDescriptor = NULL;
   security_attributes.bInheritHandle = true;
 
   // Takes ownership of the event handle.
   base::WaitableEvent event(
       CreateEvent(&security_attributes, true, false, NULL));
   base::HandlesToInheritVector handles_to_inherit;
   handles_to_inherit.push_back(event.handle());
   base::LaunchOptions options;
   options.handles_to_inherit = &handles_to_inherit;
 
-  CommandLine cmd_line = MakeCmdLine("TriggerEventChildProcess");
+  base::CommandLine cmd_line = MakeCmdLine("TriggerEventChildProcess");
   cmd_line.AppendSwitchASCII(kEventToTriggerHandleSwitch,
       base::Uint64ToString(reinterpret_cast<uint64>(event.handle())));
 
   // This functionality actually requires Vista or later. Make sure that it
   // fails properly on XP.
   if (base::win::GetVersion() < base::win::VERSION_VISTA) {
     EXPECT_FALSE(base::LaunchProcess(cmd_line, options, NULL));
     return;
   }
 
@@ skipping 304 matching lines @@
 
 TEST_F(ProcessUtilTest, GetAppOutput) {
   std::string output;
 
 #if defined(OS_ANDROID)
   std::vector<std::string> argv;
   argv.push_back("sh");  // Instead of /bin/sh, force path search to find it.
   argv.push_back("-c");
 
   argv.push_back("exit 0");
-  EXPECT_TRUE(base::GetAppOutput(CommandLine(argv), &output));
+  EXPECT_TRUE(base::GetAppOutput(base::CommandLine(argv), &output));
   EXPECT_STREQ("", output.c_str());
 
   argv[2] = "exit 1";
-  EXPECT_FALSE(base::GetAppOutput(CommandLine(argv), &output));
+  EXPECT_FALSE(base::GetAppOutput(base::CommandLine(argv), &output));
   EXPECT_STREQ("", output.c_str());
 
   argv[2] = "echo foobar42";
-  EXPECT_TRUE(base::GetAppOutput(CommandLine(argv), &output));
+  EXPECT_TRUE(base::GetAppOutput(base::CommandLine(argv), &output));
   EXPECT_STREQ("foobar42\n", output.c_str());
 #else
-  EXPECT_TRUE(base::GetAppOutput(CommandLine(FilePath("true")), &output));
+  EXPECT_TRUE(base::GetAppOutput(base::CommandLine(FilePath("true")),
+                                 &output));
   EXPECT_STREQ("", output.c_str());
 
-  EXPECT_FALSE(base::GetAppOutput(CommandLine(FilePath("false")), &output));
+  EXPECT_FALSE(base::GetAppOutput(base::CommandLine(FilePath("false")),
+                                  &output));
 
   std::vector<std::string> argv;
   argv.push_back("/bin/echo");
   argv.push_back("-n");
   argv.push_back("foobar42");
-  EXPECT_TRUE(base::GetAppOutput(CommandLine(argv), &output));
+  EXPECT_TRUE(base::GetAppOutput(base::CommandLine(argv), &output));
   EXPECT_STREQ("foobar42", output.c_str());
 #endif  // defined(OS_ANDROID)
 }
 
 // Flakes on Android, crbug.com/375840
 #if defined(OS_ANDROID)
 #define MAYBE_GetAppOutputRestricted DISABLED_GetAppOutputRestricted
 #else
 #define MAYBE_GetAppOutputRestricted GetAppOutputRestricted
 #endif
 TEST_F(ProcessUtilTest, MAYBE_GetAppOutputRestricted) {
   // Unfortunately, since we can't rely on the path, we need to know where
   // everything is. So let's use /bin/sh, which is on every POSIX system, and
   // its built-ins.
   std::vector<std::string> argv;
   argv.push_back(std::string(kShellPath));  // argv[0]
   argv.push_back("-c");  // argv[1]
 
   // On success, should set |output|. We use |/bin/sh -c 'exit 0'| instead of
   // |true| since the location of the latter may be |/bin| or |/usr/bin| (and we
   // need absolute paths).
   argv.push_back("exit 0");   // argv[2]; equivalent to "true"
   std::string output = "abc";
-  EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 100));
+  EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
+                                           100));
   EXPECT_STREQ("", output.c_str());
 
   argv[2] = "exit 1";  // equivalent to "false"
   output = "before";
-  EXPECT_FALSE(base::GetAppOutputRestricted(CommandLine(argv),
-                                            &output, 100));
+  EXPECT_FALSE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
+                                            100));
   EXPECT_STREQ("", output.c_str());
 
   // Amount of output exactly equal to space allowed.
   argv[2] = "echo 123456789";  // (the sh built-in doesn't take "-n")
   output.clear();
-  EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10));
+  EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
+                                           10));
   EXPECT_STREQ("123456789\n", output.c_str());
 
   // Amount of output greater than space allowed.
   output.clear();
-  EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 5));
+  EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
+                                           5));
   EXPECT_STREQ("12345", output.c_str());
 
   // Amount of output less than space allowed.
   output.clear();
-  EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 15));
+  EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
+                                           15));
   EXPECT_STREQ("123456789\n", output.c_str());
 
   // Zero space allowed.
   output = "abc";
-  EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 0));
+  EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
+                                           0));
   EXPECT_STREQ("", output.c_str());
 }
 
 #if !defined(OS_MACOSX) && !defined(OS_OPENBSD)
 // TODO(benwells): GetAppOutputRestricted should terminate applications
 // with SIGPIPE when we have enough output. http://crbug.com/88502
 TEST_F(ProcessUtilTest, GetAppOutputRestrictedSIGPIPE) {
   std::vector<std::string> argv;
   std::string output;
 
   argv.push_back(std::string(kShellPath));  // argv[0]
   argv.push_back("-c");
 #if defined(OS_ANDROID)
   argv.push_back("while echo 12345678901234567890; do :; done");
-  EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10));
+  EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
+                                           10));
   EXPECT_STREQ("1234567890", output.c_str());
 #else
   argv.push_back("yes");
-  EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10));
+  EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
+                                           10));
   EXPECT_STREQ("y\ny\ny\ny\ny\n", output.c_str());
 #endif
 }
 #endif
 
 #if defined(ADDRESS_SANITIZER) && defined(OS_MACOSX) && \
     defined(ARCH_CPU_64_BITS)
 // Times out under AddressSanitizer on 64-bit OS X, see
 // http://crbug.com/298197.
 #define MAYBE_GetAppOutputRestrictedNoZombies \
     DISABLED_GetAppOutputRestrictedNoZombies
 #else
 #define MAYBE_GetAppOutputRestrictedNoZombies GetAppOutputRestrictedNoZombies
 #endif
 TEST_F(ProcessUtilTest, MAYBE_GetAppOutputRestrictedNoZombies) {
   std::vector<std::string> argv;
 
   argv.push_back(std::string(kShellPath));  // argv[0]
   argv.push_back("-c");  // argv[1]
   argv.push_back("echo 123456789012345678901234567890");  // argv[2]
 
   // Run |GetAppOutputRestricted()| 300 (> default per-user processes on Mac OS
   // 10.5) times with an output buffer big enough to capture all output.
   for (int i = 0; i < 300; i++) {
     std::string output;
-    EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 100));
+    EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
+                                             100));
     EXPECT_STREQ("123456789012345678901234567890\n", output.c_str());
   }
 
   // Ditto, but with an output buffer too small to capture all output.
   for (int i = 0; i < 300; i++) {
     std::string output;
-    EXPECT_TRUE(base::GetAppOutputRestricted(CommandLine(argv), &output, 10));
+    EXPECT_TRUE(base::GetAppOutputRestricted(base::CommandLine(argv), &output,
+                                             10));
     EXPECT_STREQ("1234567890", output.c_str());
   }
 }
 
 TEST_F(ProcessUtilTest, GetAppOutputWithExitCode) {
   // Test getting output from a successful application.
   std::vector<std::string> argv;
   std::string output;
   int exit_code;
   argv.push_back(std::string(kShellPath));  // argv[0]
   argv.push_back("-c");  // argv[1]
   argv.push_back("echo foo");  // argv[2];
-  EXPECT_TRUE(base::GetAppOutputWithExitCode(CommandLine(argv), &output,
+  EXPECT_TRUE(base::GetAppOutputWithExitCode(base::CommandLine(argv), &output,
                                              &exit_code));
   EXPECT_STREQ("foo\n", output.c_str());
   EXPECT_EQ(exit_code, 0);
 
   // Test getting output from an application which fails with a specific exit
   // code.
   output.clear();
   argv[2] = "echo foo; exit 2";
-  EXPECT_TRUE(base::GetAppOutputWithExitCode(CommandLine(argv), &output,
+  EXPECT_TRUE(base::GetAppOutputWithExitCode(base::CommandLine(argv), &output,
                                              &exit_code));
   EXPECT_STREQ("foo\n", output.c_str());
   EXPECT_EQ(exit_code, 2);
 }
 
 TEST_F(ProcessUtilTest, GetParentProcessId) {
   base::ProcessId ppid = base::GetParentProcessId(base::GetCurrentProcId());
   EXPECT_EQ(ppid, getppid());
 }
 
@@ skipping 35 matching lines @@
   // Check that process was really killed.
   EXPECT_TRUE(IsProcessDead(child_process));
   base::CloseProcessHandle(child_process);
 }
 
 MULTIPROCESS_TEST_MAIN(process_util_test_die_immediately) {
   return 0;
 }
 
 #endif  // defined(OS_POSIX)