Gets tab dragging to work in touch mode.

chrome/browser/ui/views/tabs/tab_strip.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_strip.h"
 
 #include <algorithm>
 #include <iterator>
 #include <vector>
 
@@ skipping 492 matching lines @@
     DoLayout();
 }
 
 void TabStrip::MoveTab(int from_model_index,
                        int to_model_index,
                        const TabRendererData& data) {
   DCHECK_GT(tabs_.view_size(), 0);
   BaseTab* last_tab = tab_at(tab_count() - 1);
   tab_at(from_model_index)->SetData(data);
   if (touch_layout_.get()) {
-    tabs_.Move(from_model_index, to_model_index);
-    int mini_tab_count = 0;
-    int start_x = GenerateIdealBoundsForMiniTabs(&mini_tab_count);
+    tabs_.MoveViewOnly(from_model_index, to_model_index);
+    int mini_count = 0;
+    GenerateIdealBoundsForMiniTabs(&mini_count);
     touch_layout_->MoveTab(
         from_model_index, to_model_index, controller_->GetActiveIndex(),
-        start_x, mini_tab_count);
+        GetStartXForNormalTabs(), mini_count);
   } else {
     tabs_.Move(from_model_index, to_model_index);
   }
   StartMoveTabAnimation();
   if (TabDragController::IsAttachedTo(this) &&
       (last_tab != tab_at(tab_count() - 1) || last_tab->dragging())) {
     newtab_button_->SetVisible(false);
   }
 }
 
@@ skipping 260 matching lines @@
   }
   DCHECK(!tabs.empty());
   DCHECK(std::find(tabs.begin(), tabs.end(), tab) != tabs.end());
   TabStripSelectionModel selection_model;
   if (!original_selection.IsSelected(model_index))
     selection_model.Copy(original_selection);
   // Delete the existing DragController before creating a new one. We do this as
   // creating the DragController remembers the WebContents delegates and we need
   // to make sure the existing DragController isn't still a delegate.
   drag_controller_.reset();
+  // TODO(sky): verify ET_TOUCH_PRESSED is right.
+  bool move_only = touch_layout_.get() &&
+      (event.type() == ui::ET_TOUCH_PRESSED ||
+       (event.type() == ui::ET_MOUSE_PRESSED &&
+        event.flags() & ui::EF_CONTROL_DOWN));
   drag_controller_.reset(TabDragController::Create(
       this, tab, tabs, gfx::Point(x, y), tab->GetMirroredXInView(event.x()),
-      selection_model, touch_layout_.get() != NULL));
-  // TODO: Instead of touch layout need to look at event type, eg
-  // event.type() == ui::ET_TOUCH_PRESSED)), and need to plumb through long
-  // press and touch stuff.
+      selection_model, move_only));
 }
 
 void TabStrip::ContinueDrag(const views::MouseEvent& event) {
   if (drag_controller_.get())
     drag_controller_->Drag();
 }
 
 bool TabStrip::EndDrag(bool canceled) {
   if (!drag_controller_.get())
     return false;
@@ skipping 502 matching lines @@
     set_ideal_bounds(i, bounds);
   }
   touch_layout_->DragActiveTab(delta);
   DoLayout();
 }
 
 void TabStrip::LayoutDraggedTabsAt(const std::vector<BaseTab*>& tabs,
                                    BaseTab* active_tab,
                                    const gfx::Point& location,
                                    bool initial_drag) {
-  if (touch_layout_.get()) {
-    touch_layout_->DragActiveTab(location.x() - active_tab->bounds().x());
-    DoLayout();
-    return;
-  }
   // Immediately hide the new tab button if the last tab is being dragged.
   if (tab_at(tab_count() - 1)->dragging())
     newtab_button_->SetVisible(false);
   std::vector<gfx::Rect> bounds;
   CalculateBoundsForDraggedTabs(tabs, &bounds);
   DCHECK_EQ(tabs.size(), bounds.size());
   int active_tab_model_index = GetModelIndexOfBaseTab(active_tab);
   int active_tab_index = static_cast<int>(
       std::find(tabs.begin(), tabs.end(), active_tab) - tabs.begin());
   for (size_t i = 0; i < tabs.size(); ++i) {
@@ skipping 605 matching lines @@
   }
   return NULL;
 }
 
 std::vector<int> TabStrip::GetTabXCoordinates() {
   std::vector<int> results;
   for (int i = 0; i < tab_count(); ++i)
     results.push_back(ideal_bounds(i).x());
   return results;
 }