MacViews: Get c/b/ui/views/tabs to build on Mac

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 20 matching lines @@
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
-#include "ui/wm/core/coordinate_conversion.h"
-#include "ui/wm/core/window_modality_controller.h"
 
 #if defined(USE_ASH)
 #include "ash/accelerators/accelerator_commands.h"
 #include "ash/shell.h"
 #include "ash/wm/maximize_mode/maximize_mode_controller.h"
 #include "ash/wm/window_state.h"
+#include "ui/wm/core/coordinate_conversion.h"
+#endif
+
+#if defined(USE_AURA)
+#include "ui/wm/core/window_modality_controller.h"
 #endif
 
 using base::UserMetricsAction;
 using content::OpenURLParams;
 using content::WebContents;
 
 // If non-null there is a drag underway.
 static TabDragController* instance_ = NULL;
 
 namespace {
@@ skipping 28 matching lines @@
 }
 #else
 void SetWindowPositionManaged(gfx::NativeWindow window, bool value) {
 }
 
 bool IsDockedOrSnapped(const TabStrip* tab_strip) {
   return false;
 }
 #endif
 
+#if defined(USE_AURA)
+gfx::NativeWindow GetModalTransient(gfx::NativeWindow window) {
+  return wm::GetModalTransient(window);
+}
+#else
+gfx::NativeWindow GetModalTransient(gfx::NativeWindow window) {
+  NOTIMPLEMENTED();
+  return NULL;
+}
+#endif
+
 // Returns true if |bounds| contains the y-coordinate |y|. The y-coordinate
 // of |bounds| is adjusted by |vertical_adjustment|.
 bool DoesRectContainVerticalPointExpanded(
     const gfx::Rect& bounds,
     int vertical_adjustment,
     int y) {
   int upper_threshold = bounds.bottom() + vertical_adjustment;
   int lower_threshold = bounds.y() - vertical_adjustment;
   return y >= lower_threshold && y <= upper_threshold;
 }
 
 // Adds |x_offset| to all the rectangles in |rects|.
 void OffsetX(int x_offset, std::vector<gfx::Rect>* rects) {
   if (x_offset == 0)
     return;
 
   for (size_t i = 0; i < rects->size(); ++i)
     (*rects)[i].set_x((*rects)[i].x() + x_offset);
 }
 
 // WidgetObserver implementation that resets the window position managed
 // property on Show.
 // We're forced to do this here since BrowserFrameAsh resets the 'window
 // position managed' property during a show and we need the property set to
 // false before WorkspaceLayoutManager sees the visibility change.
 class WindowPositionManagedUpdater : public views::WidgetObserver {
  public:
   virtual void OnWidgetVisibilityChanged(views::Widget* widget,
                                          bool visible) override {
-    SetWindowPositionManaged(widget->GetNativeView(), false);
+    SetWindowPositionManaged(widget->GetNativeWindow(), false);
   }
 };
 
 // EscapeTracker installs itself as a pre-target handler on aura::Env and runs a
 // callback when it receives the escape key.
 class EscapeTracker : public ui::EventHandler {
  public:
   explicit EscapeTracker(const base::Closure& callback)
       : escape_callback_(callback) {
     aura::Env::GetInstance()->AddPreTargetHandler(this);
@@ skipping 73 matching lines @@
 }
 
 TabDragController::~TabDragController() {
   views::ViewStorage::GetInstance()->RemoveView(old_focused_view_id_);
 
   if (instance_ == this)
     instance_ = NULL;
 
   if (move_loop_widget_) {
     move_loop_widget_->RemoveObserver(this);
-    SetWindowPositionManaged(move_loop_widget_->GetNativeView(), true);
+    SetWindowPositionManaged(move_loop_widget_->GetNativeWindow(), true);
   }
 
   if (source_tabstrip_)
     GetModel(source_tabstrip_)->RemoveObserver(this);
 
   if (event_source_ == EVENT_SOURCE_TOUCH) {
     TabStrip* capture_tabstrip = attached_tabstrip_ ?
         attached_tabstrip_ : source_tabstrip_;
     capture_tabstrip->GetWidget()->ReleaseCapture();
   }
@@ skipping 370 matching lines @@
     // should really be done somewhere in capture change code and or inside the
     // GR. But we currently do not have a consistent way for doing it that would
     // work in all cases. Hence this hack.
     ui::GestureRecognizer::Get()->TransferEventsTo(
         browser_widget->GetNativeView(),
         target_tabstrip->GetWidget()->GetNativeView());
 #endif
 
     // The window is going away. Since the drag is still on going we don't want
     // that to effect the position of any windows.
-    SetWindowPositionManaged(browser_widget->GetNativeView(), false);
+    SetWindowPositionManaged(browser_widget->GetNativeWindow(), false);
 
 #if !defined(OS_LINUX) || defined(OS_CHROMEOS)
     // EndMoveLoop is going to snap the window back to its original location.
     // Hide it so users don't see this. Hiding a window in Linux aura causes
     // it to lose capture so skip it.
     browser_widget->Hide();
 #endif
     browser_widget->EndMoveLoop();
 
     // Ideally we would always swap the tabs now, but on non-ash Windows, it
@@ skipping 197 matching lines @@
     gfx::Rect tabstrip_bounds = GetViewScreenBounds(attached_tabstrip_);
     if (DoesRectContainVerticalPointExpanded(tabstrip_bounds,
                                              kTouchVerticalDetachMagnetism,
                                              point_in_screen.y()))
       return attached_tabstrip_;
   }
   gfx::NativeWindow local_window =
       GetLocalProcessWindow(point_in_screen, is_dragging_window_);
   // Do not allow dragging into a window with a modal dialog, it causes a weird
   // behavior.  See crbug.com/336691
-  if (!wm::GetModalTransient(local_window)) {
+  if (!GetModalTransient(local_window)) {
     TabStrip* tab_strip = GetTabStripForWindow(local_window);
     if (tab_strip && DoesTabStripContain(tab_strip, point_in_screen))
       return tab_strip;
   }
 
   return is_dragging_window_ ? attached_tabstrip_ : NULL;
 }
 
 TabStrip* TabDragController::GetTabStripForWindow(gfx::NativeWindow window) {
   if (!window)
@@ skipping 490 matching lines @@
   DCHECK(active_);
   active_ = false;
 
   bring_to_front_timer_.Stop();
   move_stacked_timer_.Stop();
 
   if (is_dragging_window_) {
     waiting_for_run_loop_to_exit_ = true;
 
     if (type == NORMAL || (type == TAB_DESTROYED && drag_data_.size() > 1)) {
-      SetWindowPositionManaged(GetAttachedBrowserWidget()->GetNativeView(),
+      SetWindowPositionManaged(GetAttachedBrowserWidget()->GetNativeWindow(),
                                true);
     }
 
     // End the nested drag loop.
     GetAttachedBrowserWidget()->EndMoveLoop();
   }
 
   if (type != TAB_DESTROYED) {
     // We only finish up the drag if we were actually dragging. If start_drag_
     // is false, the user just clicked and released and didn't move the mouse
@@ skipping 195 matching lines @@
     views::View* view) const {
   gfx::Point view_topleft;
   views::View::ConvertPointToScreen(view, &view_topleft);
   gfx::Rect view_screen_bounds = view->GetLocalBounds();
   view_screen_bounds.Offset(view_topleft.x(), view_topleft.y());
   return view_screen_bounds;
 }
 
 void TabDragController::BringWindowUnderPointToFront(
     const gfx::Point& point_in_screen) {
-  aura::Window* window = GetLocalProcessWindow(point_in_screen, true);
+  gfx::NativeWindow window = GetLocalProcessWindow(point_in_screen, true);
 
   // Only bring browser windows to front - only windows with a TabStrip can
   // be tab drag targets.
   if (!GetTabStripForWindow(window))
     return;
 
   if (window) {
-    views::Widget* widget_window = views::Widget::GetWidgetForNativeView(
+    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) {
       // 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
@@ skipping 11 matching lines @@
         if (*it == browser_window)
           return;
         if ((*it)->type() != ui::wm::WINDOW_TYPE_POPUP) {
           widget_window->StackAbove(*it);
           break;
         }
       }
     } else {
       widget_window->StackAtTop();
     }
+#else
+    widget_window->StackAtTop();
+#endif
 
     // The previous call made the window appear on top of the dragged window,
     // move the dragged window to the front.
     if (is_dragging_window_)
       attached_tabstrip_->GetWidget()->StackAtTop();
   }
 }
 
 TabStripModel* TabDragController::GetModel(
     TabStrip* tabstrip) const {
@@ skipping 116 matching lines @@
   is_dragging_new_browser_ = true;
   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 &&
       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);
     // TODO(tdresser): Switch to using gfx::PointF. See crbug.com/337824.
     gfx::Point touch_point = gfx::ToFlooredPoint(touch_point_f);
     DCHECK(got_touch_point);
     wm::ConvertPointToScreen(widget_window->GetRootWindow(), &touch_point);
     return touch_point;
   }
+#endif
 
   return screen_->GetCursorScreenPoint();
 }
 
 gfx::Vector2d TabDragController::GetWindowOffset(
     const gfx::Point& point_in_screen) {
   TabStrip* owning_tabstrip = attached_tabstrip_ ?
       attached_tabstrip_ : source_tabstrip_;
   views::View* toplevel_view = owning_tabstrip->GetWidget()->GetContentsView();
 
   gfx::Point point = point_in_screen;
   views::View::ConvertPointFromScreen(toplevel_view, &point);
   return point.OffsetFromOrigin();
 }
 
 gfx::NativeWindow TabDragController::GetLocalProcessWindow(
     const gfx::Point& screen_point,
     bool exclude_dragged_view) {
-  std::set<aura::Window*> exclude;
+  std::set<gfx::NativeWindow> exclude;
   if (exclude_dragged_view) {
-    aura::Window* dragged_window =
-        attached_tabstrip_->GetWidget()->GetNativeView();
+    gfx::NativeWindow dragged_window =
+        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);
   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);
 
 }