Move chrome::HostDesktopType to ui::HostDesktopType

chrome/browser/ui/views/tabs/tab_drag_controller.cc

 // Copyright (c) 2012 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/views/tabs/tab_drag_controller.h"
 
 #include <math.h>
 #include <set>
 
 #include "base/auto_reset.h"
@@ skipping 179 matching lines @@
 const int TabDragController::kTouchVerticalDetachMagnetism = 50;
 
 // static
 const int TabDragController::kVerticalDetachMagnetism = 15;
 
 TabDragController::TabDragController()
     : event_source_(EVENT_SOURCE_MOUSE),
       source_tabstrip_(NULL),
       attached_tabstrip_(NULL),
       screen_(NULL),
-      host_desktop_type_(chrome::HOST_DESKTOP_TYPE_NATIVE),
+      host_desktop_type_(ui::HOST_DESKTOP_TYPE_NATIVE),
       can_release_capture_(true),
       offset_to_width_ratio_(0),
-      old_focused_view_id_(
-          views::ViewStorage::GetInstance()->CreateStorageID()),
+      old_focused_view_id_(views::ViewStorage::GetInstance()
+                               ->CreateStorageID()),
       last_move_screen_loc_(0),
       started_drag_(false),
       active_(true),
       source_tab_index_(std::numeric_limits<size_t>::max()),
       initial_move_(true),
       detach_behavior_(DETACHABLE),
       move_behavior_(REORDER),
       mouse_move_direction_(0),
       is_dragging_window_(false),
       is_dragging_new_browser_(false),
@@ skipping 53 matching lines @@
   // Do not release capture when transferring capture between widgets on:
   // - Desktop Linux
   //     Mouse capture is not synchronous on desktop Linux. Chrome makes
   //     transferring capture between widgets without releasing capture appear
   //     synchronous on desktop Linux, so use that.
   // - Ash
   //     Releasing capture on Ash cancels gestures so avoid it.
 #if defined(OS_LINUX)
   can_release_capture_ = false;
 #else
-  can_release_capture_ =
-      (host_desktop_type_ != chrome::HOST_DESKTOP_TYPE_ASH);
+  can_release_capture_ = (host_desktop_type_ != ui::HOST_DESKTOP_TYPE_ASH);
 #endif
   start_point_in_screen_ = gfx::Point(source_tab_offset, mouse_offset.y());
   views::View::ConvertPointToScreen(source_tab, &start_point_in_screen_);
   event_source_ = event_source;
   mouse_offset_ = mouse_offset;
   move_behavior_ = move_behavior;
   last_point_in_screen_ = start_point_in_screen_;
   last_move_screen_loc_ = start_point_in_screen_.x();
   initial_tab_positions_ = source_tabstrip->GetTabXCoordinates();
 
@@ skipping 307 matching lines @@
   // Only Aura windows are gesture consumers.
   ui::GestureRecognizer::Get()->TransferEventsTo(
       GetAttachedBrowserWidget()->GetNativeView(),
       target_tabstrip->GetWidget()->GetNativeView());
 #endif
 
   if (is_dragging_window_) {
     // ReleaseCapture() is going to result in calling back to us (because it
     // results in a move). That'll cause all sorts of problems.  Reset the
     // observer so we don't get notified and process the event.
-    if (host_desktop_type_ == chrome::HOST_DESKTOP_TYPE_ASH) {
+    if (host_desktop_type_ == ui::HOST_DESKTOP_TYPE_ASH) {
       move_loop_widget_->RemoveObserver(this);
       move_loop_widget_ = NULL;
     }
     views::Widget* browser_widget = GetAttachedBrowserWidget();
     // Need to release the drag controller before starting the move loop as it's
     // going to trigger capture lost, which cancels drag.
     attached_tabstrip_->ReleaseDragController();
     target_tabstrip->OwnDragController(this);
     // Disable animations so that we don't see a close animation on aero.
     browser_widget->SetVisibilityChangedAnimationsEnabled(false);
@@ skipping 919 matching lines @@
             contentses, window_bounds, widget->IsMaximized());
     ResetSelection(new_browser->tab_strip_model());
     new_browser->window()->Show();
   }
 }
 
 void TabDragController::MaximizeAttachedWindow() {
   GetAttachedBrowserWidget()->Maximize();
 #if defined(USE_ASH)
   if (was_source_fullscreen_ &&
-      host_desktop_type_ == chrome::HOST_DESKTOP_TYPE_ASH) {
+      host_desktop_type_ == ui::HOST_DESKTOP_TYPE_ASH) {
     // In fullscreen mode it is only possible to get here if the source
     // was in "immersive fullscreen" mode, so toggle it back on.
     ash::accelerators::ToggleFullscreen();
   }
 #endif
 }
 
 gfx::Rect TabDragController::GetViewScreenBounds(
     views::View* view) const {
   gfx::Point view_topleft;
@@ skipping 12 matching lines @@
   if (!GetTabStripForWindow(window))
     return;
 
   if (window) {
     views::Widget* widget_window = views::Widget::GetWidgetForNativeWindow(
         window);
     if (!widget_window)
       return;
 
 #if defined(USE_ASH)
-    if (host_desktop_type_ == chrome::HOST_DESKTOP_TYPE_ASH) {
+    if (host_desktop_type_ == ui::HOST_DESKTOP_TYPE_ASH) {
       // TODO(varkha): The code below ensures that the phantom drag widget
       // is shown on top of browser windows. The code should be moved to ash/
       // and the phantom should be able to assert its top-most state on its own.
       // One strategy would be for DragWindowController to
       // be able to observe stacking changes to the phantom drag widget's
       // siblings in order to keep it on top. One way is to implement a
       // notification that is sent to a window parent's observers when a
       // stacking order is changed among the children of that same parent.
       // Note that OnWindowStackingChanged is sent only to the child that is the
       // argument of one of the Window::StackChildX calls and not to all its
@@ skipping 164 matching lines @@
   SetWindowPositionManaged(browser->window()->GetNativeWindow(), false);
   // If the window is created maximized then the bounds we supplied are ignored.
   // We need to reset them again so they are honored.
   browser->window()->SetBounds(new_bounds);
 
   return browser;
 }
 
 gfx::Point TabDragController::GetCursorScreenPoint() {
 #if defined(USE_ASH)
-  if (host_desktop_type_ == chrome::HOST_DESKTOP_TYPE_ASH &&
+  if (host_desktop_type_ == ui::HOST_DESKTOP_TYPE_ASH &&
       event_source_ == EVENT_SOURCE_TOUCH &&
       aura::Env::GetInstance()->is_touch_down()) {
     views::Widget* widget = GetAttachedBrowserWidget();
     DCHECK(widget);
     aura::Window* widget_window = widget->GetNativeWindow();
     DCHECK(widget_window->GetRootWindow());
     gfx::PointF touch_point_f;
     bool got_touch_point = ui::GestureRecognizer::Get()->
         GetLastTouchPointForTarget(widget_window, &touch_point_f);
     CHECK(got_touch_point);
@@ skipping 27 matching lines @@
         attached_tabstrip_->GetWidget()->GetNativeWindow();
     if (dragged_window)
       exclude.insert(dragged_window);
   }
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   // Exclude windows which are pending deletion via Browser::TabStripEmpty().
   // These windows can be returned in the Linux Aura port because the browser
   // window which was used for dragging is not hidden once all of its tabs are
   // attached to another browser window in DragBrowserToNewTabStrip().
   // TODO(pkotwicz): Fix this properly (crbug.com/358482)
-  BrowserList* browser_list = BrowserList::GetInstance(
-      chrome::HOST_DESKTOP_TYPE_NATIVE);
+  BrowserList* browser_list =
+      BrowserList::GetInstance(ui::HOST_DESKTOP_TYPE_NATIVE);
   for (BrowserList::const_iterator it = browser_list->begin();
        it != browser_list->end(); ++it) {
     if ((*it)->tab_strip_model()->empty())
       exclude.insert((*it)->window()->GetNativeWindow());
   }
 #endif
   return GetLocalProcessWindowAtPoint(host_desktop_type_,
                                       screen_point,
                                       exclude);
 
 }