Make startup_tests build and run on Linux (except reference tests).

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 "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"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/debug_flags.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/json_value_serializer.h"
+#include "chrome/test/automation/automation_proxy.h"
+#include "chrome/test/automation/browser_proxy.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 
 #if defined(OS_WIN)
 // TODO(port): these just need to be ported.
 #include "chrome/common/chrome_process_filter.h"
-#include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
 #endif
 
 using base::TimeTicks;
 
 // Delay to let browser complete a requested action.
 static const int kWaitForActionMsec = 2000;
 static const int kWaitForActionMaxMsec = 10000;
 // Delay to let the browser complete the test.
@@ skipping 160 matching lines @@
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(kUiTestSleepTimeout)) {
     std::wstring sleep_timeout_str =
         CommandLine::ForCurrentProcess()->GetSwitchValue(kUiTestSleepTimeout);
     int sleep_timeout = StringToInt(WideToUTF16Hack(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_));
 
   LaunchBrowser(launch_arguments_, clear_profile_);
   if (wait_for_initial_loads_)
     ASSERT_TRUE(server_->WaitForInitialLoads());
   else
-    Sleep(2000);
+    PlatformThread::Sleep(2000);
 
   automation()->SetFilteredInet(true);
-#else
-  // TODO(port): depends on AutomationProxy.
-  NOTIMPLEMENTED();
-#endif
 }
 
 void UITest::CloseBrowserAndServer() {
   QuitBrowser();
   CleanupAppProcesses();
 
-#if defined(OS_WIN)
   // Shut down IPC testing interface.
   server_.reset();
-#else
-  // TODO(port): depends on AutomationProxy.
-  NOTIMPLEMENTED();
-#endif
 }
 
 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::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.
   command_line.AppendSwitch(switches::kEnableFileCookies);
 
   if (dom_automation_enabled_)
     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.
       command_line.AppendSwitchWithValue(switches::kAutomationClientChannelID,
                                          server_->channel_id());
     } else {
       command_line.AppendSwitchWithValue(switches::kTestingChannelID,
                                          server_->channel_id());
     }
   }
-#else
-  // TODO(port): depends on AutomationProxy.
-  NOTIMPLEMENTED();
-#endif
 
   if (!show_error_dialogs_ &&
       !CommandLine::ForCurrentProcess()->HasSwitch(kEnableErrorDialogs)) {
     command_line.AppendSwitch(switches::kNoErrorDialogs);
   }
   if (in_process_renderer_)
     command_line.AppendSwitch(switches::kSingleProcess);
   if (no_sandbox_)
     command_line.AppendSwitch(switches::kNoSandbox);
   if (full_memory_dump_)
@@ skipping 42 matching lines @@
   // 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));
 
-#if defined(OS_WIN)
   if (!template_user_data_.empty()) {
     // Recursively copy the template directory to the user_data_dir.
     ASSERT_TRUE(file_util::CopyRecursiveDirNoCache(template_user_data_,
                                                    user_data_dir_));
   }
 
   browser_launch_time_ = TimeTicks::Now();
 
+#if defined(OS_WIN)
   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);
+#elif defined(OS_POSIX)
+  bool started = base::LaunchApp(command_line.argv(),
+                                 server_->fds_to_map(),
+                                 false,  // Don't wait.
+                                 &process_);
+#endif
+  ASSERT_TRUE(started);
 
+#if defined(OS_WIN)
   if (use_existing_browser_) {
     DWORD pid = 0;
     HWND hwnd = FindWindowEx(HWND_MESSAGE, NULL, chrome::kMessageWindowClass,
                              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.
   NOTIMPLEMENTED();
 #endif
 }
 
 void UITest::QuitBrowser() {
-#if defined(OS_WIN)
   typedef std::vector<BrowserProxy*> BrowserVector;
 
   // There's nothing to do here if the browser is not running.
   if (IsBrowserRunning()) {
     automation()->SetFilteredInet(false);
     BrowserVector browsers;
 
     // Build up a list of HWNDs; we do this as a separate step so that closing
     // the windows doesn't mess up the iteration.
     int window_count = 0;
@@ skipping 14 matching lines @@
     // Now, drop the automation IPC channel so that the automation provider in
     // the browser notices and drops its reference to the browser process.
     server_->Disconnect();
 
     // Wait for the browser process to quit. It should quit once all tabs have
     // been closed.
     int timeout = 5000;
 #ifdef WAIT_FOR_DEBUGGER_ON_OPEN
     timeout = 500000;
 #endif
-    if (WAIT_TIMEOUT == WaitForSingleObject(process_, timeout)) {
+    if (!base::WaitForSingleProcess(process_, timeout)) {
       // We need to force the browser to quit because it didn't quit fast
       // enough. Take no chance and kill every chrome processes.
       CleanupAppProcesses();
     }
   }
 
   // Don't forget to close the handle
-  CloseHandle(process_);
+  base::CloseProcessHandle(process_);
   process_ = NULL;
-#else
-  // TODO(port): depends on AutomationProxy.
-  NOTIMPLEMENTED();
-#endif  // OS_WIN
 }
 
 void UITest::AssertAppNotRunning(const std::wstring& error_message) {
 #if defined(OS_WIN)
   ASSERT_EQ(0, GetBrowserProcessCount()) << error_message;
 #else
-  // TODO(port): depends on AutomationProxy.
+  // TODO(port): Enable when chrome_process_filter is ported.
   NOTIMPLEMENTED();
 #endif
 }
 
 void UITest::CleanupAppProcesses() {
 #if defined(OS_WIN)
   BrowserProcessFilter filter(L"");
 
   // Make sure that no instances of the browser remain.
   const int kExitTimeoutMs = 5000;
@@ skipping 113 matching lines @@
 
 std::wstring UITest::GetActiveTabTitle() {
   std::wstring title;
   scoped_ptr<TabProxy> tab_proxy(GetActiveTab());
   if (!tab_proxy.get())
     return title;
 
   EXPECT_TRUE(tab_proxy->GetTabTitle(&title));
   return title;
 }
+#endif  // defined(OS_WIN)
 
 bool UITest::IsBrowserRunning() {
   return CrashAwareSleep(0);
 }
 
 bool UITest::CrashAwareSleep(int time_out_ms) {
   return base::CrashAwareSleep(process_, time_out_ms);
 }
 
+#if defined(OS_WIN)
+// TODO(port): Port these.
+
 /*static*/
 int UITest::GetBrowserProcessCount() {
   BrowserProcessFilter filter(L"");
   return base::GetProcessCount(chrome::kBrowserProcessExecutableName,
                                &filter);
 }
 
 static DictionaryValue* LoadDictionaryValueFromPath(const std::wstring& path) {
   if (path.empty())
     return NULL;
@@ skipping 125 matching lines @@
 
   if (*application_closed) {
     // Let's wait until the process dies (if it is not gone already).
     int r = WaitForSingleObject(process_, INFINITE);
     DCHECK(r != WAIT_FAILED);
   }
 
   return result;
 }
 
-void UITest::PrintResult(const std::wstring& measurement,
-                         const std::wstring& modifier,
-                         const std::wstring& trace,
-                         size_t value,
-                         const std::wstring& units,
-                         bool important) {
-  std::wstring value_str = StringPrintf(L"%d", value);
-  PrintResultsImpl(measurement, modifier, trace, value_str,
-                   L"", L"", units, important);
-}
-
-void UITest::PrintResultMeanAndError(const std::wstring& measurement,
-                                     const std::wstring& modifier,
-                                     const std::wstring& trace,
-                                     const std::wstring& mean_and_error,
-                                     const std::wstring& units,
-                                     bool important) {
-  PrintResultsImpl(measurement, modifier, trace, mean_and_error,
-                   L"{", L"}", units, important);
-}
-
-void UITest::PrintResultList(const std::wstring& measurement,
-                             const std::wstring& modifier,
-                             const std::wstring& trace,
-                             const std::wstring& values,
-                             const std::wstring& units,
-                             bool important) {
-  PrintResultsImpl(measurement, modifier, trace, values,
-                   L"[", L"]", units, important);
-}
-
 GURL UITest::GetTestUrl(const std::wstring& test_directory,
                         const std::wstring &test_case) {
   std::wstring path;
   PathService::Get(chrome::DIR_TEST_DATA, &path);
   file_util::AppendToPath(&path, test_directory);
   file_util::AppendToPath(&path, test_case);
   return net::FilePathToFileURL(path);
 }
 
 void UITest::WaitForFinish(const std::string &name,
@@ skipping 16 matching lines @@
 
   scoped_ptr<TabProxy> tab(GetActiveTab());
 
   bool test_result = WaitUntilCookieValue(tab.get(), url,
                                           cookie_name.c_str(),
                                           kIntervalMilliSeconds, wait_time,
                                           expected_cookie_value.c_str());
   EXPECT_EQ(true, test_result);
 }
 
+#endif  // OS_WIN
+
+void UITest::PrintResult(const std::wstring& measurement,
+                         const std::wstring& modifier,
+                         const std::wstring& trace,
+                         size_t value,
+                         const std::wstring& units,
+                         bool important) {
+  std::wstring value_str = StringPrintf(L"%d", value);
+  PrintResultsImpl(measurement, modifier, trace, value_str,
+                   L"", L"", units, important);
+}
+
+void UITest::PrintResultMeanAndError(const std::wstring& measurement,
+                                     const std::wstring& modifier,
+                                     const std::wstring& trace,
+                                     const std::wstring& mean_and_error,
+                                     const std::wstring& units,
+                                     bool important) {
+  PrintResultsImpl(measurement, modifier, trace, mean_and_error,
+                   L"{", L"}", units, important);
+}
+
+void UITest::PrintResultList(const std::wstring& measurement,
+                             const std::wstring& modifier,
+                             const std::wstring& trace,
+                             const std::wstring& values,
+                             const std::wstring& units,
+                             bool important) {
+  PrintResultsImpl(measurement, modifier, trace, values,
+                   L"[", L"]", units, important);
+}
+
 void UITest::PrintResultsImpl(const std::wstring& measurement,
                               const std::wstring& modifier,
                               const std::wstring& trace,
                               const std::wstring& values,
                               const std::wstring& prefix,
                               const std::wstring& suffix,
                               const std::wstring& units,
                               bool important) {
   // <*>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