CommandLine API rework

chrome/test/ui/ui_test.cc

 // Copyright (c) 2006-2008 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/test/ui/ui_test.h"
+
 #include <set>
 #include <vector>
 
-#include "chrome/test/ui/ui_test.h"
-
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/test_file_util.h"
 #include "base/time.h"
 #include "chrome/app/chrome_dll_resource.h"
@@ skipping 65 matching lines @@
   for (int i = 0; i < 10; ++i) {
     if (file_util::Delete(file, recurse))
       return true;
     PlatformThread::Sleep(action_max_timeout_ms() / 10);
   }
   return false;
 }
 
 UITest::UITest()
     : testing::Test(),
+      launch_arguments_(L""),
       expected_errors_(0),
       expected_crashes_(0),
       homepage_(L"about:blank"),
       wait_for_initial_loads_(true),
       dom_automation_enabled_(false),
       process_(0),  // NULL on Windows, 0 PID on POSIX.
       show_window_(false),
       clear_profile_(true),
       include_testing_id_(true),
       use_existing_browser_(default_use_existing_browser_),
@@ skipping 65 matching lines @@
   }
   EXPECT_EQ(expected_crashes_, actual_crashes) << error_msg;
 #else
   // TODO(port): we don't catch crashes, nor have CountFilesCreatedAfter.
   NOTIMPLEMENTED();
 #endif
 }
 
 // Pick up the various test time out values from the command line.
 void UITest::InitializeTimeouts() {
-  if (CommandLine().HasSwitch(kUiTestTimeout)) {
-    std::wstring timeout_str = CommandLine().GetSwitchValue(kUiTestTimeout);
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (command_line.HasSwitch(kUiTestTimeout)) {
+    std::wstring timeout_str = command_line.GetSwitchValue(kUiTestTimeout);
     int timeout = StringToInt(timeout_str);
     command_execution_timeout_ms_ = std::max(kMaxTestExecutionTime, timeout);
   }
 
-  if (CommandLine().HasSwitch(kUiTestActionTimeout)) {
-    std::wstring act_str = CommandLine().GetSwitchValue(kUiTestActionTimeout);
+  if (command_line.HasSwitch(kUiTestActionTimeout)) {
+    std::wstring act_str = command_line.GetSwitchValue(kUiTestActionTimeout);
     int act_timeout = StringToInt(act_str);
     action_timeout_ms_ = std::max(kWaitForActionMsec, act_timeout);
   }
 
-  if (CommandLine().HasSwitch(kUiTestActionMaxTimeout)) {
+  if (command_line.HasSwitch(kUiTestActionMaxTimeout)) {
     std::wstring action_max_str =
-        CommandLine().GetSwitchValue(kUiTestActionMaxTimeout);
+        command_line.GetSwitchValue(kUiTestActionMaxTimeout);
     int max_timeout = StringToInt(action_max_str);
     action_max_timeout_ms_ = std::max(kWaitForActionMaxMsec, max_timeout);
   }
 
-  if (CommandLine().HasSwitch(kUiTestSleepTimeout)) {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(kUiTestSleepTimeout)) {
     std::wstring sleep_timeout_str =
-        CommandLine().GetSwitchValue(kUiTestSleepTimeout);
+        CommandLine::ForCurrentProcess()->GetSwitchValue(kUiTestSleepTimeout);
     int sleep_timeout = StringToInt(sleep_timeout_str);
     sleep_timeout_ms_ = std::max(kWaitForActionMsec, sleep_timeout);
   }
 }
 
 void UITest::LaunchBrowserAndServer() {
 #if defined(OS_WIN)
   // Set up IPC testing interface server.
   server_.reset(new AutomationProxy(command_execution_timeout_ms_));
 
@@ skipping 16 matching lines @@
 
 #if defined(OS_WIN)
   // Shut down IPC testing interface.
   server_.reset();
 #else
   // TODO(port): depends on AutomationProxy.
   NOTIMPLEMENTED();
 #endif
 }
 
-void UITest::LaunchBrowser(const std::wstring& arguments, bool clear_profile) {
-  std::wstring command_line(browser_directory_);
-  file_util::AppendToPath(&command_line,
+void UITest::LaunchBrowser(const CommandLine& arguments, bool clear_profile) {
+  std::wstring command = browser_directory_;
+  file_util::AppendToPath(&command,
                           chrome::kBrowserProcessExecutableName);
+  CommandLine command_line(command);
 
   // Add any explict command line flags passed to the process.
   std::wstring extra_chrome_flags =
-      CommandLine().GetSwitchValue(kExtraChromeFlagsSwitch);
-  if (!extra_chrome_flags.empty())
-    command_line.append(L" " + extra_chrome_flags);
+      CommandLine::ForCurrentProcess()->GetSwitchValue(kExtraChromeFlagsSwitch);
+  if (!extra_chrome_flags.empty()) {
+#if defined(OS_WIN)
+    command_line.AppendLooseValue(extra_chrome_flags);
+#else
+    // TODO(port): figure out how to pass through extra flags via a string.
+    NOTIMPLEMENTED();
+#endif
+  }
 
   // We need cookies on file:// for things like the page cycler.
-  CommandLine::AppendSwitch(&command_line, switches::kEnableFileCookies);
+  command_line.AppendSwitch(switches::kEnableFileCookies);
 
   if (dom_automation_enabled_)
-    CommandLine::AppendSwitch(&command_line,
-                              switches::kDomAutomationController);
+    command_line.AppendSwitch(switches::kDomAutomationController);
 
 #if defined(OS_WIN)
   if (include_testing_id_) {
     if (use_existing_browser_) {
       // TODO(erikkay): The new switch depends on a browser instance already
       // running, it won't open a new browser window if it's not.  We could fix
       // this by passing an url (e.g. about:blank) on the command line, but
       // I decided to keep using the old switch in the existing use case to
       // minimize changes in behavior.
-      CommandLine::AppendSwitchWithValue(&command_line,
-                                         switches::kAutomationClientChannelID,
+      command_line.AppendSwitchWithValue(switches::kAutomationClientChannelID,
                                          server_->channel_id());
     } else {
-      CommandLine::AppendSwitchWithValue(&command_line,
-                                         switches::kTestingChannelID,
+      command_line.AppendSwitchWithValue(switches::kTestingChannelID,
                                          server_->channel_id());
     }
   }
 #else
   // TODO(port): depends on AutomationProxy.
   NOTIMPLEMENTED();
 #endif
 
   if (!show_error_dialogs_)
-    CommandLine::AppendSwitch(&command_line, switches::kNoErrorDialogs);
+    command_line.AppendSwitch(switches::kNoErrorDialogs);
   if (in_process_renderer_)
-    CommandLine::AppendSwitch(&command_line, switches::kSingleProcess);
+    command_line.AppendSwitch(switches::kSingleProcess);
   if (in_process_plugins_)
-    CommandLine::AppendSwitch(&command_line, switches::kInProcessPlugins);
+    command_line.AppendSwitch(switches::kInProcessPlugins);
   if (no_sandbox_)
-    CommandLine::AppendSwitch(&command_line, switches::kNoSandbox);
+    command_line.AppendSwitch(switches::kNoSandbox);
   if (full_memory_dump_)
-    CommandLine::AppendSwitch(&command_line, switches::kFullMemoryCrashReport);
+    command_line.AppendSwitch(switches::kFullMemoryCrashReport);
   if (safe_plugins_)
-    CommandLine::AppendSwitch(&command_line, switches::kSafePlugins);
+    command_line.AppendSwitch(switches::kSafePlugins);
   if (enable_dcheck_)
-    CommandLine::AppendSwitch(&command_line, switches::kEnableDCHECK);
+    command_line.AppendSwitch(switches::kEnableDCHECK);
   if (silent_dump_on_dcheck_)
-    CommandLine::AppendSwitch(&command_line, switches::kSilentDumpOnDCHECK);
+    command_line.AppendSwitch(switches::kSilentDumpOnDCHECK);
   if (disable_breakpad_)
-    CommandLine::AppendSwitch(&command_line, switches::kDisableBreakpad);
+    command_line.AppendSwitch(switches::kDisableBreakpad);
   if (!homepage_.empty())
-    CommandLine::AppendSwitchWithValue(&command_line,
-                                       switches::kHomePage,
+    command_line.AppendSwitchWithValue(switches::kHomePage,
                                        homepage_);
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir_);
   if (!user_data_dir_.empty())
-    CommandLine::AppendSwitchWithValue(&command_line,
-                                       switches::kUserDataDir,
+    command_line.AppendSwitchWithValue(switches::kUserDataDir,
                                        user_data_dir_);
   if (!js_flags_.empty())
-    CommandLine::AppendSwitchWithValue(&command_line,
-                                       switches::kJavaScriptFlags,
+    command_line.AppendSwitchWithValue(switches::kJavaScriptFlags,
                                        js_flags_);
 
-  CommandLine::AppendSwitch(&command_line, switches::kMetricsRecordingOnly);
+  command_line.AppendSwitch(switches::kMetricsRecordingOnly);
 
   // We always want to enable chrome logging
-  CommandLine::AppendSwitch(&command_line, switches::kEnableLogging);
+  command_line.AppendSwitch(switches::kEnableLogging);
 
   if (dump_histograms_on_exit_)
-    CommandLine::AppendSwitch(&command_line, switches::kDumpHistogramsOnExit);
+    command_line.AppendSwitch(switches::kDumpHistogramsOnExit);
 
 #ifdef WAIT_FOR_DEBUGGER_ON_OPEN
-  CommandLine::AppendSwitch(&command_line, switches::kDebugOnStart);
+  command_line.AppendSwitch(switches::kDebugOnStart);
 #endif
 
   if (!ui_test_name_.empty())
-    CommandLine::AppendSwitchWithValue(&command_line,
-                                       switches::kTestName,
+    command_line.AppendSwitchWithValue(switches::kTestName,
                                        ui_test_name_);
 
   DebugFlags::ProcessDebugFlags(&command_line, DebugFlags::UNKNOWN, false);
-  command_line.append(L" " + arguments);
+  command_line.AppendArguments(arguments, false);
 
   // Clear user data directory to make sure test environment is consistent
   // We balk on really short (absolute) user_data_dir directory names, because
   // we're worried that they'd accidentally be root or something.
   ASSERT_LT(10, static_cast<int>(user_data_dir_.size())) <<
                 "The user data directory name passed into this test was too "
                 "short to delete safely.  Please check the user-data-dir "
                 "argument and try again.";
   if (clear_profile)
     ASSERT_TRUE(DieFileDie(user_data_dir_, true));
@@ skipping 10 matching lines @@
   bool started = base::LaunchApp(command_line,
                                  false,  // Don't wait for process object
                                          // (doesn't work for us)
                                  !show_window_,
                                  &process_);
   ASSERT_EQ(started, true);
 
   if (use_existing_browser_) {
     DWORD pid = 0;
     HWND hwnd = FindWindowEx(HWND_MESSAGE, NULL, chrome::kMessageWindowClass,
-                         user_data_dir_.c_str());
+                             user_data_dir_.c_str());
     GetWindowThreadProcessId(hwnd, &pid);
     // This mode doesn't work if we wound up launching a new browser ourselves.
     ASSERT_NE(pid, base::GetProcId(process_));
     CloseHandle(process_);
     process_ = OpenProcess(SYNCHRONIZE, false, pid);
   }
 #else
   // TODO(port): above code is very Windows-specific; we need to
   // figure out and abstract out how we'll handle finding any existing
   // running process, etc. on other platforms.
@@ skipping 430 matching lines @@
   // <*>RESULT <graph_name>: <trace_name>= <value> <units>
   // <*>RESULT <graph_name>: <trace_name>= {<mean>, <std deviation>} <units>
   // <*>RESULT <graph_name>: <trace_name>= [<value>,value,value,...,] <units>
   wprintf(L"%lsRESULT %ls%ls: %ls= %ls%ls%ls %ls\n",
           important ? L"*" : L"", measurement.c_str(), modifier.c_str(),
           trace.c_str(), prefix.c_str(), values.c_str(), suffix.c_str(),
           units.c_str());
 }
 
 #endif  // OS_WIN