Remove more non-aura windows code.

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 359 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // TabDragController, public:
 
 // static
 const int TabDragController::kTouchVerticalDetachMagnetism = 50;
 
 // static
 const int TabDragController::kVerticalDetachMagnetism = 15;
 
 TabDragController::TabDragController()
-    : detach_into_browser_(ShouldDetachIntoNewBrowser()),
+    : detach_into_browser_(true),
       event_source_(EVENT_SOURCE_MOUSE),
       source_tabstrip_(NULL),
       attached_tabstrip_(NULL),
       screen_(NULL),
       host_desktop_type_(chrome::HOST_DESKTOP_TYPE_NATIVE),
       offset_to_width_ratio_(0),
       old_focused_view_id_(
           views::ViewStorage::GetInstance()->CreateStorageID()),
       last_move_screen_loc_(0),
       started_drag_(false),
@@ skipping 102 matching lines @@
 bool TabDragController::IsAttachedTo(const TabStrip* tab_strip) {
   return (instance_ && instance_->active() &&
           instance_->attached_tabstrip() == tab_strip);
 }
 
 // static
 bool TabDragController::IsActive() {
   return instance_ && instance_->active();
 }
 
-// static
-bool TabDragController::ShouldDetachIntoNewBrowser() {
-#if defined(USE_AURA)
-  return true;
-#else
-  return CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kTabBrowserDragging);
-#endif
-}
-
 void TabDragController::SetMoveBehavior(MoveBehavior behavior) {
   if (started_drag())
     return;
 
   move_behavior_ = behavior;
 }
 
 void TabDragController::Drag(const gfx::Point& point_in_screen) {
   TRACE_EVENT1("views", "TabDragController::Drag",
                "point_in_screen", point_in_screen.ToString());
@@ skipping 913 matching lines @@
       selection_model.Copy(initial_selection_model_);
       for (DragData::const_reverse_iterator i(drag_data_.rbegin());
            i != drag_data_.rend(); ++i) {
         selection_model.DecrementFrom(i->source_model_index);
       }
       // We may have cleared out the selection model. Only reset it if it
       // contains something.
       if (!selection_model.empty())
         attached_model->SetSelectionFromModel(selection_model);
     }
-  } else if (!detach_into_browser_) {
-    HideFrame();
   }
 
   // Create the dragged view.
   if (!detach_into_browser_)
     CreateDraggedView(tab_data, drag_bounds);
 
   attached_tabstrip_->DraggedTabsDetached();
   attached_tabstrip_ = NULL;
 }
 
@@ skipping 610 matching lines @@
 
 gfx::Rect TabDragController::GetViewScreenBounds(
     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::HideFrame() {
-#if defined(OS_WIN) && !defined(USE_AURA)
-  // We don't actually hide the window, rather we just move it way off-screen.
-  // If we actually hide it, we stop receiving drag events.
-  //
-  // Windows coordinates are 16 bit values. Additionally mouse events are
-  // relative, this means if we move this window to the max position it is easy
-  // to trigger overflow. To avoid this we don't move to the max position,
-  // rather some where reasonably large. This should avoid common overflow
-  // problems.
-  // An alternative approach is to query the mouse pointer and ignore the
-  // location on the mouse (early versions did this). This proves problematic as
-  // if we happen to get behind in event processing it is all to easy to process
-  // a release in the wrong location, triggering either an unexpected move or an
-  // unexpected detach.
-  HWND frame_hwnd = source_tabstrip_->GetWidget()->GetNativeView();
-  RECT wr;
-  GetWindowRect(frame_hwnd, &wr);
-  MoveWindow(frame_hwnd, 0x3FFF, 0x3FFF, wr.right - wr.left,
-             wr.bottom - wr.top, TRUE);
-
-  // We also save the bounds of the window prior to it being moved, so that if
-  // the drag session is aborted we can restore them.
-  restore_bounds_ = gfx::Rect(wr);
-#else
-  // Shouldn't hit as aura triggers the |detach_into_browser_| path.
-  NOTREACHED();
-#endif
-}
-
 void TabDragController::CleanUpHiddenFrame() {
   // If the model we started dragging from is now empty, we must ask the
   // delegate to close the frame.
   if (!detach_into_browser_ && GetModel(source_tabstrip_)->empty())
     GetModel(source_tabstrip_)->delegate()->CloseFrameAfterDragSession();
 }
 
 void TabDragController::DockDisplayerDestroyed(
     DockDisplayer* controller) {
   DockWindows::iterator dock_i =
@@ skipping 236 matching lines @@
 gfx::Vector2d TabDragController::GetWindowOffset(
     const gfx::Point& point_in_screen) {
   TabStrip* owning_tabstrip = (attached_tabstrip_ && detach_into_browser_) ?
       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();
 }