Automated ui test porting + cleanup:...

chrome/browser/automation/automation_provider_win.cc

 // Copyright (c) 2009 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/browser/automation/automation_provider.h"
 
 #include "chrome/browser/automation/ui_controls.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/external_tab_container.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
@@ skipping 56 matching lines @@
                         reinterpret_cast<LPARAM>(window))) {
     // We enumerated all the windows and did not find the foreground window,
     // it is not our window, ignore it.
     *handle = 0;
     return;
   }
 
   *handle = window_tracker_->Add(window);
 }
 
-void AutomationProvider::GetWindowHWND(int handle, HWND* win32_handle) {
-  *win32_handle = window_tracker_->GetResource(handle);
-}
-
 void AutomationProvider::WindowGetViewBounds(int handle, int view_id,
                                              bool screen_coordinates,
                                              bool* success,
                                              gfx::Rect* bounds) {
   *success = false;
   if (window_tracker_->ContainsHandle(handle)) {
     gfx::NativeWindow window = window_tracker_->GetResource(handle);
     views::RootView* root_view = views::WidgetWin::FindRootView(window);
     if (root_view) {
       views::View* view = root_view->GetViewByID(view_id);
@@ skipping 86 matching lines @@
   }
 
  private:
   AutomationProvider* provider_;
   IPC::Message* reply_message_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowDragResponseTask);
 };
 
 void AutomationProvider::WindowSimulateDrag(int handle,
-                                            std::vector<POINT> drag_path,
+                                            std::vector<gfx::Point> drag_path,
                                             int flags,
                                             bool press_escape_en_route,
                                             IPC::Message* reply_message) {
-  bool succeeded = false;
   if (browser_tracker_->ContainsHandle(handle) && (drag_path.size() > 1)) {
     gfx::NativeWindow window =
         browser_tracker_->GetResource(handle)->window()->GetNativeHandle();
-    succeeded = true;
 
     UINT down_message = 0;
     UINT up_message = 0;
     WPARAM wparam_flags = 0;
     if (flags & views::Event::EF_SHIFT_DOWN)
       wparam_flags |= MK_SHIFT;
     if (flags & views::Event::EF_CONTROL_DOWN)
       wparam_flags |= MK_CONTROL;
     if (flags & views::Event::EF_LEFT_BUTTON_DOWN) {
       wparam_flags |= MK_LBUTTON;
       down_message = WM_LBUTTONDOWN;
       up_message = WM_LBUTTONUP;
     }
     if (flags & views::Event::EF_MIDDLE_BUTTON_DOWN) {
       wparam_flags |= MK_MBUTTON;
       down_message = WM_MBUTTONDOWN;
       up_message = WM_MBUTTONUP;
     }
     if (flags & views::Event::EF_RIGHT_BUTTON_DOWN) {
       wparam_flags |= MK_RBUTTON;
       down_message = WM_LBUTTONDOWN;
       up_message = WM_LBUTTONUP;
     }
 
     Browser* browser = browser_tracker_->GetResource(handle);
     DCHECK(browser);
     HWND top_level_hwnd =
         reinterpret_cast<HWND>(browser->window()->GetNativeHandle());
-    POINT temp = drag_path[0];
+    POINT temp = drag_path[0].ToPOINT();
     MapWindowPoints(top_level_hwnd, HWND_DESKTOP, &temp, 1);
     MoveMouse(temp);
     SendMessage(top_level_hwnd, down_message, wparam_flags,
-                MAKELPARAM(drag_path[0].x, drag_path[0].y));
+                MAKELPARAM(drag_path[0].x(), drag_path[0].y()));
     for (int i = 1; i < static_cast<int>(drag_path.size()); ++i) {
-      temp = drag_path[i];
+      temp = drag_path[i].ToPOINT();
       MapWindowPoints(top_level_hwnd, HWND_DESKTOP, &temp, 1);
       MoveMouse(temp);
       SendMessage(top_level_hwnd, WM_MOUSEMOVE, wparam_flags,
-                  MAKELPARAM(drag_path[i].x, drag_path[i].y));
+                  MAKELPARAM(drag_path[i].x(), drag_path[i].y()));
     }
-    POINT end = drag_path[drag_path.size() - 1];
+    POINT end = drag_path[drag_path.size() - 1].ToPOINT();
     MapWindowPoints(top_level_hwnd, HWND_DESKTOP, &end, 1);
     MoveMouse(end);
 
     if (press_escape_en_route) {
       // Press Escape.
       ui_controls::SendKeyPress(window, VK_ESCAPE,
                                ((flags & views::Event::EF_CONTROL_DOWN)
                                 == views::Event::EF_CONTROL_DOWN),
                                ((flags & views::Event::EF_SHIFT_DOWN) ==
                                 views::Event::EF_SHIFT_DOWN),
                                ((flags & views::Event::EF_ALT_DOWN) ==
                                 views::Event::EF_ALT_DOWN));
     }
     SendMessage(top_level_hwnd, up_message, wparam_flags,
                 MAKELPARAM(end.x, end.y));
 
     MessageLoop::current()->PostTask(FROM_HERE, new InvokeTaskLaterTask(
         new WindowDragResponseTask(this, reply_message)));
   } else {
-    AutomationMsg_WindowDrag::WriteReplyParams(reply_message, true);
+    AutomationMsg_WindowDrag::WriteReplyParams(reply_message, false);
     Send(reply_message);
   }
 }
 
 void AutomationProvider::GetFocusedViewID(int handle, int* view_id) {
   *view_id = -1;
   if (window_tracker_->ContainsHandle(handle)) {
     HWND hwnd = window_tracker_->GetResource(handle);
     views::FocusManager* focus_manager =
         views::FocusManager::GetFocusManagerForNativeView(hwnd);
@@ skipping 16 matching lines @@
           browser->window()->GetBrowserWindowTesting();
       BookmarkBarView* bookmark_bar = testing->GetBookmarkBarView();
       if (bookmark_bar) {
         *animating = bookmark_bar->IsAnimating();
         *visible = browser->window()->IsBookmarkBarVisible();
       }
     }
   }
 }
 
+void AutomationProvider::GetWindowBounds(int handle, gfx::Rect* bounds,
+                                         bool* success) {
+  *success = false;
+  HWND hwnd = window_tracker_->GetResource(handle);
+  if (hwnd) {
+    *success = true;
+    WINDOWPLACEMENT window_placement;
+    GetWindowPlacement(hwnd, &window_placement);
+    *bounds = window_placement.rcNormalPosition;
+  }
+}
+
 void AutomationProvider::SetWindowBounds(int handle, const gfx::Rect& bounds,
                                          bool* success) {
   *success = false;
   if (window_tracker_->ContainsHandle(handle)) {
     HWND hwnd = window_tracker_->GetResource(handle);
     if (::MoveWindow(hwnd, bounds.x(), bounds.y(), bounds.width(),
                      bounds.height(), true)) {
       *success = true;
     }
   }
 }
 
 void AutomationProvider::SetWindowVisible(int handle, bool visible,
                                           bool* result) {
   if (window_tracker_->ContainsHandle(handle)) {
     HWND hwnd = window_tracker_->GetResource(handle);
     ::ShowWindow(hwnd, visible ? SW_SHOW : SW_HIDE);
     *result = true;
   } else {
     *result = false;
   }
 }
 
 void AutomationProvider::ActivateWindow(int handle) {
   if (window_tracker_->ContainsHandle(handle)) {
     ::SetActiveWindow(window_tracker_->GetResource(handle));
   }
 }
 
+void AutomationProvider::IsWindowMaximized(int handle, bool* is_maximized,
+                                           bool* success) {
+  *success = false;
+
+  HWND hwnd = window_tracker_->GetResource(handle);
+  if (hwnd) {
+    *success = true;
+    WINDOWPLACEMENT window_placement;
+    GetWindowPlacement(hwnd, &window_placement);
+    *is_maximized = (window_placement.showCmd == SW_MAXIMIZE);
+  }
+}
+
 void AutomationProvider::GetTabHWND(int handle, HWND* tab_hwnd) {
   *tab_hwnd = NULL;
 
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     *tab_hwnd = tab->tab_contents()->GetNativeView();
   }
 }
 
 void AutomationProvider::CreateExternalTab(
@@ skipping 69 matching lines @@
 ExternalTabContainer* AutomationProvider::GetExternalTabForHandle(int handle) {
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     return ExternalTabContainer::GetContainerForTab(
         tab->tab_contents()->GetNativeView());
   }
 
   return NULL;
 }
 
-void AutomationProvider::OnTabReposition(
-    int tab_handle, const IPC::Reposition_Params& params) {
-  if (!tab_tracker_->ContainsHandle(tab_handle))
-    return;
-
-  if (!IsWindow(params.window))
-    return;
-
-  unsigned long process_id = 0;
-  unsigned long thread_id = 0;
-
-  thread_id = GetWindowThreadProcessId(params.window, &process_id);
-
-  if (thread_id != GetCurrentThreadId()) {
-    NOTREACHED();
-    return;
-  }
-
-  SetWindowPos(params.window, params.window_insert_after, params.left,
-               params.top, params.width, params.height, params.flags);
-
-  if (params.set_parent) {
-    if (IsWindow(params.parent_window)) {
-      if (!SetParent(params.window, params.parent_window))
-        DLOG(WARNING) << "SetParent failed. Error 0x%x" << GetLastError();
-    }
-  }
-}
-
 void AutomationProvider::OnForwardContextMenuCommandToChrome(int tab_handle,
                                                              int command) {
   if (tab_tracker_->ContainsHandle(tab_handle)) {
     NavigationController* tab = tab_tracker_->GetResource(tab_handle);
     if (!tab) {
       NOTREACHED();
       return;
     }
 
     TabContents* tab_contents = tab->tab_contents();
@@ skipping 28 matching lines @@
     TabContents* tab_contents = external_tab_container->tab_contents();
     *tab_handle = external_tab_container->tab_handle();
     external_tab_container->set_tab_handle(*tab_handle);
     *tab_container_window = external_tab_container->GetNativeView();
     *tab_window = tab_contents->GetNativeView();
   } else {
     external_tab_container->Uninitialize();
   }
 }
 
+void AutomationProvider::TerminateSession(int handle, bool* success) {
+  *success = false;
+
+  if (browser_tracker_->ContainsHandle(handle)) {
+    Browser* browser = browser_tracker_->GetResource(handle);
+    HWND window = browser->window()->GetNativeHandle();
+    *success = (::PostMessageW(window, WM_ENDSESSION, 0, 0) == TRUE);
+  }
+}