Support detaching/attaching panels via inter-strip drags.

chrome/browser/ui/panels/panel_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/bind.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/net/url_request_mock_util.h"
@@ skipping 160 matching lines @@
     //              expected_bounds_after_cancel != test_begin_bounds.
     std::vector<gfx::Rect> test_begin_bounds = GetAllPanelBounds();
 
     NativePanel* panel_to_drag = panels[drag_index]->native_panel();
     scoped_ptr<NativePanelTesting> panel_testing_to_drag(
         NativePanelTesting::Create(panel_to_drag));
 
     if (drag_action & DRAG_ACTION_BEGIN) {
       // Trigger the mouse-pressed event.
       // All panels should remain in their original positions.
+      test_dragging_mouse_location_ = panels[drag_index]->GetBounds().origin();
       panel_testing_to_drag->PressLeftMouseButtonTitlebar(
-          panels[drag_index]->GetBounds().origin());
+          test_dragging_mouse_location_);
       EXPECT_EQ(test_begin_bounds, GetPanelBounds(panels));
     }
 
     // Trigger the drag.
-    panel_testing_to_drag->DragTitlebar(delta_x, delta_y);
+    test_dragging_mouse_location_.Offset(delta_x, delta_y);
+    panel_testing_to_drag->DragTitlebar(test_dragging_mouse_location_);
 
     // Compare against expected bounds.
     EXPECT_EQ(AddXDeltaToBounds(test_begin_bounds, expected_delta_x_after_drag),
               GetPanelBounds(panels));
 
     if (drag_action & DRAG_ACTION_CANCEL) {
       // Cancel the drag.
       // All panels should return to their initial positions.
       panel_testing_to_drag->CancelDragTitlebar();
       EXPECT_EQ(expected_bounds_after_cancel, GetAllPanelBounds());
@@ skipping 200 matching lines @@
         MoveMouse(minimized_bounds[index].origin());
     }
 
     // The below could be separate tests, just adding a TODO here for tracking.
     // TODO(prasadt): Add test for dragging when in titlebar exposed state.
     // TODO(prasadt): Add test in presence of auto hiding task bar.
 
     for (size_t i = 0; i < panels.size(); ++i)
       delete native_panels_testing[i];
   }
+
+ private:
+  gfx::Point test_dragging_mouse_location_;
 };
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreatePanel) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially.
 
   Panel* panel = CreatePanel("PanelTest");
   EXPECT_EQ(1, panel_manager->num_panels());
 
   gfx::Rect bounds = panel->GetBounds();
@@ skipping 353 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, NotDraggable) {
   Panel* panel = CreatePanel("panel");
   // This is used to simulate making a docked panel not draggable.
   panel->set_has_temporary_layout(true);
   Panel* panel2 = CreatePanel("panel2");
 
   scoped_ptr<NativePanelTesting> panel_testing(
       NativePanelTesting::Create(panel->native_panel()));
   gfx::Rect bounds = panel->GetBounds();
-  panel_testing->PressLeftMouseButtonTitlebar(bounds.origin());
+  gfx::Point mouse_location = bounds.origin();
+  panel_testing->PressLeftMouseButtonTitlebar(mouse_location);
   EXPECT_EQ(bounds.x(), panel->GetBounds().x());
-  panel_testing->DragTitlebar(-50, 10);
+  mouse_location.Offset(-50, 10);
+  panel_testing->DragTitlebar(mouse_location);
   EXPECT_EQ(bounds.x(), panel->GetBounds().x());
   panel_testing->FinishDragTitlebar();
   EXPECT_EQ(bounds.x(), panel->GetBounds().x());
 
   // Reset the simulation hack so that the panel can be closed correctly.
   panel->set_has_temporary_layout(false);
   panel->Close();
   panel2->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CloseDockedPanelOnDrag) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   PanelDragController* drag_controller = panel_manager->drag_controller();
   DockedPanelStrip* docked_strip = panel_manager->docked_strip();
 
-  // Create 4 detached panels.
+  // Create 4 docked panels.
   // We have:  P4  P3  P2  P1
   Panel* panel1 = CreatePanelWithBounds("Panel1", gfx::Rect(0, 0, 100, 100));
   Panel* panel2 = CreatePanelWithBounds("Panel2", gfx::Rect(0, 0, 100, 100));
   Panel* panel3 = CreatePanelWithBounds("Panel3", gfx::Rect(0, 0, 100, 100));
   Panel* panel4 = CreatePanelWithBounds("Panel4", gfx::Rect(0, 0, 100, 100));
   ASSERT_EQ(4, docked_strip->num_panels());
 
   scoped_ptr<NativePanelTesting> panel1_testing(
       NativePanelTesting::Create(panel1->native_panel()));
   gfx::Point position1 = panel1->GetBounds().origin();
   gfx::Point position2 = panel2->GetBounds().origin();
   gfx::Point position3 = panel3->GetBounds().origin();
   gfx::Point position4 = panel4->GetBounds().origin();
 
   // Test the scenario: drag a panel, close another panel, cancel the drag.
   {
     std::vector<Panel*> panels;
     gfx::Point panel1_new_position = position1;
     panel1_new_position.Offset(-500, 0);
 
     // Start dragging a panel.
     // We have:  P1*  P4  P3  P2
+    gfx::Point mouse_location = panel1->GetBounds().origin();
     panel1_testing->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin());
-    panel1_testing->DragTitlebar(-500, -5);
+    mouse_location.Offset(-500, -5);
+    panel1_testing->DragTitlebar(mouse_location);
     EXPECT_TRUE(drag_controller->IsDragging());
     EXPECT_EQ(panel1, drag_controller->dragging_panel());
 
     ASSERT_EQ(4, docked_strip->num_panels());
     panels = PanelManager::GetInstance()->panels();
     EXPECT_EQ(panel2, panels[0]);
     EXPECT_EQ(panel3, panels[1]);
     EXPECT_EQ(panel4, panels[2]);
     EXPECT_EQ(panel1, panels[3]);
     EXPECT_EQ(position1, panel2->GetBounds().origin());
@@ skipping 33 matching lines @@
   }
 
   // Test the scenario: drag a panel, close another panel, end the drag.
   {
     std::vector<Panel*> panels;
     gfx::Point panel1_new_position = position1;
     panel1_new_position.Offset(-500, 0);
 
     // Start dragging a panel.
     // We have:  P1*  P4  P3
-    panel1_testing->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin());
-    panel1_testing->DragTitlebar(-500, -5);
+    gfx::Point mouse_location = panel1->GetBounds().origin();
+    panel1_testing->PressLeftMouseButtonTitlebar(mouse_location);
+    mouse_location.Offset(-500, -5);
+    panel1_testing->DragTitlebar(mouse_location);
     EXPECT_TRUE(drag_controller->IsDragging());
     EXPECT_EQ(panel1, drag_controller->dragging_panel());
 
     ASSERT_EQ(3, docked_strip->num_panels());
     panels = PanelManager::GetInstance()->panels();
     EXPECT_EQ(panel3, panels[0]);
     EXPECT_EQ(panel4, panels[1]);
     EXPECT_EQ(panel1, panels[2]);
     EXPECT_EQ(position1, panel3->GetBounds().origin());
     EXPECT_EQ(position2, panel4->GetBounds().origin());
@@ skipping 27 matching lines @@
   }
 
   // Test the scenario: drag a panel and close the dragging panel.
   {
     std::vector<Panel*> panels;
     gfx::Point panel1_new_position = position2;
     panel1_new_position.Offset(-500, 0);
 
     // Start dragging a panel again.
     // We have:  P1*  P4
-    panel1_testing->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin());
-    panel1_testing->DragTitlebar(-500, -5);
+    gfx::Point mouse_location = panel1->GetBounds().origin();
+    panel1_testing->PressLeftMouseButtonTitlebar(mouse_location);
+    mouse_location.Offset(-500, -5);
+    panel1_testing->DragTitlebar(mouse_location);
     EXPECT_TRUE(drag_controller->IsDragging());
     EXPECT_EQ(panel1, drag_controller->dragging_panel());
     EXPECT_EQ(panel1_new_position, panel1->GetBounds().origin());
 
     ASSERT_EQ(2, docked_strip->num_panels());
     panels = PanelManager::GetInstance()->panels();
     EXPECT_EQ(panel4, panels[0]);
     EXPECT_EQ(panel1, panels[1]);
     EXPECT_EQ(position1, panel4->GetBounds().origin());
 
@@ skipping 1218 matching lines @@
   // position when tall panel brings up its titlebar.
   CloseWindowAndWait(panel1->browser());
   EXPECT_EQ(balloon_bottom_after_tall_panel_titlebar_up,
             GetBalloonBottomPosition(balloon));
 
   // Closing the remaining tall panel should move the notification balloon back
   // to its original position.
   CloseWindowAndWait(panel2->browser());
   EXPECT_EQ(original_balloon_bottom, GetBalloonBottomPosition(balloon));
 }