Remove useless TabDragController::detach_behavior_ and TabDragController::detach_into_browser_

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

 // 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.
 
 #ifndef CHROME_BROWSER_UI_VIEWS_TABS_TAB_DRAG_CONTROLLER_H_
 #define CHROME_BROWSER_UI_VIEWS_TABS_TAB_DRAG_CONTROLLER_H_
 
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
 #include "chrome/browser/ui/views/tabs/tab_strip_types.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
-#include "content/public/browser/web_contents_delegate.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/widget/widget_observer.h"
 
 namespace gfx {
 class Screen;
 }
 namespace ui {
 class EventHandler;
 class ListSelectionModel;
@@ skipping 11 matching lines @@
 // the user presses the mouse on a tab a new TabDragController is created and
 // Drag() is invoked as the mouse is dragged. If the mouse is dragged far enough
 // TabDragController starts a drag session. The drag session is completed when
 // EndDrag() is invoked (or the TabDragController is destroyed).
 //
 // While dragging within a tab strip TabDragController sets the bounds of the
 // tabs (this is referred to as attached). When the user drags far enough such
 // that the tabs should be moved out of the tab strip a new Browser is created
 // and RunMoveLoop() is invoked on the Widget to drag the browser around. This
 // is the default on aura.
-class TabDragController : public content::WebContentsDelegate,
-                          public content::NotificationObserver,
+class TabDragController : public content::NotificationObserver,
                           public views::WidgetObserver,
                           public TabStripModelObserver {
  public:
-  enum DetachBehavior {
-    DETACHABLE,
-    NOT_DETACHABLE
-  };
-
   // What should happen as the mouse is dragged within the tabstrip.
   enum MoveBehavior {
     // Only the set of visible tabs should change. This is only applicable when
     // using touch layout.
     MOVE_VISIBILE_TABS,
 
     // Typical behavior where tabs are dragged around.
     REORDER
   };
 
@@ skipping 17 matching lines @@
   // offset from |source_tab|. |source_tab_offset| is the horizontal offset of
   // |mouse_offset| relative to |source_tab|. |initial_selection_model| is the
   // selection model before the drag started and is only non-empty if
   // |source_tab| was not initially selected.
   void 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);
 
   // Returns true if there is a drag underway and the drag is attached to
   // |tab_strip|.
   // NOTE: this returns false if the TabDragController is in the process of
   // finishing the drag.
   static bool IsAttachedTo(const TabStrip* tab_strip);
 
   // Returns true if there is a drag underway.
@@ skipping 76 matching lines @@
   };
 
   // Stores the date associated with a single tab that is being dragged.
   struct TabDragData {
     TabDragData();
     ~TabDragData();
 
     // The WebContents being dragged.
     content::WebContents* contents;
 
-    // content::WebContentsDelegate for |contents| before it was detached from
-    // the browser window. We store this so that we can forward certain delegate
-    // notifications back to it if we can't handle them locally.
-    content::WebContentsDelegate* original_delegate;
-
     // This is the index of the tab in |source_tabstrip_| when the drag
     // began. This is used to restore the previous state if the drag is aborted.
     int source_model_index;
 
     // If attached this is the tab in |attached_tabstrip_|.
     Tab* attached_tab;
 
     // Is the tab pinned?
     bool pinned;
   };
 
   typedef std::vector<TabDragData> DragData;
 
   // Sets |drag_data| from |tab|. This also registers for necessary
   // notifications and resets the delegate of the WebContents.
   void InitTabDragData(Tab* tab, TabDragData* drag_data);
 
-  // Overridden from content::WebContentsDelegate:
-  virtual content::WebContents* OpenURLFromTab(
-      content::WebContents* source,
-      const content::OpenURLParams& params) OVERRIDE;
-  virtual void NavigationStateChanged(const content::WebContents* source,
-                                      unsigned changed_flags) OVERRIDE;
-  virtual void AddNewContents(content::WebContents* source,
-                              content::WebContents* new_contents,
-                              WindowOpenDisposition disposition,
-                              const gfx::Rect& initial_pos,
-                              bool user_gesture,
-                              bool* was_blocked) OVERRIDE;
-  virtual bool ShouldSuppressDialogs() OVERRIDE;
-  virtual content::JavaScriptDialogManager*
-      GetJavaScriptDialogManager() OVERRIDE;
-  virtual void RequestMediaAccessPermission(
-      content::WebContents* web_contents,
-      const content::MediaStreamRequest& request,
-      const content::MediaResponseCallback& callback) OVERRIDE;
-
   // Overridden from content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Overriden from views::WidgetObserver:
   virtual void OnWidgetBoundsChanged(views::Widget* widget,
                                      const gfx::Rect& new_bounds) OVERRIDE;
 
   // Overriden from TabStripModelObserver:
@@ skipping 147 matching lines @@
 
   // Restores |initial_selection_model_| to the |source_tabstrip_|.
   void RestoreInitialSelection();
 
   // Finishes a succesful drag operation.
   void CompleteDrag();
 
   // Maximizes the attached window.
   void MaximizeAttachedWindow();
 
-  // Resets the delegates of the WebContents.
-  void ResetDelegates();
-
   // Returns the bounds (in screen coordinates) of the specified View.
   gfx::Rect GetViewScreenBounds(views::View* tabstrip) const;
 
   // Hides the frame for the window that contains the TabStrip the current
   // drag session was initiated from.
   void HideFrame();
 
-  // Closes a hidden frame at the end of a drag session.
-  void CleanUpHiddenFrame();
-
   void BringWindowUnderPointToFront(const gfx::Point& point_in_screen);
 
   // Convenience for getting the TabDragData corresponding to the tab the user
   // started dragging.
   TabDragData* source_tab_drag_data() {
     return &(drag_data_[source_tab_index_]);
   }
 
   // Convenience for |source_tab_drag_data()->contents|.
   content::WebContents* source_dragged_contents() {
@@ skipping 46 matching lines @@
   // Returns true if moving the mouse only changes the visible tabs.
   bool move_only() const {
     return (move_behavior_ == MOVE_VISIBILE_TABS) != 0;
   }
 
   // Returns the NativeWindow at the specified point. If |exclude_dragged_view|
   // is true, then the dragged view is not considered.
   gfx::NativeWindow GetLocalProcessWindow(const gfx::Point& screen_point,
                                           bool exclude_dragged_view);
 
-  // If true detaching creates a new browser and enters a nested message loop.
-  bool detach_into_browser_;
-
   // Handles registering for notifications.
   content::NotificationRegistrar registrar_;
 
   EventSource event_source_;
 
   // The TabStrip the drag originated from.
   TabStrip* source_tabstrip_;
 
   // The TabStrip the dragged Tab is currently attached to, or NULL if the
   // dragged Tab is detached.
@@ skipping 30 matching lines @@
   // A hint to use when positioning new windows created by detaching Tabs. This
   // is the distance of the mouse from the top left of the dragged tab as if it
   // were the distance of the mouse from the top left of the first tab in the
   // attached TabStrip from the top left of the window.
   gfx::Point window_create_point_;
 
   // Location of the first tab in the source tabstrip in screen coordinates.
   // This is used to calculate |window_create_point_|.
   gfx::Point first_source_tab_point_;
 
-  // The bounds of the browser window before the last Tab was detached. When
-  // the last Tab is detached, rather than destroying the frame (which would
-  // abort the drag session), the frame is moved off-screen. If the drag is
-  // aborted (e.g. by the user pressing Esc, or capture being lost), the Tab is
-  // attached to the hidden frame and the frame moved back to these bounds.
-  gfx::Rect restore_bounds_;
-
   // Storage ID in ViewStorage where the last view that had focus in the window
   // containing |source_tab_| is saved. This is saved so that focus can be
   // restored properly when a drag begins and ends within this same window.
   const int old_focused_view_id_;
 
   // The horizontal position of the mouse cursor in screen coordinates at the
   // time of the last re-order event.
   int last_move_screen_loc_;
 
   // Timer used to bring the window under the cursor to front. If the user
@@ skipping 23 matching lines @@
   // details.
   ui::ListSelectionModel initial_selection_model_;
 
   // The selection model of |attached_tabstrip_| before the tabs were attached.
   ui::ListSelectionModel selection_model_before_attach_;
 
   // Initial x-coordinates of the tabs when the drag started. Only used for
   // touch mode.
   std::vector<int> initial_tab_positions_;
 
-  DetachBehavior detach_behavior_;
   MoveBehavior move_behavior_;
 
   // Updated as the mouse is moved when attached. Indicates whether the mouse
   // has ever moved to the left or right. If the tabs are ever detached this
   // is set to kMovedMouseRight | kMovedMouseLeft.
   int mouse_move_direction_;
 
   // Last location used in screen coordinates.
   gfx::Point last_point_in_screen_;
 
@@ skipping 41 matching lines @@
   int attach_index_;
 
   scoped_ptr<ui::EventHandler> escape_tracker_;
 
   base::WeakPtrFactory<TabDragController> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TabDragController);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_TABS_TAB_DRAG_CONTROLLER_H_