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

chrome/test/ui/ui_test.h

 // 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.
 
 #ifndef CHROME_TEST_UI_UI_TEST_H_
 #define CHROME_TEST_UI_UI_TEST_H_
 
 // This file provides a common base for running UI unit tests, which operate
 // the entire browser application in a separate process for holistic
 // functional testing.
 //
 // Tests should #include this file, subclass UITest, and use the TEST_F macro
 // to declare individual test cases.  This provides a running browser window
 // during the test, accessible through the window_ member variable.  The window
 // will close when the test ends, regardless of whether the test passed.
 //
 // Tests which need to launch the browser with a particular set of command-line
 // arguments should set the value of launch_arguments_ in their constructors.
 
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
 #include <windows.h>
+#endif
 #include <string>
 
+#include "base/message_loop.h"
 #include "base/path_service.h"
+#include "base/process.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
+#if defined(OS_WIN)
+// TODO(evanm): we should be able to just forward-declare
+// AutomationProxy here, but many files that #include this one don't
+// themselves #include automation_proxy.h.
 #include "chrome/test/automation/automation_proxy.h"
+#endif
 #include "testing/gtest/include/gtest/gtest.h"
 
+class AutomationProxy;
+class BrowserProxy;
 class DictionaryValue;
 class GURL;
 class TabProxy;
 
 class UITest : public testing::Test {
  protected:
   // Delay to let browser complete a requested action.
-  static const int kWaitForActionMsec = 2000;
-  static const int kWaitForActionMaxMsec = 10000;
+  static const int kWaitForActionMsec;
+  static const int kWaitForActionMaxMsec;
   // Delay to let the browser complete the test.
-  static const int kMaxTestExecutionTime = 30000;
+  static const int kMaxTestExecutionTime;
 
   // String to display when a test fails because the crash service isn't
   // running.
   static const wchar_t kFailedNoCrashService[];
 
   // Tries to delete the specified file/directory returning true on success.
   // This differs from file_util::Delete in that it repeatedly invokes Delete
   // until successful, or a timeout is reached. Returns true on success.
   static bool DieFileDie(const std::wstring& file, bool recurse);
 
@@ skipping 148 matching lines @@
                        const std::wstring& values,
                        const std::wstring& units,
                        bool important);
 
   // Gets the directory for the currently active profile in the browser.
   std::wstring GetDownloadDirectory();
 
   // Get the handle of browser process connected to the automation. This
   // function only retruns a reference to the handle so the caller does not
   // own the handle returned.
-  HANDLE process() { return process_; }
+  base::ProcessHandle process() { return process_; }
 
  public:
   // Get/Set a flag to run the renderer in process when running the
   // tests.
   static bool in_process_renderer() { return in_process_renderer_; }
   static void set_in_process_renderer(bool value) {
     in_process_renderer_ = value;
   }
 
   // Get/Set a flag to run the plugins in the renderer process when running the
@@ skipping 125 matching lines @@
                         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);
 
  protected:
   AutomationProxy* automation() {
+#if defined(OS_WIN)
     EXPECT_TRUE(server_.get());
     return server_.get();
+#else
+    // TODO(port): restore when AutomationProxy bits work.
+    NOTIMPLEMENTED();
+    return NULL;
+#endif
   }
 
   // Wait a certain amount of time for all the app processes to exit,
   // forcibly killing them if they haven't exited by then.
   // It has the side-effect of killing every browser window opened in your
   // session, even those unrelated in the test.
   void CleanupAppProcesses();
 
   // Returns the proxy for the currently active tab, or NULL if there is no
   // tab or there was some kind of error. The returned pointer MUST be
   // deleted by the caller if non-NULL.
   TabProxy* GetActiveTab();
 
   // ********* Member variables *********
 
   std::wstring browser_directory_;      // Path to the browser executable,
                                         // with no trailing slash
   std::wstring test_data_directory_;    // Path to the unit test data,
                                         // with no trailing slash
   std::wstring launch_arguments_;       // Arguments to the browser on launch.
-  int expected_errors_;                 // The number of errors expected during
+  size_t expected_errors_;              // The number of errors expected during
                                         // the run (generally 0).
   int expected_crashes_;                // The number of crashes expected during
                                         // the run (generally 0).
   std::wstring homepage_;               // Homepage used for testing.
   bool wait_for_initial_loads_;         // Wait for initial loads to complete
                                         // in SetUp() before running test body.
   base::TimeTicks browser_launch_time_; // Time when the browser was run.
   bool dom_automation_enabled_;         // This can be set to true to have the
                                         // test run the dom automation case.
   std::wstring template_user_data_;     // See set_template_user_data().
-  HANDLE process_;                      // Handle the the first Chrome process.
+  base::ProcessHandle process_;         // Handle to the first Chrome process.
   std::wstring user_data_dir_;          // User data directory used for the test
   static bool in_process_renderer_;     // true if we're in single process mode
   bool show_window_;                    // Determines if the window is shown or
                                         // hidden. Defaults to hidden.
   bool clear_profile_;                  // If true the profile is cleared before
                                         // launching. Default is true.
   bool include_testing_id_;             // Should we supply the testing channel
                                         // id on the command line? Default is
                                         // true.
   bool use_existing_browser_;           // Duplicate of the static version.
                                         // Default value comes from static.
 
  private:
+#if defined(OS_WIN)
+  // TODO(port): make this use base::Time instead.  It would seem easy, but
+  // the code also depends on file_util::CountFilesCreatedAfter which hasn't
+  // yet been made portable.
   FILETIME test_start_time_;            // Time the test was started
                                         // (so we can check for new crash dumps)
+#endif
   static bool in_process_plugins_;
   static bool no_sandbox_;
   static bool safe_plugins_;
   static bool full_memory_dump_;        // If true, write full memory dump
                                         // during crash.
   static bool show_error_dialogs_;      // If true, a user is paying attention
                                         // to the test, so show error dialogs.
   static bool default_use_existing_browser_;  // The test connects to an already
                                               // running browser instance.
   static bool dump_histograms_on_exit_;  // Include histograms in log on exit.
   static bool enable_dcheck_;           // Enable dchecks in release mode.
   static bool silent_dump_on_dcheck_;   // Dump process memory on dcheck without
                                         // crashing.
   static bool disable_breakpad_;        // Disable breakpad on the browser.
   static int timeout_ms_;               // Timeout in milliseconds to wait
                                         // for an test to finish.
   static std::wstring js_flags_;        // Flags passed to the JS engine.
-  ::scoped_ptr<AutomationProxy> server_;
+#if defined(OS_WIN)
+  // TODO(port): restore me after AutomationProxy works.
+  scoped_ptr<AutomationProxy> server_;
+#endif
 
   MessageLoop message_loop_;            // Enables PostTask to main thread.
 
   int command_execution_timeout_ms_;
   int action_timeout_ms_;
   int action_max_timeout_ms_;
 };
 
 // These exist only to support the gTest assertion macros, and
 // shouldn't be used in normal program code.
 #ifdef UNIT_TEST
 std::ostream& operator<<(std::ostream& out, const std::wstring& wstr);
 
 template<typename T>
 std::ostream& operator<<(std::ostream& out, const ::scoped_ptr<T>& ptr) {
   return out << ptr.get();
 }
 #endif  // UNIT_TEST
 
 #endif  // CHROME_TEST_UI_UI_TEST_H_