Move automation/ui_controls to ui/ui_controls

chrome/browser/ui/gtk/tabs/dragged_tab_controller_gtk.cc

 // Copyright (c) 2011 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/ui/gtk/tabs/dragged_tab_controller_gtk.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/i18n/rtl.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/app_modal_dialogs/message_box_handler.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/gtk/browser_window_gtk.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/tabs/dragged_view_gtk.h"
 #include "chrome/browser/ui/gtk/tabs/tab_strip_gtk.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
+#include "ui/base/gtk/gtk_screen_util.h"
 #include "ui/gfx/screen.h"
 
 using content::OpenURLParams;
 using content::WebContents;
 
 namespace {
 
 // Delay, in ms, during dragging before we bring a window to front.
 const int kBringToFrontDelay = 750;
 
@@ skipping 335 matching lines @@
     return NULL;
 
   return GetTabStripIfItContains(other_tabstrip, screen_point);
 }
 
 TabStripGtk* DraggedTabControllerGtk::GetTabStripIfItContains(
     TabStripGtk* tabstrip, const gfx::Point& screen_point) const {
   // Make sure the specified screen point is actually within the bounds of the
   // specified tabstrip...
   gfx::Rect tabstrip_bounds =
-      gtk_util::GetWidgetScreenBounds(tabstrip->tabstrip_.get());
+      ui::GetWidgetScreenBounds(tabstrip->tabstrip_.get());
   if (screen_point.x() < tabstrip_bounds.right() &&
       screen_point.x() >= tabstrip_bounds.x()) {
     // TODO(beng): make this be relative to the start position of the mouse for
     // the source TabStrip.
     int upper_threshold = tabstrip_bounds.bottom() + kVerticalDetachMagnetism;
     int lower_threshold = tabstrip_bounds.y() - kVerticalDetachMagnetism;
     if (screen_point.y() >= lower_threshold &&
         screen_point.y() <= upper_threshold) {
       return tabstrip;
     }
@@ skipping 24 matching lines @@
     tab_count += drag_data_->size();
     mini_tab_count += drag_data_->mini_tab_count();
   }
 
   double unselected_width = 0, selected_width = 0;
   attached_tabstrip_->GetDesiredTabWidths(tab_count, mini_tab_count,
                                           &unselected_width, &selected_width);
 
   GtkWidget* parent_window = gtk_widget_get_parent(
       gtk_widget_get_parent(attached_tabstrip_->tabstrip_.get()));
-  gfx::Rect window_bounds = gtk_util::GetWidgetScreenBounds(parent_window);
+  gfx::Rect window_bounds = ui::GetWidgetScreenBounds(parent_window);
   dragged_view_->Attach(static_cast<int>(floor(selected_width + 0.5)),
                         TabGtk::GetMiniWidth(), window_bounds.width());
 
   if (attached_dragged_tabs.size() == 0) {
     // There is no tab in |attached_tabstrip| that corresponds to the dragged
     // TabContents. We must now create one.
 
     // Remove ourselves as the delegate now that the dragged TabContents is
     // being inserted back into a Browser.
     for (size_t i = 0; i < drag_data_->size(); ++i) {
@@ skipping 62 matching lines @@
   // Detaching resets the delegate, but we still want to be the delegate.
   for (size_t i = 0; i < drag_data_->size(); ++i)
     drag_data_->get(i)->contents_->web_contents()->SetDelegate(this);
 
   attached_tabstrip_ = NULL;
 }
 
 gfx::Point DraggedTabControllerGtk::ConvertScreenPointToTabStripPoint(
     TabStripGtk* tabstrip, const gfx::Point& screen_point) {
   gfx::Point tabstrip_screen_point =
-      gtk_util::GetWidgetScreenPosition(tabstrip->tabstrip_.get());
+      ui::GetWidgetScreenPosition(tabstrip->tabstrip_.get());
   return screen_point.Subtract(tabstrip_screen_point);
 }
 
 gfx::Rect DraggedTabControllerGtk::GetDraggedViewTabStripBounds(
     const gfx::Point& screen_point) {
   gfx::Point client_point =
       ConvertScreenPointToTabStripPoint(attached_tabstrip_, screen_point);
   gfx::Size tab_size = dragged_view_->attached_tab_size();
   return gfx::Rect(client_point.x(), client_point.y(),
                    dragged_view_->GetTotalWidthInTabStrip(), tab_size.height());
@@ skipping 51 matching lines @@
 
 gfx::Point DraggedTabControllerGtk::GetDraggedViewPoint(
     const gfx::Point& screen_point) {
   int x = screen_point.x() -
       dragged_view_->GetWidthInTabStripUpToMousePointer();
   int y = screen_point.y() - mouse_offset_.y();
 
   // If we're not attached, we just use x and y from above.
   if (attached_tabstrip_) {
     gfx::Rect tabstrip_bounds =
-        gtk_util::GetWidgetScreenBounds(attached_tabstrip_->tabstrip_.get());
+        ui::GetWidgetScreenBounds(attached_tabstrip_->tabstrip_.get());
     // Snap the dragged tab to the tabstrip if we are attached, detaching
     // only when the mouse position (screen_point) exceeds the screen bounds
     // of the tabstrip.
     if (x < tabstrip_bounds.x() && screen_point.x() >= tabstrip_bounds.x())
       x = tabstrip_bounds.x();
 
     gfx::Size tab_size = dragged_view_->attached_tab_size();
     int vertical_drag_magnetism = tab_size.height() * 2;
     int vertical_detach_point = tabstrip_bounds.y() - vertical_drag_magnetism;
     if (y < tabstrip_bounds.y() && screen_point.y() >= vertical_detach_point)
@@ skipping 223 matching lines @@
   //
   // We use the requested bounds instead of the allocation because the
   // allocation is relative to the first windowed widget ancestor of the tab.
   // Because of this, we can't use the tabs allocation to get the screen bounds.
   std::vector<TabGtk*> tabs = GetTabsMatchingDraggedContents(
       attached_tabstrip_);
   TabGtk* tab = !base::i18n::IsRTL() ? tabs.front() : tabs.back();
   gfx::Rect bounds = tab->GetRequisition();
   GtkWidget* widget = tab->widget();
   GtkWidget* parent = gtk_widget_get_parent(widget);
-  gfx::Point point = gtk_util::GetWidgetScreenPosition(parent);
+  gfx::Point point = ui::GetWidgetScreenPosition(parent);
   bounds.Offset(point);
 
   return gfx::Rect(bounds.x(), bounds.y(),
                    dragged_view_->GetTotalWidthInTabStrip(), bounds.height());
 }
 
 void DraggedTabControllerGtk::HideWindow() {
   GtkWidget* tabstrip = source_tabstrip_->widget();
   GtkWindow* window = platform_util::GetTopLevel(tabstrip);
   gtk_widget_hide(GTK_WIDGET(window));
@@ skipping 59 matching lines @@
 
 bool DraggedTabControllerGtk::AreTabsConsecutive() {
   for (size_t i = 1; i < drag_data_->size(); ++i) {
     if (drag_data_->get(i - 1)->source_model_index_ + 1 !=
         drag_data_->get(i)->source_model_index_) {
       return false;
     }
   }
   return true;
 }