Remove useless TabDragController::detach_behavior_ and TabDragController::detach_into_browser_

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 "ash/accelerators/accelerator_commands.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/window_state.h"
 #include "base/auto_reset.h"
 #include "base/callback.h"
-#include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ui/app_modal_dialogs/javascript_dialog_manager.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
-#include "chrome/browser/ui/media_utils.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/tabs/browser_tab_strip_controller.h"
 #include "chrome/browser/ui/views/tabs/stacked_tab_strip_layout.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 #include "chrome/browser/ui/views/tabs/window_finder.h"
-#include "chrome/common/chrome_switches.h"
-#include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "ui/aura/env.h"
-#include "ui/aura/env.h"
 #include "ui/aura/window.h"
-#include "ui/aura/window_event_dispatcher.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "ui/events/event_constants.h"
-#include "ui/events/event_utils.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/window_modality_controller.h"
 
-#if defined(OS_WIN)
-#include "ui/aura/window.h"
-#include "ui/events/gestures/gesture_recognizer.h"
-#endif
-
 using base::UserMetricsAction;
 using content::OpenURLParams;
 using content::WebContents;
 
 // If non-null there is a drag underway.
 static TabDragController* instance_ = NULL;
 
 namespace {
 
 // Delay, in ms, during dragging before we bring a window to front.
@@ skipping 81 matching lines @@
 
   base::Closure escape_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(EscapeTracker);
 };
 
 }  // namespace
 
 TabDragController::TabDragData::TabDragData()
     : contents(NULL),
-      original_delegate(NULL),
       source_model_index(-1),
       attached_tab(NULL),
       pinned(false) {
 }
 
 TabDragController::TabDragData::~TabDragData() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabDragController, public:
 
 // static
 const int TabDragController::kTouchVerticalDetachMagnetism = 50;
 
 // static
 const int TabDragController::kVerticalDetachMagnetism = 15;
 
 TabDragController::TabDragController()
-    : detach_into_browser_(true),
-      event_source_(EVENT_SOURCE_MOUSE),
+    : event_source_(EVENT_SOURCE_MOUSE),
       source_tabstrip_(NULL),
       attached_tabstrip_(NULL),
       screen_(NULL),
       host_desktop_type_(chrome::HOST_DESKTOP_TYPE_NATIVE),
       use_aura_capture_policy_(false),
       offset_to_width_ratio_(0),
       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),
       was_source_maximized_(false),
       was_source_fullscreen_(false),
       did_restore_window_(false),
       end_run_loop_behavior_(END_RUN_LOOP_STOP_DRAGGING),
       waiting_for_run_loop_to_exit_(false),
       tab_strip_to_attach_to_after_exit_(NULL),
       move_loop_widget_(NULL),
       is_mutating_(false),
       attach_x_(-1),
       attach_index_(-1),
       weak_factory_(this) {
   instance_ = this;
 }
 
 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);
   }
 
-  if (source_tabstrip_ && detach_into_browser_)
+  if (source_tabstrip_)
     GetModel(source_tabstrip_)->RemoveObserver(this);
 
-  // Reset the delegate of the dragged WebContents. This ends up doing nothing
-  // if the drag was completed.
-  if (!detach_into_browser_)
-    ResetDelegates();
-
   if (event_source_ == EVENT_SOURCE_TOUCH) {
-    TabStrip* capture_tabstrip = (attached_tabstrip_ && detach_into_browser_) ?
+    TabStrip* capture_tabstrip = attached_tabstrip_ ?
         attached_tabstrip_ : source_tabstrip_;
     capture_tabstrip->GetWidget()->ReleaseCapture();
   }
 }
 
 void TabDragController::Init(
     TabStrip* source_tabstrip,
     Tab* source_tab,
     const std::vector<Tab*>& tabs,
     const gfx::Point& mouse_offset,
     int source_tab_offset,
     const ui::ListSelectionModel& initial_selection_model,
-    DetachBehavior detach_behavior,
     MoveBehavior move_behavior,
     EventSource event_source) {
   DCHECK(!tabs.empty());
   DCHECK(std::find(tabs.begin(), tabs.end(), source_tab) != tabs.end());
   source_tabstrip_ = source_tabstrip;
   was_source_maximized_ = source_tabstrip->GetWidget()->IsMaximized();
   was_source_fullscreen_ = source_tabstrip->GetWidget()->IsFullscreen();
   screen_ = gfx::Screen::GetScreenFor(
       source_tabstrip->GetWidget()->GetNativeView());
   host_desktop_type_ = chrome::GetHostDesktopTypeForNativeView(
       source_tabstrip->GetWidget()->GetNativeView());
 #if defined(OS_LINUX)
   use_aura_capture_policy_ = true;
 #else
   use_aura_capture_policy_ =
       (host_desktop_type_ == chrome::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;
-  detach_behavior_ = detach_behavior;
   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();
-  if (detach_behavior == NOT_DETACHABLE)
-    detach_into_browser_ = false;
 
-  if (detach_into_browser_)
-    GetModel(source_tabstrip_)->AddObserver(this);
+  GetModel(source_tabstrip_)->AddObserver(this);
 
   drag_data_.resize(tabs.size());
   for (size_t i = 0; i < tabs.size(); ++i)
     InitTabDragData(tabs[i], &(drag_data_[i]));
   source_tab_index_ =
       std::find(tabs.begin(), tabs.end(), source_tab) - tabs.begin();
 
   // Listen for Esc key presses.
   escape_tracker_.reset(
       new EscapeTracker(base::Bind(&TabDragController::EndDrag,
@@ skipping 48 matching lines @@
 
     // On windows SaveFocus() may trigger a capture lost, which destroys us.
     {
       base::WeakPtr<TabDragController> ref(weak_factory_.GetWeakPtr());
       SaveFocus();
       if (!ref)
         return;
     }
     started_drag_ = true;
     Attach(source_tabstrip_, gfx::Point());
-    if (detach_into_browser_ && static_cast<int>(drag_data_.size()) ==
+    if (static_cast<int>(drag_data_.size()) ==
         GetModel(source_tabstrip_)->count()) {
       if (was_source_maximized_ || was_source_fullscreen_) {
         did_restore_window_ = true;
         // When all tabs in a maximized browser are dragged the browser gets
         // restored during the drag and maximized back when the drag ends.
         views::Widget* widget = GetAttachedBrowserWidget();
         const int last_tabstrip_width = attached_tabstrip_->tab_area_width();
         std::vector<gfx::Rect> drag_bounds = CalculateBoundsForDraggedTabs();
         OffsetX(GetAttachedDragPoint(point_in_screen).x(), &drag_bounds);
         gfx::Rect new_bounds(CalculateDraggedBrowserBounds(source_tabstrip_,
@@ skipping 35 matching lines @@
   TRACE_EVENT0("views", "TabDragController::InitTabDragData");
   drag_data->source_model_index =
       source_tabstrip_->GetModelIndexOfTab(tab);
   drag_data->contents = GetModel(source_tabstrip_)->GetWebContentsAt(
       drag_data->source_model_index);
   drag_data->pinned = source_tabstrip_->IsTabPinned(tab);
   registrar_.Add(
       this,
       content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
       content::Source<WebContents>(drag_data->contents));
-
-  if (!detach_into_browser_) {
-    drag_data->original_delegate = drag_data->contents->GetDelegate();
-    drag_data->contents->SetDelegate(this);
-  }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// TabDragController, PageNavigator implementation:
-
-WebContents* TabDragController::OpenURLFromTab(
-    WebContents* source,
-    const OpenURLParams& params) {
-  if (source_tab_drag_data()->original_delegate) {
-    OpenURLParams forward_params = params;
-    if (params.disposition == CURRENT_TAB)
-      forward_params.disposition = NEW_WINDOW;
-
-    return source_tab_drag_data()->original_delegate->OpenURLFromTab(
-        source, forward_params);
-  }
-  return NULL;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// TabDragController, content::WebContentsDelegate implementation:
-
-void TabDragController::NavigationStateChanged(const WebContents* source,
-                                               unsigned changed_flags) {
-  if (attached_tabstrip_ ||
-      changed_flags == content::INVALIDATE_TYPE_PAGE_ACTIONS) {
-    for (size_t i = 0; i < drag_data_.size(); ++i) {
-      if (drag_data_[i].contents == source) {
-        // Pass the NavigationStateChanged call to the original delegate so
-        // that the title is updated. Do this only when we are attached as
-        // otherwise the Tab isn't in the TabStrip (except for page action
-        // updates).
-        drag_data_[i].original_delegate->NavigationStateChanged(source,
-                                                                changed_flags);
-        break;
-      }
-    }
-  }
-}
-
-void TabDragController::AddNewContents(WebContents* source,
-                                       WebContents* new_contents,
-                                       WindowOpenDisposition disposition,
-                                       const gfx::Rect& initial_pos,
-                                       bool user_gesture,
-                                       bool* was_blocked) {
-  DCHECK_NE(CURRENT_TAB, disposition);
-
-  // Theoretically could be called while dragging if the page tries to
-  // spawn a window. Route this message back to the browser in most cases.
-  if (source_tab_drag_data()->original_delegate) {
-    source_tab_drag_data()->original_delegate->AddNewContents(
-        source, new_contents, disposition, initial_pos, user_gesture,
-        was_blocked);
-  }
-}
-
-bool TabDragController::ShouldSuppressDialogs() {
-  // When a dialog is about to be shown we revert the drag. Otherwise a modal
-  // dialog might appear and attempt to parent itself to a hidden tabcontents.
-  EndDragImpl(CANCELED);
-  return false;
-}
-
-content::JavaScriptDialogManager*
-TabDragController::GetJavaScriptDialogManager() {
-  return GetJavaScriptDialogManagerInstance();
-}
-
-void TabDragController::RequestMediaAccessPermission(
-    content::WebContents* web_contents,
-    const content::MediaStreamRequest& request,
-    const content::MediaResponseCallback& callback) {
-  ::RequestMediaAccessPermission(
-      web_contents,
-      Profile::FromBrowserContext(web_contents->GetBrowserContext()),
-      request,
-      callback);
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // TabDragController, content::NotificationObserver implementation:
 
 void TabDragController::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(content::NOTIFICATION_WEB_CONTENTS_DESTROYED, type);
   WebContents* destroyed_web_contents =
       content::Source<WebContents>(source).ptr();
   for (size_t i = 0; i < drag_data_.size(); ++i) {
     if (drag_data_[i].contents == destroyed_web_contents) {
       // One of the tabs we're dragging has been destroyed. Cancel the drag.
-      if (destroyed_web_contents->GetDelegate() == this)
-        destroyed_web_contents->SetDelegate(NULL);
       drag_data_[i].contents = NULL;
-      drag_data_[i].original_delegate = NULL;
       EndDragImpl(TAB_DESTROYED);
       return;
     }
   }
   // If we get here it means we got notification for a tab we don't know about.
   NOTREACHED();
 }
 
 void TabDragController::OnWidgetBoundsChanged(views::Widget* widget,
                                               const gfx::Rect& new_bounds) {
   TRACE_EVENT1("views", "TabDragController::OnWidgetBoundsChanged",
                "new_bounds", new_bounds.ToString());
 
   Drag(GetCursorScreenPoint());
 }
 
 void TabDragController::TabStripEmpty() {
-  DCHECK(detach_into_browser_);
   GetModel(source_tabstrip_)->RemoveObserver(this);
   // NULL out source_tabstrip_ so that we don't attempt to add back to it (in
   // the case of a revert).
   source_tabstrip_ = NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabDragController, private:
 
 void TabDragController::InitWindowCreatePoint() {
@@ skipping 64 matching lines @@
   int x_offset = abs(point_in_screen.x() - start_point_in_screen_.x());
   int y_offset = abs(point_in_screen.y() - start_point_in_screen_.y());
   return sqrt(pow(static_cast<float>(x_offset), 2) +
               pow(static_cast<float>(y_offset), 2)) > kMinimumDragDistance;
 }
 
 void TabDragController::ContinueDragging(const gfx::Point& point_in_screen) {
   TRACE_EVENT1("views", "TabDragController::ContinueDragging",
                "point_in_screen", point_in_screen.ToString());
 
-  DCHECK(!detach_into_browser_ || attached_tabstrip_);
+  DCHECK(attached_tabstrip_);
 
-  TabStrip* target_tabstrip = detach_behavior_ == DETACHABLE ?
-      GetTargetTabStripForPoint(point_in_screen) : source_tabstrip_;
+  TabStrip* target_tabstrip = GetTargetTabStripForPoint(point_in_screen);
   bool tab_strip_changed = (target_tabstrip != attached_tabstrip_);
 
   if (attached_tabstrip_) {
     int move_delta = point_in_screen.x() - last_point_in_screen_.x();
     if (move_delta > 0)
       mouse_move_direction_ |= kMovedMouseRight;
     else if (move_delta < 0)
       mouse_move_direction_ |= kMovedMouseLeft;
   }
   last_point_in_screen_ = point_in_screen;
 
   if (tab_strip_changed) {
     is_dragging_new_browser_ = false;
     did_restore_window_ = false;
-    if (detach_into_browser_ &&
-        DragBrowserToNewTabStrip(target_tabstrip, point_in_screen) ==
+    if (DragBrowserToNewTabStrip(target_tabstrip, point_in_screen) ==
         DRAG_BROWSER_RESULT_STOP) {
       return;
-    } else if (!detach_into_browser_) {
-      if (attached_tabstrip_)
-        Detach(RELEASE_CAPTURE);
-      if (target_tabstrip)
-        Attach(target_tabstrip, point_in_screen);
     }
   }
   if (is_dragging_window_) {
     static_cast<base::Timer*>(&bring_to_front_timer_)->Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(kBringToFrontDelay),
         base::Bind(&TabDragController::BringWindowUnderPointToFront,
                    base::Unretained(this), point_in_screen));
   }
 
   if (!is_dragging_window_ && attached_tabstrip_) {
@@ skipping 254 matching lines @@
     return DETACH_AFTER;
   return DETACH_ABOVE_OR_BELOW;
 }
 
 TabStrip* TabDragController::GetTargetTabStripForPoint(
     const gfx::Point& point_in_screen) {
   TRACE_EVENT1("views", "TabDragController::GetTargetTabStripForPoint",
                "point_in_screen", point_in_screen.ToString());
 
   if (move_only() && attached_tabstrip_) {
-    DCHECK_EQ(DETACHABLE, detach_behavior_);
     // move_only() is intended for touch, in which case we only want to detach
     // if the touch point moves significantly in the vertical distance.
     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_);
@@ skipping 53 matching lines @@
 
   std::vector<Tab*> tabs =
       GetTabsMatchingDraggedContents(attached_tabstrip_);
 
   if (tabs.empty()) {
     // Transitioning from detached to attached to a new tabstrip. Add tabs to
     // the new model.
 
     selection_model_before_attach_.Copy(attached_tabstrip->GetSelectionModel());
 
-    if (!detach_into_browser_) {
-      // Remove ourselves as the delegate now that the dragged WebContents is
-      // being inserted back into a Browser.
-      for (size_t i = 0; i < drag_data_.size(); ++i) {
-        drag_data_[i].contents->SetDelegate(NULL);
-        drag_data_[i].original_delegate = NULL;
-      }
-
-      // Return the WebContents to normalcy.
-      source_dragged_contents()->DecrementCapturerCount();
-    }
-
     // Inserting counts as a move. We don't want the tabs to jitter when the
     // user moves the tab immediately after attaching it.
     last_move_screen_loc_ = point_in_screen.x();
 
     // Figure out where to insert the tab based on the bounds of the dragged
     // representation and the ideal bounds of the other Tabs already in the
     // strip. ("ideal bounds" are stable even if the Tabs' actual bounds are
     // changing due to animation).
     gfx::Point tab_strip_point(point_in_screen);
     views::View::ConvertPointFromScreen(attached_tabstrip_, &tab_strip_point);
@@ skipping 36 matching lines @@
                        tabs_to_source.end());
   int new_x = attached_tabstrip_->GetSizeNeededForTabs(tabs_to_source) -
       tabs[source_tab_index_]->width() +
       static_cast<int>(offset_to_width_ratio_ *
                        tabs[source_tab_index_]->width());
   mouse_offset_.set_x(new_x);
 
   // Transfer ownership of us to the new tabstrip as well as making sure the
   // window has capture. This is important so that if activation changes the
   // drag isn't prematurely canceled.
-  if (detach_into_browser_) {
-    attached_tabstrip_->GetWidget()->SetCapture(attached_tabstrip_);
-    attached_tabstrip_->OwnDragController(this);
-  }
+  attached_tabstrip_->GetWidget()->SetCapture(attached_tabstrip_);
+  attached_tabstrip_->OwnDragController(this);
 
   // Redirect all mouse events to the TabStrip so that the tab that originated
   // the drag can safely be deleted.
-  if (detach_into_browser_ || attached_tabstrip_ == source_tabstrip_) {
-    static_cast<views::internal::RootView*>(
-        attached_tabstrip_->GetWidget()->GetRootView())->SetMouseHandler(
-            attached_tabstrip_);
-  }
+  static_cast<views::internal::RootView*>(
+      attached_tabstrip_->GetWidget()->GetRootView())->SetMouseHandler(
+          attached_tabstrip_);
 }
 
 void TabDragController::Detach(ReleaseCapture release_capture) {
   TRACE_EVENT1("views", "TabDragController::Detach",
                "release_capture", release_capture);
 
   attach_index_ = -1;
 
   // When the user detaches we assume they want to reorder.
   move_behavior_ = REORDER;
 
   // Release ownership of the drag controller and mouse capture. When we
   // reattach ownership is transfered.
-  if (detach_into_browser_) {
-    attached_tabstrip_->ReleaseDragController();
-    if (release_capture == RELEASE_CAPTURE)
-      attached_tabstrip_->GetWidget()->ReleaseCapture();
-  }
+  attached_tabstrip_->ReleaseDragController();
+  if (release_capture == RELEASE_CAPTURE)
+    attached_tabstrip_->GetWidget()->ReleaseCapture();
 
   mouse_move_direction_ = kMovedMouseLeft | kMovedMouseRight;
 
-  // Prevent the WebContents HWND from being hidden by any of the model
-  // operations performed during the drag.
-  if (!detach_into_browser_)
-    source_dragged_contents()->IncrementCapturerCount(gfx::Size());
-
   std::vector<gfx::Rect> drag_bounds = CalculateBoundsForDraggedTabs();
   TabStripModel* attached_model = GetModel(attached_tabstrip_);
   std::vector<TabRendererData> tab_data;
   for (size_t i = 0; i < drag_data_.size(); ++i) {
     tab_data.push_back(drag_data_[i].attached_tab->data());
     int index = attached_model->GetIndexOfWebContents(drag_data_[i].contents);
     DCHECK_NE(-1, index);
 
     // Hide the tab so that the user doesn't see it animate closed.
     drag_data_[i].attached_tab->SetVisible(false);
     drag_data_[i].attached_tab->set_detached();
 
     attached_model->DetachWebContentsAt(index);
 
-    // Detaching resets the delegate, but we still want to be the delegate.
-    if (!detach_into_browser_)
-      drag_data_[i].contents->SetDelegate(this);
-
     // Detaching may end up deleting the tab, drop references to it.
     drag_data_[i].attached_tab = NULL;
   }
 
   // If we've removed the last Tab from the TabStrip, hide the frame now.
   if (!attached_model->empty()) {
     if (!selection_model_before_attach_.empty() &&
         selection_model_before_attach_.active() >= 0 &&
         selection_model_before_attach_.active() < attached_model->count()) {
       // Restore the selection.
@@ skipping 364 matching lines @@
       if (type == CANCELED)
         RevertDrag();
       else
         CompleteDrag();
     }
   } else if (drag_data_.size() > 1) {
     initial_selection_model_.Clear();
     RevertDrag();
   }  // else case the only tab we were dragging was deleted. Nothing to do.
 
-  if (!detach_into_browser_)
-    ResetDelegates();
-
   // Clear out drag data so we don't attempt to do anything with it.
   drag_data_.clear();
 
-  TabStrip* owning_tabstrip = (attached_tabstrip_ && detach_into_browser_) ?
+  TabStrip* owning_tabstrip = attached_tabstrip_ ?
       attached_tabstrip_ : source_tabstrip_;
   owning_tabstrip->DestroyDragController();
 }
 
 void TabDragController::RevertDrag() {
   std::vector<Tab*> tabs;
   for (size_t i = 0; i < drag_data_.size(); ++i) {
     if (drag_data_[i].contents) {
       // Contents is NULL if a tab was destroyed while the drag was under way.
       tabs.push_back(drag_data_[i].attached_tab);
       RevertDragAt(i);
     }
   }
 
-  bool restore_frame = !detach_into_browser_ &&
-                       attached_tabstrip_ != source_tabstrip_;
   if (attached_tabstrip_) {
     if (did_restore_window_)
       MaximizeAttachedWindow();
     if (attached_tabstrip_ == source_tabstrip_) {
       source_tabstrip_->StoppedDraggingTabs(
           tabs, initial_tab_positions_, move_behavior_ == MOVE_VISIBILE_TABS,
           false);
     } else {
       attached_tabstrip_->DraggedTabsDetached();
     }
   }
 
   if (initial_selection_model_.empty())
     ResetSelection(GetModel(source_tabstrip_));
   else
     GetModel(source_tabstrip_)->SetSelectionFromModel(initial_selection_model_);
 
-  // If we're not attached to any TabStrip, or attached to some other TabStrip,
-  // we need to restore the bounds of the original TabStrip's frame, in case
-  // it has been hidden.
-  if (restore_frame && !restore_bounds_.IsEmpty())
-    source_tabstrip_->GetWidget()->SetBounds(restore_bounds_);
-
-  if (detach_into_browser_ && source_tabstrip_)
+  if (source_tabstrip_)
     source_tabstrip_->GetWidget()->Activate();
-
-  // Return the WebContents to normalcy.  If the tab was attached to a
-  // TabStrip before the revert, the decrement has already occurred.
-  // If the tab was destroyed, don't attempt to dereference the
-  // WebContents pointer.
-  if (!detach_into_browser_ && !attached_tabstrip_ && source_dragged_contents())
-    source_dragged_contents()->DecrementCapturerCount();
 }
 
 void TabDragController::ResetSelection(TabStripModel* model) {
   DCHECK(model);
   ui::ListSelectionModel selection_model;
   bool has_one_valid_tab = false;
   for (size_t i = 0; i < drag_data_.size(); ++i) {
     // |contents| is NULL if a tab was deleted out from under us.
     if (drag_data_[i].contents) {
       int index = model->GetIndexOfWebContents(drag_data_[i].contents);
@@ skipping 108 matching lines @@
       item.add_types = drag_data_[i].pinned ? TabStripModel::ADD_PINNED
                                             : TabStripModel::ADD_NONE;
       contentses.push_back(item);
     }
 
     Browser* new_browser =
         GetModel(source_tabstrip_)->delegate()->CreateNewStripWithContents(
             contentses, window_bounds, widget->IsMaximized());
     ResetSelection(new_browser->tab_strip_model());
     new_browser->window()->Show();
-
-    // Return the WebContents to normalcy.
-    if (!detach_into_browser_)
-      source_dragged_contents()->DecrementCapturerCount();
   }
-
-  CleanUpHiddenFrame();
 }
 
 void TabDragController::MaximizeAttachedWindow() {
   GetAttachedBrowserWidget()->Maximize();
   if (was_source_fullscreen_ &&
       host_desktop_type_ == chrome::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();
   }
 }
 
-void TabDragController::ResetDelegates() {
-  DCHECK(!detach_into_browser_);
-  for (size_t i = 0; i < drag_data_.size(); ++i) {
-    if (drag_data_[i].contents &&
-        drag_data_[i].contents->GetDelegate() == this) {
-      drag_data_[i].contents->SetDelegate(
-          drag_data_[i].original_delegate);
-    }
-  }
-}
-
 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::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::BringWindowUnderPointToFront(
     const gfx::Point& point_in_screen) {
   aura::Window* 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) {
@@ skipping 184 matching lines @@
     DCHECK(got_touch_point);
     ash::wm::ConvertPointToScreen(widget_window->GetRootWindow(), &touch_point);
     return touch_point;
   }
 
   return screen_->GetCursorScreenPoint();
 }
 
 gfx::Vector2d TabDragController::GetWindowOffset(
     const gfx::Point& point_in_screen) {
-  TabStrip* owning_tabstrip = (attached_tabstrip_ && detach_into_browser_) ?
+  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,
@@ skipping 17 matching lines @@
        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);
 
 }