Gesture related changes for views:

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/callback.h"
@@ skipping 760 matching lines @@
     move_loop_widget_->RemoveObserver(this);
     move_loop_widget_ = NULL;
 #endif
     views::Widget* browser_widget = GetAttachedBrowserWidget();
     // Need to release the drag controller before starting the move loop as it's
     // going to trigger capture lost, which cancels drag.
     attached_tabstrip_->ReleaseDragController();
     target_tabstrip->OwnDragController(this);
     // Disable animations so that we don't see a close animation on aero.
     browser_widget->SetVisibilityChangedAnimationsEnabled(false);
-    browser_widget->ReleaseMouseCapture();
+    browser_widget->ReleaseCapture();
     // EndMoveLoop is going to snap the window back to its original location.
     // Hide it so users don't see this.
     browser_widget->Hide();
     browser_widget->EndMoveLoop();
 
     // Ideally we would always swap the tabs now, but on windows it seems that
     // running the move loop implicitly activates the window when done, leading
     // to all sorts of flicker. So, on windows, instead we process the move
     // after the loop completes. But on chromeos, we can do tab swapping now to
     // avoid the tab flashing issue(crbug.com/116329).
@@ skipping 319 matching lines @@
   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 mouse capture. This is important so that if activation changes
   // the drag isn't prematurely canceled.
   if (detach_into_browser_) {
-    attached_tabstrip_->GetWidget()->SetMouseCapture(attached_tabstrip_);
+    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_);
   }
 }
 
 void TabDragController::Detach() {
   // Release ownership of the drag controller and mouse capture. When we
   // reattach ownership is transfered.
   if (detach_into_browser_) {
     attached_tabstrip_->ReleaseDragController();
-    attached_tabstrip_->GetWidget()->ReleaseMouseCapture();
+    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()->web_contents()->SetCapturingContents(true);
 
   std::vector<gfx::Rect> drag_bounds = CalculateBoundsForDraggedTabs(0);
@@ skipping 96 matching lines @@
   move_loop_widget_ = GetAttachedBrowserWidget();
   DCHECK(move_loop_widget_);
   move_loop_widget_->AddObserver(this);
   is_dragging_window_ = true;
   bool destroyed = false;
   destroyed_ = &destroyed;
   // Running the move loop releases mouse capture on windows, which triggers
   // destroying the drag loop. Release mouse capture ourself before this while
   // the DragController isn't owned by the TabStrip.
   attached_tabstrip_->ReleaseDragController();
-  attached_tabstrip_->GetWidget()->ReleaseMouseCapture();
+  attached_tabstrip_->GetWidget()->ReleaseCapture();
   attached_tabstrip_->OwnDragController(this);
   views::Widget::MoveLoopResult result = move_loop_widget_->RunMoveLoop();
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TAB_DRAG_LOOP_DONE,
       content::NotificationService::AllBrowserContextsAndSources(),
       content::NotificationService::NoDetails());
 
   if (destroyed)
     return;
   destroyed_ = NULL;
@@ skipping 10 matching lines @@
       Detach();
       // TODO: this needs to query the event.
       gfx::Point screen_point(gfx::Screen::GetCursorScreenPoint());
       Attach(tab_strip_to_attach_to_after_exit_, screen_point);
       // Move the tabs into position.
       MoveAttached(screen_point);
       attached_tabstrip_->GetWidget()->Activate();
       tab_strip_to_attach_to_after_exit_ = NULL;
     }
     DCHECK(attached_tabstrip_);
-    attached_tabstrip_->GetWidget()->SetMouseCapture(attached_tabstrip_);
+    attached_tabstrip_->GetWidget()->SetCapture(attached_tabstrip_);
   } else if (active_) {
     EndDrag(result == views::Widget::MOVE_LOOP_CANCELED);
   }
 }
 
 int TabDragController::GetInsertionIndexFrom(const gfx::Rect& dragged_bounds,
                                              int start,
                                              int delta) const {
   for (int i = start, tab_count = attached_tabstrip_->tab_count();
        i >= 0 && i < tab_count; i += delta) {
@@ skipping 579 matching lines @@
     }
 
     default:
       break; // Nothing to do for DETACH_ABOVE_OR_BELOW.
   }
 
   SetTrackedByWorkspace(browser->window()->GetNativeHandle(), false);
   browser->window()->SetBounds(new_bounds);
   return browser;
 }