Make basic bits of chrome/test/automation build on Linux.

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/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;
 
 bool BrowserProxy::ActivateTab(int tab_index) {
-  return ActivateTabWithTimeout(tab_index, INFINITE, NULL);
+  return ActivateTabWithTimeout(tab_index, base::kNoTimeout, NULL);
 }
 
 bool BrowserProxy::ActivateTabWithTimeout(int tab_index, uint32 timeout_ms,
                                           bool* is_timeout) {
   if (!is_valid())
     return false;
 
   int activate_tab_response = -1;
 
   sender_->SendWithTimeout(new AutomationMsg_ActivateTab(
       0, handle_, tab_index, &activate_tab_response), timeout_ms, is_timeout);
 
   if (activate_tab_response >= 0)
     return true;
 
   return false;
 }
 
 bool BrowserProxy::BringToFront() {
-  return BringToFrontWithTimeout(INFINITE, NULL);
+  return BringToFrontWithTimeout(base::kNoTimeout, NULL);
 }
 
 bool BrowserProxy::BringToFrontWithTimeout(uint32 timeout_ms,
                                            bool* is_timeout) {
   if (!is_valid())
     return false;
 
   bool succeeded = false;
 
   sender_->SendWithTimeout(new AutomationMsg_BringBrowserToFront(
@@ skipping 21 matching lines @@
     return false;
 
   int append_tab_response = -1;
 
   sender_->Send(new AutomationMsg_AppendTab(0, handle_, tab_url,
                                             &append_tab_response));
   return append_tab_response >= 0;
 }
 
 bool BrowserProxy::GetActiveTabIndex(int* active_tab_index) const {
-  return GetActiveTabIndexWithTimeout(active_tab_index, INFINITE, NULL);
+  return GetActiveTabIndexWithTimeout(active_tab_index, base::kNoTimeout, NULL);
 }
 
 bool BrowserProxy::GetActiveTabIndexWithTimeout(int* active_tab_index,
                                                 uint32 timeout_ms,
                                                 bool* is_timeout) const {
   if (!is_valid())
     return false;
 
   if (!active_tab_index) {
     NOTREACHED();
@@ skipping 22 matching lines @@
   int handle = 0;
 
   sender_->Send(new AutomationMsg_Tab(0, handle_, tab_index, &handle));
   if (!handle)
     return NULL;
 
   return new TabProxy(sender_, tracker_, handle);
 }
 
 TabProxy* BrowserProxy::GetActiveTab() const {
-  return GetActiveTabWithTimeout(INFINITE, NULL);
+  return GetActiveTabWithTimeout(base::kNoTimeout, NULL);
 }
 
 TabProxy* BrowserProxy::GetActiveTabWithTimeout(uint32 timeout_ms,
                                                 bool* is_timeout) const {
   int active_tab_index;
   if (!GetActiveTabIndexWithTimeout(&active_tab_index, timeout_ms, is_timeout))
     return NULL;
   return GetTab(active_tab_index);
 }
 
 bool BrowserProxy::GetTabCount(int* num_tabs) const {
-  return GetTabCountWithTimeout(num_tabs, INFINITE, NULL);
+  return GetTabCountWithTimeout(num_tabs, base::kNoTimeout, NULL);
 }
 
 bool BrowserProxy::GetTabCountWithTimeout(int* num_tabs, uint32 timeout_ms,
                                           bool* is_timeout) const {
   if (!is_valid())
     return false;
 
   if (!num_tabs) {
     NOTREACHED();
     return false;
@@ skipping 18 matching lines @@
     return false;
 
   return sender_->Send(
       new AutomationMsg_ApplyAccelerator(0, handle_, id));
 }
 
 bool BrowserProxy::SimulateDrag(const POINT& start,
                                 const POINT& end,
                                 int flags,
                                 bool press_escape_en_route) {
-  return SimulateDragWithTimeout(start, end, flags, INFINITE, NULL,
+  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())
@@ skipping 200 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);
 }