Port another UI test file. Disable tests that still need to be ported.

chrome/test/automation/automation_proxy_uitest.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 <string>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
+#include "build/build_config.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/json_value_serializer.h"
+#include "chrome/common/message_box_flags.h"
 #include "chrome/test/automation/constrained_window_proxy.h"
 #include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/automation/window_proxy.h"
 #include "chrome/test/ui/ui_test.h"
 #include "chrome/views/event.h"
-#include "chrome/views/window/dialog_delegate.h"
 #include "net/base/net_util.h"
 
 class AutomationProxyTest : public UITest {
  protected:
   AutomationProxyTest() {
     dom_automation_enabled_ = true;
     launch_arguments_.AppendSwitchWithValue(switches::kLang,
                                             L"en-us");
   }
 };
@@ skipping 39 matching lines @@
     scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(-1));
     ASSERT_FALSE(window.get());
   }
 
   {
     scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(1));
     ASSERT_FALSE(window.get());
   }
 };
 
+// TODO(port): This test is for Chrome Views, which we only use on Windows.
+// Maybe split this into a _win.cc file?
+#if defined(OS_WIN)
 TEST_F(AutomationProxyVisibleTest, WindowGetViewBounds) {
   {
     scoped_ptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
     ASSERT_TRUE(browser.get());
     scoped_ptr<WindowProxy> window(browser->GetWindow());
     ASSERT_TRUE(window.get());
 
     scoped_ptr<TabProxy> tab1(browser->GetTab(0));
     ASSERT_TRUE(tab1.get());
     GURL tab1_url;
@@ skipping 55 matching lines @@
     ASSERT_TRUE(tab2.get());
     GURL tab2_new_url;
     ASSERT_TRUE(tab2->GetCurrentURL(&tab2_new_url));
 
     EXPECT_EQ(tab1_url.spec(), tab2_new_url.spec());
     EXPECT_EQ(tab2_url.spec(), tab1_new_url.spec());
 
     */
   }
 }
+#endif  // defined(OS_WIN)
 
 TEST_F(AutomationProxyTest, GetTabCount) {
   scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
 
   int tab_count = 0;
   ASSERT_TRUE(window->GetTabCount(&tab_count));
   ASSERT_EQ(1, tab_count);
 }
 
+// TODO(port): Port to mac.
+#if defined(OS_WIN) || defined(OS_LINUX)
 TEST_F(AutomationProxyTest, GetActiveTabIndex) {
   scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
 
   int active_tab_index = -1;
   ASSERT_TRUE(window->GetActiveTabIndex(&active_tab_index));
   ASSERT_EQ(0, active_tab_index);
 }
+#endif
 
 TEST_F(AutomationProxyVisibleTest, AppendTab) {
   scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
 
   int original_tab_count;
   ASSERT_TRUE(window->GetTabCount(&original_tab_count));
   ASSERT_EQ(1, original_tab_count);  // By default there are 2 tabs opened.
 
   int original_active_tab_index;
@@ skipping 104 matching lines @@
   ASSERT_FALSE(is_timeout);
 
   std::wstring title;
   ASSERT_TRUE(tab->GetTabTitle(&title));
   ASSERT_STREQ(L"Title Of Awesomeness", title.c_str());
 
   tab->NavigateToURLWithTimeout(net::FilePathToFileURL(filename),
                                 1, &is_timeout);
   ASSERT_TRUE(is_timeout);
 
-  Sleep(10);
+  PlatformThread::Sleep(10);
 }
 
 // This test is disabled. See bug 794412.
 TEST_F(AutomationProxyTest, DISABLED_NavigateToURLWithTimeout2) {
   scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
   scoped_ptr<TabProxy> tab(window->GetTab(0));
   tab.reset(window->GetTab(0));
   ASSERT_TRUE(tab.get());
 
   FilePath filename1(FilePath::FromWStringHack(test_data_directory_));
   filename1 = filename1.AppendASCII("title1.html");
 
   bool is_timeout;
   tab->NavigateToURLWithTimeout(net::FilePathToFileURL(filename1),
                                 1, &is_timeout);
   ASSERT_TRUE(is_timeout);
 
   FilePath filename2(FilePath::FromWStringHack(test_data_directory_));
   filename2 = filename2.AppendASCII("title1.html");
   tab->NavigateToURLWithTimeout(net::FilePathToFileURL(filename2),
                                 10000, &is_timeout);
   ASSERT_FALSE(is_timeout);
 
-  Sleep(10);
+  PlatformThread::Sleep(10);
 }
 
 TEST_F(AutomationProxyTest, GoBackForward) {
   scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
   scoped_ptr<TabProxy> tab(window->GetTab(0));
   ASSERT_TRUE(tab.get());
 
   std::wstring title;
   ASSERT_TRUE(tab->GetTabTitle(&title));
@@ skipping 67 matching lines @@
   ASSERT_TRUE(window->GetActiveTabIndex(&active_tab_index));
   int tab_count;
   ASSERT_TRUE(window->GetTabCount(&tab_count));
   ASSERT_EQ(0, active_tab_index);
   int at_index = 1;
   ASSERT_TRUE(window->ActivateTab(at_index));
   ASSERT_TRUE(window->GetActiveTabIndex(&active_tab_index));
   ASSERT_EQ(at_index, active_tab_index);
 }
 
+// TODO(port): Port to mac.
+#if defined(OS_WIN) || defined(OS_LINUX)
 TEST_F(AutomationProxyTest2, GetTabTitle) {
   scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
   scoped_ptr<TabProxy> tab(window->GetTab(0));
   ASSERT_TRUE(tab.get());
   std::wstring title;
   ASSERT_TRUE(tab->GetTabTitle(&title));
   ASSERT_STREQ(L"title1.html", title.c_str());
 
   tab.reset(window->GetTab(1));
   ASSERT_TRUE(tab.get());
   ASSERT_TRUE(tab->GetTabTitle(&title));
   ASSERT_STREQ(L"Title Of Awesomeness", title.c_str());
 }
+#endif
 
 TEST_F(AutomationProxyTest, Cookies) {
-  GURL url(L"http://mojo.jojo.google.com");
+  GURL url("http://mojo.jojo.google.com");
   std::string value_result;
 
   scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
 
   scoped_ptr<TabProxy> tab(window->GetTab(0));
   ASSERT_TRUE(tab.get());
 
   // test setting the cookie:
   ASSERT_TRUE(tab->SetCookie(url, "foo=baz"));
@@ skipping 11 matching lines @@
   // now, test that we can get multiple cookies:
   ASSERT_TRUE(tab->SetCookie(url, "foo1=baz1"));
   ASSERT_TRUE(tab->SetCookie(url, "foo2=baz2"));
 
   ASSERT_TRUE(tab->GetCookies(url, &value_result));
   ASSERT_FALSE(value_result.empty());
   EXPECT_TRUE(value_result.find("foo1=baz1") != std::string::npos);
   EXPECT_TRUE(value_result.find("foo2=baz2") != std::string::npos);
 }
 
+// TODO(port): Determine what tests need this and port.
+#if defined(OS_WIN)
 TEST_F(AutomationProxyTest, GetHWND) {
   scoped_ptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(browser.get());
   scoped_ptr<WindowProxy> window(browser->GetWindow());
   ASSERT_TRUE(window.get());
 
   HWND handle;
   ASSERT_TRUE(window->GetHWND(&handle));
   ASSERT_TRUE(handle);
 }
+#endif
 
 TEST_F(AutomationProxyTest, NavigateToURLAsync) {
   AutomationProxy* automation_object = automation();
   scoped_ptr<BrowserProxy> window(automation_object->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
   scoped_ptr<TabProxy> tab(window->GetTab(0));
   ASSERT_TRUE(tab.get());
 
   FilePath filename(FilePath::FromWStringHack(test_data_directory_));
   filename = filename.AppendASCII("cookie1.html");
@@ skipping 14 matching lines @@
   ASSERT_TRUE(window->ApplyAccelerator(IDC_NEW_TAB));
   ASSERT_TRUE(window->WaitForTabCountToBecome(tab_count + 1,
                                               action_timeout_ms()));
   ASSERT_TRUE(window->GetTabCount(&tab_count));
   scoped_ptr<TabProxy> tab(window->GetTab(tab_count - 1));
   ASSERT_TRUE(tab.get());
 
   std::wstring title;
   int i;
   for (i = 0; i < 10; ++i) {
-    Sleep(sleep_timeout_ms());
+    PlatformThread::Sleep(sleep_timeout_ms());
     ASSERT_TRUE(tab->GetTabTitle(&title));
     if (title == L"Destinations" || title == L"New Tab")
       break;
   }
   // If we got to 10, the new tab failed to open.
   ASSERT_NE(10, i);
 }
 
 class AutomationProxyTest4 : public UITest {
  protected:
@@ skipping 80 matching lines @@
   std::wstring document1_;
 };
 
 std::wstring CreateJSStringForDOMQuery(const std::wstring& id) {
   std::wstring jscript(L"window.domAutomationController");
   StringAppendF(&jscript, L".send(document.getElementById('%ls').nodeName);",
                 id.c_str());
   return jscript;
 }
 
+// TODO(port): Port to mac.
+#if defined(OS_WIN) || defined(OS_LINUX)
 TEST_F(AutomationProxyTest3, FrameDocumentCanBeAccessed) {
   scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
 
   scoped_ptr<TabProxy> tab(window->GetTab(0));
   ASSERT_TRUE(tab.get());
 
   std::wstring actual;
   std::wstring xpath1 = L"";  // top level frame
   std::wstring jscript1 = CreateJSStringForDOMQuery(L"myinput");
@@ skipping 17 matching lines @@
 #if 0
   // Open a new Destinations tab to execute script inside.
   window->ApplyAccelerator(IDC_NEWTAB);
   tab.reset(window->GetTab(1));
   ASSERT_TRUE(tab.get());
   ASSERT_TRUE(window->ActivateTab(1));
 
   std::wstring title;
   int i;
   for (i = 0; i < 10; ++i) {
-    Sleep(sleep_timeout_ms());
+    PlatformThread::Sleep(sleep_timeout_ms());
     ASSERT_TRUE(tab->GetTabTitle(&title));
     if (title == L"Destinations")
       break;
   }
   // If we got to 10, the new tab failed to open.
   ASSERT_NE(10, i);
   ASSERT_FALSE(tab->ExecuteAndExtractString(xpath1, jscript1, &actual));
 #endif
 }
+#endif  // defined(OS_WIN) || defined(OS_LINUX)
 
+// TODO(port): Need to port constrained_window_proxy.* first.
+#if defined(OS_WIN)
 TEST_F(AutomationProxyTest, DISABLED_ConstrainedWindowTest) {
   scoped_ptr<BrowserProxy> window(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(window.get());
 
   scoped_ptr<TabProxy> tab(window->GetTab(0));
   tab.reset(window->GetTab(0));
   ASSERT_TRUE(tab.get());
 
   FilePath filename(FilePath::FromWStringHack(test_data_directory_));
   filename = filename.AppendASCII("constrained_files");
@@ skipping 50 matching lines @@
   ConstrainedWindowProxy* cwindow = tab->GetConstrainedWindow(0);
   ASSERT_TRUE(cwindow);
 
   gfx::Rect rect;
   bool is_timeout = false;
   ASSERT_TRUE(cwindow->GetBoundsWithTimeout(&rect, 1000, &is_timeout));
   ASSERT_FALSE(is_timeout);
   ASSERT_NE(20, rect.x());
   ASSERT_NE(20, rect.y());
 }
+#endif  // defined(OS_WIN)
 
+
+// TODO(port): Remove HWND if possible.
+#if defined(OS_WIN)
 // Creates a top-level window, makes the |external_tab_window| a child
 // of that window and displays them.  After displaying the windows the function
 // enters a message loop that processes window messages as well as calling
 // MessageLoop::current()->RunAllPending() to process any incoming IPC messages.
 // The time_to_wait parameter is the maximum time the loop will run.
 // To end the loop earlier, post a quit message to the thread.
 bool ExternalTabHandler(HWND external_tab_window, int time_to_wait) {
   static const wchar_t class_name[] = L"External_Tab_UI_Test_Class";
   static const wchar_t window_title[] = L"External Tab Tester";
 
@@ skipping 101 matching lines @@
 
   const std::string& target() const {
     return target_;
   }
 
   // Waits for the DidNavigate event to be processed on the current thread.
   // Returns true if the event arrived, false if there was a timeout.
   bool WaitForNavigationComplete(int max_time_to_wait_ms) {
     base::TimeTicks start(base::TimeTicks::Now());
     while (!navigate_complete_) {
-      Sleep(50);
+      PlatformThread::Sleep(50);
       MessageLoop::current()->RunAllPending();
       base::TimeTicks end(base::TimeTicks::Now());
       base::TimeDelta delta = end - start;
       if (static_cast<int>(delta.InMilliseconds()) > max_time_to_wait_ms)
         return false;
     }
     return true;
   }
 
  protected:
@@ skipping 32 matching lines @@
 TEST_F(ExternalTabTestType, CreateExternalTab) {
   HWND external_tab_container = NULL;
   scoped_ptr<TabProxy> tab(automation()->CreateExternalTab(NULL, gfx::Rect(),
       WS_POPUP, false, &external_tab_container));
   EXPECT_TRUE(tab != NULL);
   EXPECT_NE(FALSE, ::IsWindow(external_tab_container));
   if (tab != NULL) {
     tab->NavigateInExternalTab(GURL(L"http://www.google.com"));
     EXPECT_EQ(true, ExternalTabHandler(external_tab_container, 1000));
     // Since the tab goes away lazily, wait a bit
-    Sleep(1000);
+    PlatformThread::Sleep(1000);
     EXPECT_FALSE(tab->is_valid());
   }
 }
 
 TEST_F(ExternalTabTestType, IncognitoMode) {
   HWND external_tab_container = NULL;
-  GURL url(L"http://anatomyofmelancholy.net");
+  GURL url("http://anatomyofmelancholy.net");
   std::string value_result;
 
   // Create incognito tab
   scoped_ptr<TabProxy> tab(automation()->CreateExternalTab(NULL, gfx::Rect(),
       WS_POPUP, true, &external_tab_container));
   EXPECT_TRUE(tab->SetCookie(url, "robert=burton; "
                                   "expires=Thu, 13 Oct 2011 05:04:03 UTC;"));
   EXPECT_TRUE(tab->GetCookieByName(url, "robert", &value_result));
   EXPECT_EQ("burton", value_result);
   tab.reset(NULL);
@@ skipping 37 matching lines @@
                                        "null", "*");
 
     EXPECT_TRUE(ExternalTabHandler(external_tab_container, 10000));
     EXPECT_NE(0, proxy->messages_received());
 
     if (proxy->messages_received()) {
       EXPECT_EQ("Hello from gtest", proxy->message());
     }
   }
 }
+#endif  // defined(OS_WIN)
 
+// TODO(port): Need to port autocomplete_edit_proxy.* first.
+#if defined(OS_WIN)
 TEST_F(AutomationProxyTest, AutocompleteGetSetText) {
   scoped_ptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(browser.get());
   scoped_ptr<AutocompleteEditProxy> edit(
       browser->GetAutocompleteEdit());
   ASSERT_TRUE(edit.get());
   EXPECT_TRUE(edit->is_valid());
   const std::wstring text_to_set = L"Lollerskates";
   std::wstring actual_text;
   EXPECT_TRUE(edit->SetText(text_to_set));
@@ skipping 40 matching lines @@
   EXPECT_TRUE(edit->is_valid());
   EXPECT_TRUE(edit->SetText(L"Roflcopter"));
   EXPECT_TRUE(edit->WaitForQuery(30000));
   bool query_in_progress;
   EXPECT_TRUE(edit->IsQueryInProgress(&query_in_progress));
   EXPECT_FALSE(query_in_progress);
   std::vector<AutocompleteMatchData> matches;
   EXPECT_TRUE(edit->GetAutocompleteMatches(&matches));
   EXPECT_FALSE(matches.empty());
 }
+#endif  // defined(OS_WIN)
 
-// Disabled because flacky see bug #5314.
+// Disabled because flaky see bug #5314.
 TEST_F(AutomationProxyTest, DISABLED_AppModalDialogTest) {
   scoped_ptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
   ASSERT_TRUE(browser.get());
   scoped_ptr<TabProxy> tab(browser->GetTab(0));
   tab.reset(browser->GetTab(0));
   ASSERT_TRUE(tab.get());
 
   bool modal_dialog_showing = false;
   MessageBoxFlags::DialogButton button = MessageBoxFlags::DIALOGBUTTON_NONE;
   EXPECT_TRUE(automation()->GetShowingAppModalDialog(&modal_dialog_showing,
@@ skipping 89 matching lines @@
 
   scoped_ptr<TabProxy> tab(window->GetTab(0));
   ASSERT_TRUE(tab.get());
 
   FilePath filename(FilePath::FromWStringHack(test_data_directory_));
   filename = filename.AppendASCII("dom_automation_test_with_popup.html");
 
   tab->NavigateToURL(net::FilePathToFileURL(filename));
 
   // Allow some time for the popup to show up and close.
-  Sleep(2000);
+  PlatformThread::Sleep(2000);
 
   std::wstring expected(L"string");
   std::wstring jscript = CreateJSString(L"\"" + expected + L"\"");
   std::wstring actual;
   ASSERT_TRUE(tab->ExecuteAndExtractString(L"", jscript, &actual));
   ASSERT_STREQ(expected.c_str(), actual.c_str());
 }