Butcher some files to make ui_tests run 0 tests on Linux.

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 <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"
 #include "chrome/browser/url_fixer_upper.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
-#include "chrome/common/chrome_process_filter.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 "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"
-#include "googleurl/src/gurl.h"
-#include "net/base/net_util.h"
+#endif
 
 using base::TimeTicks;
 
+// Delay to let browser complete a requested action.
+const int UITest::kWaitForActionMsec = 2000;
+const int UITest::kWaitForActionMaxMsec = 10000;
+// Delay to let the browser complete the test.
+const int UITest::kMaxTestExecutionTime = 30000;
+
 const wchar_t UITest::kFailedNoCrashService[] =
     L"NOTE: This test is expected to fail if crash_service.exe is not "
     L"running. Start it manually before running this test (see the build "
     L"output directory).";
 bool UITest::in_process_renderer_ = false;
 bool UITest::in_process_plugins_ = false;
 bool UITest::no_sandbox_ = false;
 bool UITest::full_memory_dump_ = false;
 bool UITest::safe_plugins_ = false;
 bool UITest::show_error_dialogs_ = true;
@@ skipping 21 matching lines @@
 
 // static
 bool UITest::DieFileDie(const std::wstring& file, bool recurse) {
   if (!file_util::PathExists(file))
     return true;
 
   // Sometimes Delete fails, so try a few more times.
   for (int i = 0; i < 10; ++i) {
     if (file_util::Delete(file, recurse))
       return true;
-    Sleep(kWaitForActionMaxMsec / 10);
+    PlatformThread::Sleep(kWaitForActionMaxMsec / 10);
   }
   return false;
 }
 
 UITest::UITest()
     : testing::Test(),
       expected_errors_(0),
       expected_crashes_(0),
+      homepage_(L"about:blank"),
       wait_for_initial_loads_(true),
-      homepage_(L"about:blank"),
       dom_automation_enabled_(false),
-      process_(NULL),
+      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_),
       command_execution_timeout_ms_(kMaxTestExecutionTime),
       action_timeout_ms_(kWaitForActionMsec),
       action_max_timeout_ms_(kWaitForActionMaxMsec) {
   PathService::Get(chrome::DIR_APP, &browser_directory_);
   PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory_);
+#if defined(OS_WIN)
   GetSystemTimeAsFileTime(&test_start_time_);
+#else
+  NOTIMPLEMENTED();
+#endif
 }
 
 void UITest::SetUp() {
   if (!use_existing_browser_) {
     AssertAppNotRunning(L"Please close any other instances "
                         L"of the app before testing.");
   }
 
   InitializeTimeouts();
   LaunchBrowserAndServer();
 }
 
 void UITest::TearDown() {
   CloseBrowserAndServer();
 
   // Make sure that we didn't encounter any assertion failures
   logging::AssertionList assertions;
   logging::GetFatalAssertions(&assertions);
 
   // If there were errors, get all the error strings for display.
   std::wstring failures =
     L"The following error(s) occurred in the application during this test:";
-  if (static_cast<int>(assertions.size()) > expected_errors_) {
+  if (assertions.size() > expected_errors_) {
     logging::AssertionList::const_iterator iter = assertions.begin();
     for (; iter != assertions.end(); ++iter) {
       failures.append(L"\n\n");
       failures.append(*iter);
     }
   }
   EXPECT_EQ(expected_errors_, assertions.size()) << failures;
 
+#if defined(OS_WIN)
   // Check for crashes during the test
   std::wstring crash_dump_path;
   PathService::Get(chrome::DIR_CRASH_DUMPS, &crash_dump_path);
   // Each crash creates two dump files, so we divide by two here.
   int actual_crashes =
     file_util::CountFilesCreatedAfter(crash_dump_path, test_start_time_) / 2;
   std::wstring error_msg =
       L"Encountered an unexpected crash in the program during this test.";
   if (expected_crashes_ > 0 && actual_crashes == 0) {
     error_msg += L"  ";
     error_msg += kFailedNoCrashService;
   }
   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);
     int timeout = StringToInt(timeout_str);
     command_execution_timeout_ms_ = std::max(kMaxTestExecutionTime, timeout);
   }
 
   if (CommandLine().HasSwitch(kUiTestActionTimeout)) {
     std::wstring act_str = CommandLine().GetSwitchValue(kUiTestActionTimeout);
     int act_timeout = StringToInt(act_str);
     action_timeout_ms_ = std::max(kWaitForActionMsec, act_timeout);
   }
 
   if (CommandLine().HasSwitch(kUiTestActionMaxTimeout)) {
     std::wstring action_max_str =
         CommandLine().GetSwitchValue(kUiTestActionMaxTimeout);
     int max_timeout = StringToInt(action_max_str);
     action_max_timeout_ms_ = std::max(kWaitForActionMaxMsec, max_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);
 
   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 std::wstring& arguments, bool clear_profile) {
   std::wstring command_line(browser_directory_);
   file_util::AppendToPath(&command_line,
                           chrome::kBrowserProcessExecutableName);
 
   // 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);
 
   // We need cookies on file:// for things like the page cycler.
   CommandLine::AppendSwitch(&command_line, switches::kEnableFileCookies);
 
   if (dom_automation_enabled_)
     CommandLine::AppendSwitch(&command_line,
                               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,
                                          server_->channel_id());
     } else {
       CommandLine::AppendSwitchWithValue(&command_line,
                                          switches::kTestingChannelID,
                                          server_->channel_id());
     }
   }
+#else
+  // TODO(port): depends on AutomationProxy.
+  NOTIMPLEMENTED();
+#endif
 
   if (!show_error_dialogs_)
     CommandLine::AppendSwitch(&command_line, switches::kNoErrorDialogs);
   if (in_process_renderer_)
     CommandLine::AppendSwitch(&command_line, switches::kSingleProcess);
   if (in_process_plugins_)
     CommandLine::AppendSwitch(&command_line, switches::kInProcessPlugins);
   if (no_sandbox_)
     CommandLine::AppendSwitch(&command_line, switches::kNoSandbox);
   if (full_memory_dump_)
@@ skipping 38 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();
 
   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());
     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 25 matching lines @@
     if (WAIT_TIMEOUT == WaitForSingleObject(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_);
   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.
+  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;
   const int kExitCode = 1;
   base::CleanupProcesses(
       chrome::kBrowserProcessExecutableName, kExitTimeoutMs, kExitCode,
       &filter);
 
   // Suppress spammy failures that seem to be occurring when running
   // the UI tests in single-process mode.
   // TODO(jhughes): figure out why this is necessary at all, and fix it
   if (!in_process_renderer_) {
     AssertAppNotRunning(L"Unable to quit all browser processes.");
   }
+#else
+  // TODO(port): depends on BrowserProcessFilter.
+  NOTIMPLEMENTED();
+#endif
 }
 
+// TODO(port): this #if effectively cuts out half of this file on
+// non-Windows platforms, and is a temporary hack to get things
+// building.
+#if defined(OS_WIN)
 TabProxy* UITest::GetActiveTab() {
   scoped_ptr<BrowserProxy> window_proxy(automation()->GetBrowserWindow(0));
   if (!window_proxy.get())
     return NULL;
 
   int active_tab_index = -1;
   EXPECT_TRUE(window_proxy->GetActiveTabIndex(&active_tab_index));
   if (active_tab_index == -1)
     return NULL;
 
@@ skipping 325 matching lines @@
                               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