More TabStrip refactoring.

chrome/browser/views/tabs/dragged_tab_controller.cc

 // Copyright (c) 2010 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/views/tabs/dragged_tab_controller.h"
 
 #include <math.h>
 #include <set>
 
 #include "app/animation.h"
 #include "app/slide_animation.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/callback.h"
 #include "base/i18n/rtl.h"
 #include "base/keyboard_codes.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/views/frame/browser_view.h"
+#include "chrome/browser/views/tabs/base_tab_renderer.h"
+#include "chrome/browser/views/tabs/base_tab_strip.h"
 #include "chrome/browser/views/tabs/browser_tab_strip_controller.h"
 #include "chrome/browser/views/tabs/dragged_tab_view.h"
 #include "chrome/browser/views/tabs/native_view_photobooth.h"
-#include "chrome/browser/views/tabs/tab.h"
 #include "chrome/browser/views/tabs/tab_strip.h"
 #include "chrome/common/notification_service.h"
 #include "gfx/canvas.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "views/event.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget.h"
 #include "views/window/window.h"
 
@@ skipping 134 matching lines @@
     SkPaint paint;
     paint.setAlpha(128);
     canvas->DrawBitmapInt(image, x, y, paint);
   }
 
   DockInfo::Type type_;
 
   DISALLOW_COPY_AND_ASSIGN(DockView);
 };
 
-gfx::Point ConvertScreenPointToTabStripPoint(TabStrip* tabstrip,
+gfx::Point ConvertScreenPointToTabStripPoint(BaseTabStrip* tabstrip,
                                              const gfx::Point& screen_point) {
   gfx::Point tabstrip_topleft;
   views::View::ConvertPointToScreen(tabstrip, &tabstrip_topleft);
   return gfx::Point(screen_point.x() - tabstrip_topleft.x(),
                     screen_point.y() - tabstrip_topleft.y());
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 112 matching lines @@
   // Have we been hidden?
   bool hidden_;
 
   // Value of DockInfo::in_enable_area.
   bool in_enable_area_;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // DraggedTabController, public:
 
-DraggedTabController::DraggedTabController(Tab* source_tab,
-                                           TabStrip* source_tabstrip)
+DraggedTabController::DraggedTabController(BaseTabRenderer* source_tab,
+                                           BaseTabStrip* source_tabstrip)
     : dragged_contents_(NULL),
       original_delegate_(NULL),
       source_tabstrip_(source_tabstrip),
-      source_model_index_(source_tabstrip->GetModelIndexOfTab(source_tab)),
+      source_model_index_(source_tabstrip->GetModelIndexOfBaseTab(source_tab)),
       attached_tabstrip_(NULL),
       attached_tab_(NULL),
       offset_to_width_ratio_(0),
       old_focused_view_(NULL),
       in_destructor_(false),
       last_move_screen_x_(0),
       mini_(source_tab->data().mini),
       pinned_(source_tabstrip->IsTabPinned(source_tab)),
       started_drag_(false) {
   SetDraggedContents(
       GetModel(source_tabstrip_)->GetTabContentsAt(source_model_index_));
   // Listen for Esc key presses.
   MessageLoopForUI::current()->AddObserver(this);
 }
 
 DraggedTabController::~DraggedTabController() {
   in_destructor_ = true;
   MessageLoopForUI::current()->RemoveObserver(this);
   // Need to delete the view here manually _before_ we reset the dragged
   // contents to NULL, otherwise if the view is animating to its destination
   // bounds, it won't be able to clean up properly since its cleanup routine
   // uses GetIndexForDraggedContents, which will be invalid.
   view_.reset(NULL);
   SetDraggedContents(NULL);  // This removes our observer.
 }
 
-void DraggedTabController::CaptureDragInfo(Tab* tab,
+void DraggedTabController::CaptureDragInfo(views::View* tab,
                                            const gfx::Point& mouse_offset) {
   if (tab->width() > 0) {
     offset_to_width_ratio_ = static_cast<float>(mouse_offset.x()) /
         static_cast<float>(tab->width());
   }
   start_screen_point_ = GetCursorScreenPoint();
   mouse_offset_ = mouse_offset;
   InitWindowCreatePoint();
 }
 
@@ skipping 141 matching lines @@
 // DraggedTabController, private:
 
 void DraggedTabController::InitWindowCreatePoint() {
   // window_create_point_ is only used in CompleteDrag() (through
   // GetWindowCreatePoint() to get the start point of the docked window) when
   // the attached_tabstrip_ is NULL and all the window's related bound
   // information are obtained from source_tabstrip_. So, we need to get the
   // first_tab based on source_tabstrip_, not attached_tabstrip_. Otherwise,
   // the window_create_point_ is not in the correct coordinate system. Please
   // refer to http://crbug.com/6223 comment #15 for detailed information.
-  Tab* first_tab = source_tabstrip_->GetTabAtTabDataIndex(0);
+  views::View* first_tab = source_tabstrip_->base_tab_at_tab_index(0);
   views::View::ConvertPointToWidget(first_tab, &first_source_tab_point_);
   UpdateWindowCreatePoint();
 }
 
 void DraggedTabController::UpdateWindowCreatePoint() {
   // See comments in InitWindowCreatePoint for details on this.
   window_create_point_ = first_source_tab_point_;
   window_create_point_.Offset(mouse_offset_.x(), mouse_offset_.y());
 }
 
@@ skipping 93 matching lines @@
   // windows are open, the coordinates of |source_tab_| are way off in
   // hyperspace since the window was moved there instead of being closed so
   // that we'd keep receiving events. And our ConvertPointToScreen methods
   // aren't really multi-screen aware. So really it's just safer to get the
   // actual position of the mouse cursor directly from Windows here, which is
   // guaranteed to be correct regardless of monitor config.
   gfx::Point screen_point = GetCursorScreenPoint();
 
 #if defined(OS_CHROMEOS)
   // We don't allow detaching in chrome os.
-  TabStrip* target_tabstrip = source_tabstrip_;
+  BaseTabStrip* target_tabstrip = source_tabstrip_;
 #else
   // Determine whether or not we have dragged over a compatible TabStrip in
   // another browser window. If we have, we should attach to it and start
   // dragging within it.
-  TabStrip* target_tabstrip = GetTabStripForPoint(screen_point);
+  BaseTabStrip* target_tabstrip = GetTabStripForPoint(screen_point);
 #endif
   if (target_tabstrip != attached_tabstrip_) {
     // Make sure we're fully detached from whatever TabStrip we're attached to
     // (if any).
     if (attached_tabstrip_)
       Detach();
     if (target_tabstrip)
       Attach(target_tabstrip, screen_point);
   }
   if (!target_tabstrip) {
     bring_to_front_timer_.Start(
         base::TimeDelta::FromMilliseconds(kBringToFrontDelay), this,
         &DraggedTabController::BringWindowUnderMouseToFront);
   }
 
   UpdateDockInfo(screen_point);
 
   if (attached_tabstrip_)
     MoveAttachedTab(screen_point);
   else
     MoveDetachedTab(screen_point);
 }
 
 void DraggedTabController::MoveAttachedTab(const gfx::Point& screen_point) {
   DCHECK(attached_tabstrip_);
   DCHECK(!view_.get());
 
   gfx::Point dragged_view_point = GetAttachedTabDragPoint(screen_point);
-
   TabStripModel* attached_model = GetModel(attached_tabstrip_);
   int from_index = attached_model->GetIndexOfTabContents(dragged_contents_);
 
+  if (attached_tabstrip_->type() == BaseTabStrip::HORIZONTAL_TAB_STRIP) {
+    MoveAttachedTabHorizontalTabStrip(screen_point, attached_model,
+                                      dragged_view_point, from_index);
+  } else {
+    MoveAttachedTabVerticalTabStrip(screen_point, attached_model,
+                                    dragged_view_point, from_index);
+  }
+  attached_tab_->SchedulePaint();
+  attached_tab_->SetX(dragged_view_point.x());
+  attached_tab_->SetY(dragged_view_point.y());
+  attached_tab_->SchedulePaint();
+}
+
+void DraggedTabController::MoveAttachedTabHorizontalTabStrip(
+    const gfx::Point& screen_point,
+    TabStripModel* model,
+    const gfx::Point& dragged_view_point,
+    int from_index) {
+  TabStrip* tab_strip = static_cast<TabStrip*>(attached_tabstrip_);
   // Determine the horizontal move threshold. This is dependent on the width
   // of tabs. The smaller the tabs compared to the standard size, the smaller
   // the threshold.
   double unselected, selected;
-  attached_tabstrip_->GetCurrentTabWidths(&unselected, &selected);
+  tab_strip->GetCurrentTabWidths(&unselected, &selected);
   double ratio = unselected / Tab::GetStandardSize().width();
   int threshold = static_cast<int>(ratio * kHorizontalMoveThreshold);
 
   // Update the model, moving the TabContents from one index to another. Do this
   // only if we have moved a minimum distance since the last reorder (to prevent
   // jitter).
   if (abs(screen_point.x() - last_move_screen_x_) > threshold) {
     gfx::Point dragged_view_screen_point(dragged_view_point);
-    views::View::ConvertPointToScreen(attached_tabstrip_,
-                                      &dragged_view_screen_point);
+    views::View::ConvertPointToScreen(tab_strip, &dragged_view_screen_point);
     gfx::Rect bounds = GetDraggedViewTabStripBounds(dragged_view_screen_point);
     int to_index = GetInsertionIndexForDraggedBounds(bounds, true);
     to_index = NormalizeIndexToAttachedTabStrip(to_index);
     if (from_index != to_index) {
       last_move_screen_x_ = screen_point.x();
-      attached_model->MoveTabContentsAt(from_index, to_index, true);
+      model->MoveTabContentsAt(from_index, to_index, true);
     }
   }
-  attached_tab_->SchedulePaint();
-  attached_tab_->SetX(dragged_view_point.x());
-  attached_tab_->SetY(dragged_view_point.y());
-  attached_tab_->SchedulePaint();
+}
+
+void DraggedTabController::MoveAttachedTabVerticalTabStrip(
+    const gfx::Point& screen_point,
+    TabStripModel* model,
+    const gfx::Point& dragged_view_point,
+    int from_index) {
+  // TODO(sky): implement me.
 }
 
 void DraggedTabController::MoveDetachedTab(const gfx::Point& screen_point) {
   DCHECK(!attached_tabstrip_);
   DCHECK(view_.get());
 
   int x = screen_point.x() - mouse_offset_.x();
   int y = screen_point.y() - mouse_offset_.y();
 
   // Move the View. There are no changes to the model if we're detached.
@@ skipping 14 matching lines @@
     return dock_info_;
   }
 
   gfx::NativeView dragged_hwnd = view_->GetWidget()->GetNativeView();
   dock_windows_.insert(dragged_hwnd);
   DockInfo info = DockInfo::GetDockInfoAtPoint(screen_point, dock_windows_);
   dock_windows_.erase(dragged_hwnd);
   return info;
 }
 
-TabStrip* DraggedTabController::GetTabStripForPoint(
+BaseTabStrip* DraggedTabController::GetTabStripForPoint(
     const gfx::Point& screen_point) {
   gfx::NativeView dragged_view = NULL;
   if (view_.get()) {
     dragged_view = view_->GetWidget()->GetNativeView();
     dock_windows_.insert(dragged_view);
   }
   gfx::NativeWindow local_window =
       DockInfo::GetLocalProcessWindowAtPoint(screen_point, dock_windows_);
   if (dragged_view)
     dock_windows_.erase(dragged_view);
   if (!local_window)
     return NULL;
   BrowserView* browser =
       BrowserView::GetBrowserViewForNativeWindow(local_window);
   // We don't allow drops on windows that don't have tabstrips.
   if (!browser ||
       !browser->browser()->SupportsWindowFeature(Browser::FEATURE_TABSTRIP))
     return NULL;
 
-  TabStrip* other_tabstrip = browser->tabstrip()->AsTabStrip();
+  BaseTabStrip* other_tabstrip = browser->tabstrip();
   if (!other_tabstrip->controller()->IsCompatibleWith(source_tabstrip_))
     return NULL;
   return GetTabStripIfItContains(other_tabstrip, screen_point);
 }
 
-TabStrip* DraggedTabController::GetTabStripIfItContains(
-    TabStrip* tabstrip, const gfx::Point& screen_point) const {
+BaseTabStrip* DraggedTabController::GetTabStripIfItContains(
+    BaseTabStrip* tabstrip, const gfx::Point& screen_point) const {
+  // TODO(sky): this likely needs to be adjusted for vertical tabs.
   static const int kVerticalDetachMagnetism = 15;
   // Make sure the specified screen point is actually within the bounds of the
   // specified tabstrip...
   gfx::Rect tabstrip_bounds = GetViewScreenBounds(tabstrip);
   if (screen_point.x() < tabstrip_bounds.right() &&
       screen_point.x() >= tabstrip_bounds.x()) {
     // TODO(beng): make this be relative to the start position of the mouse for
     // the source TabStrip.
     int upper_threshold = tabstrip_bounds.bottom() + kVerticalDetachMagnetism;
     int lower_threshold = tabstrip_bounds.y() - kVerticalDetachMagnetism;
     if (screen_point.y() >= lower_threshold &&
         screen_point.y() <= upper_threshold) {
       return tabstrip;
     }
   }
   return NULL;
 }
 
-void DraggedTabController::Attach(TabStrip* attached_tabstrip,
+void DraggedTabController::Attach(BaseTabStrip* attached_tabstrip,
                                   const gfx::Point& screen_point) {
   DCHECK(!attached_tabstrip_);  // We should already have detached by the time
                                 // we get here.
   DCHECK(!attached_tab_);  // Similarly there should be no attached tab.
 
   attached_tabstrip_ = attached_tabstrip;
 
   // We don't need the photo-booth while we're attached.
   photobooth_.reset(NULL);
 
   // And we don't need the dragged view.
   view_.reset();
 
-  Tab* tab = GetTabMatchingDraggedContents(attached_tabstrip_);
+  BaseTabRenderer* tab = GetTabMatchingDraggedContents(attached_tabstrip_);
 
   if (!tab) {
     // There is no Tab in |attached_tabstrip| that corresponds to the dragged
     // TabContents. We must now create one.
 
     // Remove ourselves as the delegate now that the dragged TabContents is
     // being inserted back into a Browser.
     dragged_contents_->set_delegate(NULL);
     original_delegate_ = NULL;
 
@@ skipping 79 matching lines @@
   // mirroring transformation flag) which effectively means that even though
   // the tabs are rendered from right to left, the code performs the
   // calculation as if the tabs are laid out from left to right. Mirroring the
   // dragged bounds adjusts the coordinates of the tab we are dragging so that
   // it uses the same orientation used by the tabs on the tab strip.
   gfx::Rect adjusted_bounds(dragged_bounds);
   adjusted_bounds.set_x(
       attached_tabstrip_->MirroredLeftPointForRect(adjusted_bounds));
 
   int index = -1;
-  for (int i = 0; i < attached_tabstrip_->GetTabCount(); ++i) {
-    gfx::Rect ideal_bounds = attached_tabstrip_->GetIdealBounds(i);
+  for (int i = 0; i < attached_tabstrip_->tab_count(); ++i) {
+    const gfx::Rect& ideal_bounds = attached_tabstrip_->ideal_bounds(i);
     gfx::Rect left_half = ideal_bounds;
     left_half.set_width(left_half.width() / 2);
     gfx::Rect right_half = ideal_bounds;
     right_half.set_width(ideal_bounds.width() - left_half.width());
     right_half.set_x(left_half.right());
     right_tab_x = right_half.right();
     if (adjusted_bounds.x() >= right_half.x() &&
         adjusted_bounds.x() < right_half.right()) {
       index = i + 1;
       break;
@@ skipping 19 matching lines @@
 }
 
 gfx::Rect DraggedTabController::GetDraggedViewTabStripBounds(
     const gfx::Point& screen_point) {
   gfx::Point client_point =
       ConvertScreenPointToTabStripPoint(attached_tabstrip_, screen_point);
   if (attached_tab_) {
     return gfx::Rect(client_point.x(), client_point.y(),
                      attached_tab_->width(), attached_tab_->height());
   }
-  // attached_tab_ is NULL when inserting into a new tabstrip.
-  double sel_width, unselected_width;
-  attached_tabstrip_->GetCurrentTabWidths(&sel_width, &unselected_width);
+  if (attached_tabstrip_->type() == BaseTabStrip::HORIZONTAL_TAB_STRIP) {
+    // attached_tab_ is NULL when inserting into a new tabstrip.
+    double sel_width, unselected_width;
+    static_cast<TabStrip*>(attached_tabstrip_)->GetCurrentTabWidths(
+        &sel_width, &unselected_width);
+    return gfx::Rect(client_point.x(), client_point.y(),
+                     static_cast<int>(sel_width),
+                     Tab::GetStandardSize().height());
+  }
   // TODO(sky): this needs to adjust based on orientation of the tab strip.
   return gfx::Rect(client_point.x(), client_point.y(),
-                   static_cast<int>(sel_width),
-                   Tab::GetStandardSize().height());
+                   0, Tab::GetStandardSize().height());
 }
 
 gfx::Point DraggedTabController::GetAttachedTabDragPoint(
     const gfx::Point& screen_point) {
   DCHECK(attached_tabstrip_);  // The tab must be attached.
 
   int x = screen_point.x() - mouse_offset_.x();
   int y = screen_point.y() - mouse_offset_.y();
 
   gfx::Point tab_loc(x, y);
   views::View::ConvertPointToView(NULL, attached_tabstrip_, &tab_loc);
 
   x = tab_loc.x();
   y = tab_loc.y();
 
   const gfx::Size& tab_size = attached_tab_->bounds().size();
 
   int max_x = attached_tabstrip_->bounds().right() - tab_size.width();
   // TODO(sky): this needs to adjust based on orientation of the tab strip.
   x = std::min(std::max(x, 0), max_x);
   y = 0;
   return gfx::Point(x, y);
 }
 
-Tab* DraggedTabController::GetTabMatchingDraggedContents(
-    TabStrip* tabstrip) const {
-  int model_index = GetModel(tabstrip)->GetIndexOfTabContents(dragged_contents_);
+BaseTabRenderer* DraggedTabController::GetTabMatchingDraggedContents(
+    BaseTabStrip* tabstrip) const {
+  int model_index =
+      GetModel(tabstrip)->GetIndexOfTabContents(dragged_contents_);
   return model_index == TabStripModel::kNoTab ?
-      NULL : tabstrip->GetTabAtModelIndex(model_index);
+      NULL : tabstrip->GetBaseTabAtModelIndex(model_index);
 }
 
 void DraggedTabController::EndDragImpl(EndDragType type) {
   // WARNING: this may be invoked multiple times. In particular, if deletion
   // occurs after a delay (as it does when the tab is released in the original
   // tab strip) and the navigation controller/tab contents is deleted before
   // the animation finishes, this is invoked twice. The second time through
   // type == TAB_DESTROYED.
 
   bring_to_front_timer_.Stop();
@@ skipping 280 matching lines @@
 #else
     NOTIMPLEMENTED();
 #endif
   }
 }
 
 TabStripModel* DraggedTabController::GetModel(BaseTabStrip* tabstrip) const {
   return static_cast<BrowserTabStripController*>(tabstrip->controller())->
       model();
 }