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

chrome/test/automation/browser_proxy.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/automation/browser_proxy.h"
 
 #include <vector>
 
 #include "base/logging.h"
+#include "base/platform_thread.h"
 #include "base/time.h"
 #include "chrome/test/automation/autocomplete_edit_proxy.h"
 #include "chrome/test/automation/automation_constants.h"
 #include "chrome/test/automation/automation_messages.h"
 #include "chrome/test/automation/automation_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
@@ skipping 144 matching lines @@
 }
 
 bool BrowserProxy::ApplyAccelerator(int id) {
   if (!is_valid())
     return false;
 
   return sender_->Send(
       new AutomationMsg_ApplyAccelerator(0, handle_, id));
 }
 
+#if defined(OS_WIN)
+// TODO(port): Replace POINT.
 bool BrowserProxy::SimulateDrag(const POINT& start,
                                 const POINT& end,
                                 int flags,
                                 bool press_escape_en_route) {
   return SimulateDragWithTimeout(start, end, flags, base::kNoTimeout, NULL,
                                  press_escape_en_route);
 }
 
 bool BrowserProxy::SimulateDragWithTimeout(const POINT& start,
                                            const POINT& end,
                                            int flags,
                                            uint32 timeout_ms,
                                            bool* is_timeout,
                                            bool press_escape_en_route) {
   if (!is_valid())
     return false;
 
   std::vector<POINT> drag_path;
   drag_path.push_back(start);
   drag_path.push_back(end);
 
   bool result = false;
 
   sender_->SendWithTimeout(new AutomationMsg_WindowDrag(
       0, handle_, drag_path, flags, press_escape_en_route, &result),
       timeout_ms, is_timeout);
 
   return result;
 }
+#endif  // defined(OS_WIN)
 
 bool BrowserProxy::WaitForTabCountToChange(int count, int* new_count,
                                            int wait_timeout) {
   const TimeTicks start = TimeTicks::Now();
   const TimeDelta timeout = TimeDelta::FromMilliseconds(wait_timeout);
   while (TimeTicks::Now() - start < timeout) {
-    Sleep(automation::kSleepTime);
+    PlatformThread::Sleep(automation::kSleepTime);
     bool is_timeout;
     bool succeeded = GetTabCountWithTimeout(new_count, wait_timeout,
                                             &is_timeout);
     if (!succeeded)
       return false;
     if (count != *new_count)
       return true;
   }
   // If we get here, the tab count hasn't changed.
   return false;
 }
 
 bool BrowserProxy::WaitForTabCountToBecome(int count, int wait_timeout) {
   const TimeTicks start = TimeTicks::Now();
   const TimeDelta timeout = TimeDelta::FromMilliseconds(wait_timeout);
   while (TimeTicks::Now() - start < timeout) {
-    Sleep(automation::kSleepTime);
+    PlatformThread::Sleep(automation::kSleepTime);
     bool is_timeout;
     int new_count;
     bool succeeded = GetTabCountWithTimeout(&new_count, wait_timeout,
                                             &is_timeout);
     if (!succeeded)
       return false;
     if (count == new_count)
       return true;
   }
   // If we get here, the tab count doesn't match.
   return false;
 }
 
 bool BrowserProxy::WaitForTabToBecomeActive(int tab,
                                             int wait_timeout) {
   const TimeTicks start = TimeTicks::Now();
   const TimeDelta timeout = TimeDelta::FromMilliseconds(wait_timeout);
   while (TimeTicks::Now() - start < timeout) {
-    Sleep(automation::kSleepTime);
+    PlatformThread::Sleep(automation::kSleepTime);
     int active_tab;
     if (GetActiveTabIndex(&active_tab) && active_tab == tab)
       return true;
   }
   // If we get here, the active tab hasn't changed.
   return false;
 }
 
 bool BrowserProxy::OpenFindInPage() {
   if (!is_valid())
@@ skipping 17 matching lines @@
 
   if (!is_visible) {
     NOTREACHED();
     return false;
   }
 
   return sender_->Send(
       new AutomationMsg_FindWindowVisibility(0, handle_, is_visible));
 }
 
+#if defined(OS_WIN)
+// TODO(port): Replace HWND.
 bool BrowserProxy::GetHWND(HWND* handle) const {
   if (!is_valid())
     return false;
 
   if (!handle) {
     NOTREACHED();
     return false;
   }
 
   return sender_->Send(new AutomationMsg_WindowHWND(0, handle_, handle));
 }
+#endif  // defined(OS_WIN)
 
 bool BrowserProxy::RunCommand(int browser_command) const {
   if (!is_valid())
     return false;
 
   bool result = false;
 
   sender_->Send(new AutomationMsg_WindowExecuteCommand(0, handle_,
                                                        browser_command,
                                                        &result));
@@ skipping 85 matching lines @@
   int autocomplete_edit_handle = 0;
 
   sender_->Send(new AutomationMsg_AutocompleteEditForBrowser(
       0, handle_, &handle_ok, &autocomplete_edit_handle));
 
   if (!handle_ok)
     return NULL;
 
   return new AutocompleteEditProxy(sender_, tracker_, autocomplete_edit_handle);
 }