Add Vector2d classes that represent offsets, instead of using Point.

chrome/browser/ui/panels/panel_drag_browsertest.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 "base/message_loop.h"
 #include "chrome/browser/ui/panels/base_panel_browser_test.h"
 #include "chrome/browser/ui/panels/detached_panel_strip.h"
 #include "chrome/browser/ui/panels/docked_panel_strip.h"
 #include "chrome/browser/ui/panels/native_panel.h"
 #include "chrome/browser/ui/panels/panel.h"
@@ skipping 17 matching lines @@
 
     // All the tests here assume using mocked 800x600 screen area for the
     // primary monitor. Do the check now.
     gfx::Rect primary_screen_area = PanelManager::GetInstance()->
         display_settings_provider()->GetPrimaryScreenArea();
     DCHECK(primary_screen_area.width() == 800);
     DCHECK(primary_screen_area.height() == 600);
   }
 
   // Drag |panel| from its origin by the offset |delta|.
-  void DragPanelByDelta(Panel* panel, const gfx::Point& delta) {
+  void DragPanelByDelta(Panel* panel, const gfx::Vector2d& delta) {
     scoped_ptr<NativePanelTesting> panel_testing(
         CreateNativePanelTesting(panel));
     gfx::Point mouse_location(panel->GetBounds().origin());
     panel_testing->PressLeftMouseButtonTitlebar(mouse_location);
     panel_testing->DragTitlebar(mouse_location.Add(delta));
     panel_testing->FinishDragTitlebar();
   }
 
   // Drag |panel| from its origin to |new_mouse_location|.
   void DragPanelToMouseLocation(Panel* panel,
                                 const gfx::Point& new_mouse_location) {
     scoped_ptr<NativePanelTesting> panel_testing(
         CreateNativePanelTesting(panel));
     gfx::Point mouse_location(panel->GetBounds().origin());
     panel_testing->PressLeftMouseButtonTitlebar(panel->GetBounds().origin());
     panel_testing->DragTitlebar(new_mouse_location);
     panel_testing->FinishDragTitlebar();
   }
 
-  static gfx::Point GetDragDeltaToRemainDocked() {
-    return gfx::Point(
+  static gfx::Vector2d GetDragDeltaToRemainDocked() {
+    return gfx::Vector2d(
         -5,
         -(PanelDragController::GetDetachDockedPanelThreshold() / 2));
   }
 
-  static gfx::Point GetDragDeltaToDetach() {
-    return gfx::Point(
+  static gfx::Vector2d GetDragDeltaToDetach() {
+    return gfx::Vector2d(
         -20,
         -(PanelDragController::GetDetachDockedPanelThreshold() + 20));
   }
 
-  static gfx::Point GetDragDeltaToRemainDetached(Panel* panel) {
+  static gfx::Vector2d GetDragDeltaToRemainDetached(Panel* panel) {
     int distance = panel->manager()->docked_strip()->display_area().bottom() -
                    panel->GetBounds().bottom();
-    return gfx::Point(
+    return gfx::Vector2d(
         -5,
         distance - PanelDragController::GetDockDetachedPanelThreshold() * 2);
   }
 
-  static gfx::Point GetDragDeltaToAttach(Panel* panel) {
+  static gfx::Vector2d GetDragDeltaToAttach(Panel* panel) {
     int distance = panel->manager()->docked_strip()->display_area().bottom() -
                    panel->GetBounds().bottom();
-    return gfx::Point(
+    return gfx::Vector2d(
         -20,
         distance - PanelDragController::GetDockDetachedPanelThreshold() / 2);
   }
 };
 
 IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DragOneDockedPanel) {
   static const int big_delta_x = 70;
   static const int big_delta_y = 30;  // Do not exceed the threshold to detach.
 
   Panel* panel = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100));
@@ skipping 78 matching lines @@
   panel_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(panel_old_bounds, panel->GetBounds());
 
   panel_testing->FinishDragTitlebar();
   EXPECT_EQ(panel_old_bounds, panel->GetBounds());
 
   PanelManager::GetInstance()->CloseAll();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DragTwoDockedPanels) {
-  static const gfx::Point small_delta(10, 0);
+  static const gfx::Vector2d small_delta(10, 0);
 
   Panel* panel1 = CreateDockedPanel("1", gfx::Rect(0, 0, 100, 100));
   Panel* panel2 = CreateDockedPanel("2", gfx::Rect(0, 0, 100, 100));
   scoped_ptr<NativePanelTesting> panel1_testing(
       CreateNativePanelTesting(panel1));
   scoped_ptr<NativePanelTesting> panel2_testing(
       CreateNativePanelTesting(panel2));
   gfx::Point position1 = panel1->GetBounds().origin();
   gfx::Point position2 = panel2->GetBounds().origin();
 
@@ skipping 13 matching lines @@
   EXPECT_EQ(position1, panel1->GetBounds().origin());
   EXPECT_EQ(position2, panel2->GetBounds().origin());
 
   // Drag right panel towards left with big delta.
   // Expect shuffle: P2 P1
   mouse_location = position1;
   panel1_testing->PressLeftMouseButtonTitlebar(mouse_location);
   EXPECT_EQ(position1, panel1->GetBounds().origin());
   EXPECT_EQ(position2, panel2->GetBounds().origin());
 
-  mouse_location = position2.Add(gfx::Point(1, 0));
+  mouse_location = position2.Add(gfx::Vector2d(1, 0));
   panel1_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(mouse_location, panel1->GetBounds().origin());
   EXPECT_EQ(position1, panel2->GetBounds().origin());
 
   panel1_testing->FinishDragTitlebar();
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position1, panel2->GetBounds().origin());
 
   // Drag left panel towards right with small delta.
   // Expect no shuffle: P2 P1
@@ skipping 11 matching lines @@
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position1, panel2->GetBounds().origin());
 
   // Drag left panel towards right with big delta.
   // Expect shuffle: P1 P2
   mouse_location = position2;
   panel1_testing->PressLeftMouseButtonTitlebar(mouse_location);
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position1, panel2->GetBounds().origin());
 
-  mouse_location = position1.Add(gfx::Point(1, 0));
+  mouse_location = position1.Add(gfx::Vector2d(1, 0));
   panel1_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(mouse_location, panel1->GetBounds().origin());
   EXPECT_EQ(position2, panel2->GetBounds().origin());
 
   panel1_testing->FinishDragTitlebar();
   EXPECT_EQ(position1, panel1->GetBounds().origin());
   EXPECT_EQ(position2, panel2->GetBounds().origin());
 
   // Drag right panel towards left with big delta and then cancel the drag.
   // Expect shuffle after drag:   P2 P1
   // Expect shuffle after cancel: P1 P2
   mouse_location = position1;
   panel1_testing->PressLeftMouseButtonTitlebar(mouse_location);
   EXPECT_EQ(position1, panel1->GetBounds().origin());
   EXPECT_EQ(position2, panel2->GetBounds().origin());
 
-  mouse_location = position2.Add(gfx::Point(1, 0));
+  mouse_location = position2.Add(gfx::Vector2d(1, 0));
   panel1_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(mouse_location, panel1->GetBounds().origin());
   EXPECT_EQ(position1, panel2->GetBounds().origin());
 
   panel1_testing->CancelDragTitlebar();
   EXPECT_EQ(position1, panel1->GetBounds().origin());
   EXPECT_EQ(position2, panel2->GetBounds().origin());
 
   PanelManager::GetInstance()->CloseAll();
 }
@@ skipping 13 matching lines @@
   // Drag leftmost panel to become the rightmost in 2 drags. Each drag will
   // shuffle one panel.
   // Expect shuffle after 1st drag: P1 P3 P2
   // Expect shuffle after 2nd drag: P3 P1 P2
   gfx::Point mouse_location = position3;
   panel3_testing->PressLeftMouseButtonTitlebar(mouse_location);
   EXPECT_EQ(position1, panel1->GetBounds().origin());
   EXPECT_EQ(position2, panel2->GetBounds().origin());
   EXPECT_EQ(position3, panel3->GetBounds().origin());
 
-  mouse_location = position2.Add(gfx::Point(1, 0));
+  mouse_location = position2.Add(gfx::Vector2d(1, 0));
   panel3_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(position1, panel1->GetBounds().origin());
   EXPECT_EQ(position3, panel2->GetBounds().origin());
   EXPECT_EQ(mouse_location, panel3->GetBounds().origin());
 
-  mouse_location = position1.Add(gfx::Point(1, 0));
+  mouse_location = position1.Add(gfx::Vector2d(1, 0));
   panel3_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position3, panel2->GetBounds().origin());
   EXPECT_EQ(mouse_location, panel3->GetBounds().origin());
 
   panel3_testing->FinishDragTitlebar();
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position3, panel2->GetBounds().origin());
   EXPECT_EQ(position1, panel3->GetBounds().origin());
 
   // Drag rightmost panel to become the leftmost in 2 drags and then cancel the
   // drag. Each drag will shuffle one panel and the cancellation will restore
   // all panels.
   // Expect shuffle after 1st drag: P1 P3 P2
   // Expect shuffle after 2nd drag: P1 P2 P3
   // Expect shuffle after cancel:   P3 P1 P2
   mouse_location = position1;
   panel3_testing->PressLeftMouseButtonTitlebar(mouse_location);
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position3, panel2->GetBounds().origin());
   EXPECT_EQ(position1, panel3->GetBounds().origin());
 
-  mouse_location = position2.Add(gfx::Point(1, 0));
+  mouse_location = position2.Add(gfx::Vector2d(1, 0));
   panel3_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(position1, panel1->GetBounds().origin());
   EXPECT_EQ(position3, panel2->GetBounds().origin());
   EXPECT_EQ(mouse_location, panel3->GetBounds().origin());
 
-  mouse_location = position3.Add(gfx::Point(1, 0));
+  mouse_location = position3.Add(gfx::Vector2d(1, 0));
   panel3_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(position1, panel1->GetBounds().origin());
   EXPECT_EQ(position2, panel2->GetBounds().origin());
   EXPECT_EQ(mouse_location, panel3->GetBounds().origin());
 
   panel3_testing->CancelDragTitlebar();
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position3, panel2->GetBounds().origin());
   EXPECT_EQ(position1, panel3->GetBounds().origin());
 
   // Drag leftmost panel to become the rightmost in a single drag. The drag will
   // shuffle 2 panels at a time.
   // Expect shuffle: P2 P3 P1
   mouse_location = position3;
   panel2_testing->PressLeftMouseButtonTitlebar(mouse_location);
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position3, panel2->GetBounds().origin());
   EXPECT_EQ(position1, panel3->GetBounds().origin());
 
-  mouse_location = position1.Add(gfx::Point(1, 0));
+  mouse_location = position1.Add(gfx::Vector2d(1, 0));
   panel2_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(position3, panel1->GetBounds().origin());
   EXPECT_EQ(mouse_location, panel2->GetBounds().origin());
   EXPECT_EQ(position2, panel3->GetBounds().origin());
 
   panel2_testing->FinishDragTitlebar();
   EXPECT_EQ(position3, panel1->GetBounds().origin());
   EXPECT_EQ(position1, panel2->GetBounds().origin());
   EXPECT_EQ(position2, panel3->GetBounds().origin());
 
   // Drag rightmost panel to become the leftmost in a single drag. The drag will
   // shuffle 2 panels at a time.
   // Expect shuffle: P3 P1 P2
   mouse_location = position1;
   panel2_testing->PressLeftMouseButtonTitlebar(mouse_location);
   EXPECT_EQ(position3, panel1->GetBounds().origin());
   EXPECT_EQ(position1, panel2->GetBounds().origin());
   EXPECT_EQ(position2, panel3->GetBounds().origin());
 
-  mouse_location = position3.Add(gfx::Point(1, 0));
+  mouse_location = position3.Add(gfx::Vector2d(1, 0));
   panel2_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(mouse_location, panel2->GetBounds().origin());
   EXPECT_EQ(position1, panel3->GetBounds().origin());
 
   panel2_testing->FinishDragTitlebar();
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position3, panel2->GetBounds().origin());
   EXPECT_EQ(position1, panel3->GetBounds().origin());
 
   // Drag rightmost panel to become the leftmost in a single drag and then
   // cancel the drag. The drag will shuffle 2 panels and the cancellation will
   // restore all panels.
   // Expect shuffle after drag:   P1 P2 P3
   // Expect shuffle after cancel: P3 P1 P2
   mouse_location = position1;
   panel3_testing->PressLeftMouseButtonTitlebar(mouse_location);
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position3, panel2->GetBounds().origin());
   EXPECT_EQ(position1, panel3->GetBounds().origin());
 
-  mouse_location = position3.Add(gfx::Point(1, 0));
+  mouse_location = position3.Add(gfx::Vector2d(1, 0));
   panel3_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(position1, panel1->GetBounds().origin());
   EXPECT_EQ(position2, panel2->GetBounds().origin());
   EXPECT_EQ(mouse_location, panel3->GetBounds().origin());
 
   panel3_testing->CancelDragTitlebar();
   EXPECT_EQ(position2, panel1->GetBounds().origin());
   EXPECT_EQ(position3, panel2->GetBounds().origin());
   EXPECT_EQ(position1, panel3->GetBounds().origin());
 
@@ skipping 450 matching lines @@
 
   // Press on title-bar.
   scoped_ptr<NativePanelTesting> panel_testing(
       CreateNativePanelTesting(panel));
   gfx::Point mouse_location(panel->GetBounds().origin());
   panel_testing->PressLeftMouseButtonTitlebar(mouse_location);
 
   // Drag up the panel in a small offset that does not trigger the detach.
   // Expect that the panel is still docked and only x coordinate of its position
   // is changed.
-  gfx::Point drag_delta_to_remain_docked = GetDragDeltaToRemainDocked();
+  gfx::Vector2d drag_delta_to_remain_docked = GetDragDeltaToRemainDocked();
   mouse_location = mouse_location.Add(drag_delta_to_remain_docked);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(1, docked_strip->num_panels());
   ASSERT_EQ(0, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type());
   gfx::Rect panel_new_bounds = panel_old_bounds;
   panel_new_bounds.Offset(drag_delta_to_remain_docked.x(), 0);
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
   // Continue dragging up the panel in big offset that triggers the detach.
   // Expect that the panel is previewed as detached.
-  gfx::Point drag_delta_to_detach = GetDragDeltaToDetach();
+  gfx::Vector2d drag_delta_to_detach = GetDragDeltaToDetach();
   mouse_location = mouse_location.Add(drag_delta_to_detach);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(0, docked_strip->num_panels());
   ASSERT_EQ(1, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type());
   panel_new_bounds.Offset(
       drag_delta_to_detach.x(),
       drag_delta_to_detach.y() + drag_delta_to_remain_docked.y());
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
@@ skipping 22 matching lines @@
 
   // Press on title-bar.
   scoped_ptr<NativePanelTesting> panel_testing(
       CreateNativePanelTesting(panel));
   gfx::Point mouse_location(panel->GetBounds().origin());
   panel_testing->PressLeftMouseButtonTitlebar(mouse_location);
 
   // Drag up the panel in a small offset that does not trigger the detach.
   // Expect that the panel is still docked and only x coordinate of its position
   // is changed.
-  gfx::Point drag_delta_to_remain_docked = GetDragDeltaToRemainDocked();
+  gfx::Vector2d drag_delta_to_remain_docked = GetDragDeltaToRemainDocked();
   mouse_location = mouse_location.Add(drag_delta_to_remain_docked);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(1, docked_strip->num_panels());
   ASSERT_EQ(0, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type());
   gfx::Rect panel_new_bounds = panel_old_bounds;
   panel_new_bounds.Offset(drag_delta_to_remain_docked.x(), 0);
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
   // Continue dragging up the panel in big offset that triggers the detach.
   // Expect that the panel is previewed as detached.
-  gfx::Point drag_delta_to_detach = GetDragDeltaToDetach();
+  gfx::Vector2d drag_delta_to_detach = GetDragDeltaToDetach();
   mouse_location = mouse_location.Add(drag_delta_to_detach);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(0, docked_strip->num_panels());
   ASSERT_EQ(1, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type());
   panel_new_bounds.Offset(
       drag_delta_to_detach.x(),
       drag_delta_to_detach.y() + drag_delta_to_remain_docked.y());
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
@@ skipping 22 matching lines @@
   gfx::Rect panel_old_bounds = panel->GetBounds();
 
   // Press on title-bar.
   scoped_ptr<NativePanelTesting> panel_testing(
       CreateNativePanelTesting(panel));
   gfx::Point mouse_location(panel->GetBounds().origin());
   panel_testing->PressLeftMouseButtonTitlebar(mouse_location);
 
   // Drag down the panel but not close enough to the bottom of work area.
   // Expect that the panel is still detached.
-  gfx::Point drag_delta_to_remain_detached =
+  gfx::Vector2d drag_delta_to_remain_detached =
       GetDragDeltaToRemainDetached(panel);
   mouse_location = mouse_location.Add(drag_delta_to_remain_detached);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(0, docked_strip->num_panels());
   ASSERT_EQ(1, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type());
   gfx::Rect panel_new_bounds = panel_old_bounds;
   panel_new_bounds.Offset(drag_delta_to_remain_detached);
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
   // Continue dragging down the panel to make it close enough to the bottom of
   // work area.
   // Expect that the panel is previewed as docked.
-  gfx::Point drag_delta_to_attach = GetDragDeltaToAttach(panel);
+  gfx::Vector2d drag_delta_to_attach = GetDragDeltaToAttach(panel);
   mouse_location = mouse_location.Add(drag_delta_to_attach);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(1, docked_strip->num_panels());
   ASSERT_EQ(0, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type());
   panel_new_bounds.Offset(drag_delta_to_attach);
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
   // Finish the drag.
   // Expect that the panel stays as docked and moves to the final position.
@@ skipping 24 matching lines @@
   gfx::Rect panel_old_bounds = panel->GetBounds();
 
   // Press on title-bar.
   scoped_ptr<NativePanelTesting> panel_testing(
       CreateNativePanelTesting(panel));
   gfx::Point mouse_location(panel->GetBounds().origin());
   panel_testing->PressLeftMouseButtonTitlebar(mouse_location);
 
   // Drag down the panel but not close enough to the bottom of work area.
   // Expect that the panel is still detached.
-  gfx::Point drag_delta_to_remain_detached =
+  gfx::Vector2d drag_delta_to_remain_detached =
       GetDragDeltaToRemainDetached(panel);
   mouse_location = mouse_location.Add(drag_delta_to_remain_detached);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(0, docked_strip->num_panels());
   ASSERT_EQ(1, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type());
   gfx::Rect panel_new_bounds = panel_old_bounds;
   panel_new_bounds.Offset(drag_delta_to_remain_detached);
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
   // Continue dragging down the panel to make it close enough to the bottom of
   // work area.
   // Expect that the panel is previewed as docked.
-  gfx::Point drag_delta_to_attach = GetDragDeltaToAttach(panel);
+  gfx::Vector2d drag_delta_to_attach = GetDragDeltaToAttach(panel);
   mouse_location = mouse_location.Add(drag_delta_to_attach);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(1, docked_strip->num_panels());
   ASSERT_EQ(0, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type());
   panel_new_bounds.Offset(drag_delta_to_attach);
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
   // Cancel the drag.
   // Expect that the panel is back as detached.
@@ skipping 19 matching lines @@
   gfx::Rect panel_old_bounds = panel->GetBounds();
 
   // Press on title-bar.
   scoped_ptr<NativePanelTesting> panel_testing(
       CreateNativePanelTesting(panel));
   gfx::Point mouse_location(panel->GetBounds().origin());
   panel_testing->PressLeftMouseButtonTitlebar(mouse_location);
 
   // Drag up the panel to trigger the detach.
   // Expect that the panel is previewed as detached.
-  gfx::Point drag_delta_to_detach = GetDragDeltaToDetach();
+  gfx::Vector2d drag_delta_to_detach = GetDragDeltaToDetach();
   mouse_location = mouse_location.Add(drag_delta_to_detach);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(0, docked_strip->num_panels());
   ASSERT_EQ(1, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type());
   gfx::Rect panel_new_bounds = panel_old_bounds;
   panel_new_bounds.Offset(drag_delta_to_detach);
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
   // Continue dragging down the panel to trigger the re-attach.
-  gfx::Point drag_delta_to_reattach = GetDragDeltaToAttach(panel);
+  gfx::Vector2d drag_delta_to_reattach = GetDragDeltaToAttach(panel);
   mouse_location = mouse_location.Add(drag_delta_to_reattach);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(1, docked_strip->num_panels());
   ASSERT_EQ(0, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type());
   panel_new_bounds.Offset(drag_delta_to_reattach);
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
   // Continue dragging up the panel to trigger the detach again.
-  gfx::Point drag_delta_to_detach_again = GetDragDeltaToDetach();
+  gfx::Vector2d drag_delta_to_detach_again = GetDragDeltaToDetach();
   mouse_location = mouse_location.Add(drag_delta_to_detach_again);
   panel_testing->DragTitlebar(mouse_location);
   ASSERT_EQ(0, docked_strip->num_panels());
   ASSERT_EQ(1, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type());
   panel_new_bounds.Offset(drag_delta_to_detach_again);
   EXPECT_EQ(panel_new_bounds, panel->GetBounds());
 
   // Cancel the drag.
   // Expect that the panel stays as docked.
   panel_testing->CancelDragTitlebar();
   ASSERT_EQ(1, docked_strip->num_panels());
   ASSERT_EQ(0, detached_strip->num_panels());
   EXPECT_EQ(PanelStrip::DOCKED, panel->panel_strip()->type());
   EXPECT_EQ(panel_old_bounds, panel->GetBounds());
 
   panel_manager->CloseAll();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelDragBrowserTest, DetachWithSqueeze) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   DockedPanelStrip* docked_strip = panel_manager->docked_strip();
   DetachedPanelStrip* detached_strip = panel_manager->detached_strip();
 
-  gfx::Point drag_delta_to_detach = GetDragDeltaToDetach();
+  gfx::Vector2d drag_delta_to_detach = GetDragDeltaToDetach();
 
   // Create some docked panels.
   //   docked:    P1  P2  P3  P4  P5
   Panel* panel1 = CreateDockedPanel("1", gfx::Rect(0, 0, 200, 100));
   Panel* panel2 = CreateDockedPanel("2", gfx::Rect(0, 0, 200, 100));
   Panel* panel3 = CreateDockedPanel("3", gfx::Rect(0, 0, 200, 100));
   Panel* panel4 = CreateDockedPanel("4", gfx::Rect(0, 0, 200, 100));
   Panel* panel5 = CreateDockedPanel("5", gfx::Rect(0, 0, 200, 100));
   ASSERT_EQ(0, detached_strip->num_panels());
   ASSERT_EQ(5, docked_strip->num_panels());
@@ skipping 194 matching lines @@
 
   // Drag down the panel. Expect that the panel can be dragged without
   // constraint.
   drag_to_location = gfx::Point(280, 150);
   DragPanelToMouseLocation(panel, drag_to_location);
   EXPECT_EQ(PanelStrip::DETACHED, panel->panel_strip()->type());
   EXPECT_EQ(drag_to_location, panel->GetBounds().origin());
 
   panel_manager->CloseAll();
 }