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

chrome/test/automation/automation_proxy.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_AUTOMATION_AUTOMATION_PROXY_H__
 #define CHROME_TEST_AUTOMATION_AUTOMATION_PROXY_H__
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/scoped_ptr.h"
+#include "base/time.h"
 #include "base/thread.h"
+#include "base/waitable_event.h"
 #include "chrome/common/ipc_channel_proxy.h"
 #include "chrome/common/ipc_message.h"
 #include "chrome/common/ipc_sync_channel.h"
 #include "chrome/test/automation/automation_handle_tracker.h"
 #include "chrome/test/automation/automation_messages.h"
+
+#if defined(OS_WIN)
+// TODO(port): Enable this or equivalent.
 #include "chrome/views/dialog_delegate.h"
+#endif
 
 class AutomationRequest;
 class BrowserProxy;
 class TabProxy;
 class WindowProxy;
 
 // This is an interface that AutomationProxy-related objects can use to
 // access the message-sending abilities of the Proxy.
 class AutomationMessageSender : public IPC::Message::Sender {
  public:
   // Sends a message synchronously; it doesn't return until a response has been
   // received or a timeout has expired.
+  //
+  // Use base::kNoTimeout for no timeout.
+  //
   // The function returns true if a response is received, and returns false if
   // there is a failure or timeout (in milliseconds). If return after timeout,
   // is_timeout is set to true.
   // NOTE: When timeout occurs, the connection between proxy provider may be
   //       in transit state. Specifically, there might be pending IPC messages,
   //       and the proxy provider might be still working on the previous
   //       request.
   virtual bool SendWithTimeout(IPC::Message* message, int timeout,
                                bool* is_timeout) = 0;
 };
@@ skipping 45 matching lines @@
   // Returns false if the window count does not change before time out.
   // TODO(evanm): this function has a confusing name and semantics; it should
   // be deprecated for WaitForWindowCountToBecome.
   bool WaitForWindowCountToChange(int count, int* new_counter,
                                   int wait_timeout);
 
   // Block the thread until the window count becomes the provided value.
   // Returns true on success.
   bool WaitForWindowCountToBecome(int target_count, int wait_timeout);
 
+#if defined(OS_WIN)
+  // TODO(port): Enable when we have portable DialogDelegate.
+
   // Returns whether an app modal dialog window is showing right now (i.e., a
   // javascript alert), and what buttons it contains.
   bool GetShowingAppModalDialog(bool* showing_app_modal_dialog,
                                 views::DialogDelegate::DialogButton* button);
 
   // Simulates a click on a dialog button.
   bool ClickAppModalDialogButton(views::DialogDelegate::DialogButton button);
+#endif  // defined(OS_WIN)
 
   // Block the thread until a modal dialog is displayed. Returns true on
   // success.
   bool WaitForAppModalDialog(int wait_timeout);
 
   // Returns the BrowserProxy for the browser window at the given index,
   // transferring ownership of the pointer to the caller.
   // On failure, returns NULL.
   //
   // Use GetBrowserWindowCount to see how many browser windows you can ask for.
@@ skipping 41 matching lines @@
   // Returns the current AutomationRequest object.
   AutomationRequest* current_request() { return current_request_; }
   // Clears the current AutomationRequest object.
   void clear_current_request() { current_request_ = NULL; }
 
   // Wrapper over AutomationHandleTracker::InvalidateHandle. Receives the
   // message from AutomationProxy, unpacks the messages and routes that call to
   // the tracker.
   void InvalidateHandle(const IPC::Message& message);
 
+#if defined(OS_WIN)
+  // TODO(port): Enable when we can replace HWND.
+
   // Creates a tab that can hosted in an external process. The function
   // returns a TabProxy representing the tab as well as a window handle
   // that can be reparented in another process.
   TabProxy* CreateExternalTab(HWND parent, const gfx::Rect& dimensions,
                               unsigned int style, HWND* external_tab_container);
+#endif  // defined(OS_WIN)
 
   int command_execution_timeout_ms() const {
-    return command_execution_timeout_ms_;
+    return static_cast<int>(command_execution_timeout_.InMilliseconds());
   }
 
  private:
-  void InitializeEvents();
   void InitializeChannelID();
   void InitializeThread();
   void InitializeChannel();
   void InitializeHandleTracker();
 
   std::wstring channel_id_;
   scoped_ptr<base::Thread> thread_;
   scoped_ptr<IPC::SyncChannel> channel_;
   scoped_ptr<AutomationHandleTracker> tracker_;
 
-  HANDLE app_launched_;
-  HANDLE initial_loads_complete_;
-  HANDLE new_tab_ui_load_complete_;
+  base::WaitableEvent app_launched_;
+  base::WaitableEvent initial_loads_complete_;
+  base::WaitableEvent new_tab_ui_load_complete_;
   int new_tab_ui_load_time_;
 
   // An event that notifies when we are shutting-down.
   scoped_ptr<base::WaitableEvent> shutdown_event_;
 
   AutomationRequest* current_request_;
 
   // Delay to let the browser execute the command.
-  int command_execution_timeout_ms_;
+  base::TimeDelta command_execution_timeout_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationProxy);
 };
 
 #endif  // CHROME_TEST_AUTOMATION_AUTOMATION_PROXY_H__