Addition testing for panels drag and drop.

chrome/browser/ui/panels/panel_browsertest.cc

 // Copyright (c) 2011 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/command_line.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
@@ skipping 136 matching lines @@
         gfx::Rect(0, 0, 500, 200));
     signal3.Wait();
     signal4.Wait();
     ASSERT_EQ(2, panel_manager->num_panels());
     EXPECT_LT(panel6->GetBounds().right(), panel1->GetBounds().x());
 
     panel1->Close();
     panel6->Close();
   }
 
-  struct DragTestData {
-    DragTestData(int drag_delta_x,
-                 int drag_delta_y,
-                 bool is_big_delta,
-                 bool should_cancel_drag)
-        : drag_delta_x(drag_delta_x), drag_delta_y(drag_delta_y),
-          is_big_delta(is_big_delta), should_cancel_drag(should_cancel_drag) {}
-    int drag_delta_x;
-    int drag_delta_y;
-    bool is_big_delta;  // Drag big enough to cause shuffling.
-    bool should_cancel_drag;
-  };
+  void SetWorkArea(const gfx::Rect& work_area) {
+    PanelManager::GetInstance()->SetWorkArea(gfx::Rect(0, 0, 800, 600));
+  }
 
-  void TestDragging(std::vector<Panel*>* panels,
-                    const DragTestData& drag_test_data) {
-    size_t num_panels = panels->size();
+  int horizontal_spacing() {
+    return PanelManager::horizontal_spacing();
+  }
 
-    // Test dragging each panel in the list.
-    for (size_t drag_index = 0; drag_index < num_panels; ++drag_index) {
-      std::vector<int> expected_delta_x_after_drag(num_panels, 0);
-      std::vector<int> expected_delta_x_after_finish(num_panels, 0);
+  void CloseAllPanels() {
+    std::vector<Panel*> panels = PanelManager::GetInstance()->panels_;

[jennb, 2011/08/23 21:26:48]

Add a TODO here for dimich. When he makes Close() not call panel manager to
remove panels immediately, it will be safe to use the actual vector of panels
again.

[jennb, 2011/08/23 21:26:48]

Can you use the Panels (typedef inside PanelManager) here?  This test is a
friend class of PanelManager so maybe you have access to that typedef.

[prasadt, 2011/08/23 21:39:29]

Does it matter?  And worse we'd be be relying on that implementation detail when
we don't have to.

[prasadt, 2011/08/23 21:39:29]

I'd rather just use the vector so we have it right there for someone to see
instead of having to go to the header to figure what it is.

+    for (size_t i = 0; i < panels.size(); ++i)
+      panels[i]->Close();
+  }
 
-      for (size_t j = 0; j < num_panels; ++j) {
-        expected_delta_x_after_drag.push_back(0);
-        expected_delta_x_after_finish.push_back(0);
-      }
+  std::vector<gfx::Rect> GetAllPanelsBounds() {
+    std::vector<gfx::Rect> panels_bounds;
+    const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels_;
+    for (size_t i = 0; i < panels.size(); ++i)
+      panels_bounds.push_back(panels[i]->GetRestoredBounds());
+    return panels_bounds;
+  }
 
-      expected_delta_x_after_drag[drag_index] = drag_test_data.drag_delta_x;
-      size_t swap_index = drag_index;
-      if (drag_test_data.is_big_delta) {
-        if (drag_test_data.drag_delta_x > 0 && drag_index != 0) {
-          // Dragged to right.
-          swap_index = drag_index - 1;
-        } else if (drag_test_data.drag_delta_x < 0 &&
-            drag_index != num_panels - 1) {
-          // Dragged to left.
-          swap_index = drag_index + 1;
-        }
-      }
-      if (swap_index != drag_index) {
-        expected_delta_x_after_drag[swap_index] =
-            (*panels)[drag_index]->GetRestoredBounds().x() -
-            (*panels)[swap_index]->GetRestoredBounds().x();
-        expected_delta_x_after_finish[swap_index] =
-            expected_delta_x_after_drag[swap_index];
-        expected_delta_x_after_finish[drag_index] =
-            -expected_delta_x_after_drag[swap_index];
-      }
-      ValidateDragging(*panels, drag_index, drag_test_data.drag_delta_x,
-          drag_test_data.drag_delta_y, expected_delta_x_after_drag,
-          expected_delta_x_after_finish, drag_test_data.should_cancel_drag);
-
-      if (swap_index != drag_index && !drag_test_data.should_cancel_drag) {
-        // Swap the panels in the vector so they reflect their true relative
-        // positions.
-        Panel* tmp_panel = (*panels)[swap_index];
-        (*panels)[swap_index] = (*panels)[drag_index];
-        (*panels)[drag_index] = tmp_panel;
-      }
+  // Helper function for debugging.
+  void PrintPanelBounds() {
+    const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels_;
+    DLOG(WARNING) << "PanelBounds:";
+    for (size_t i = 0; i < panels.size(); ++i) {
+      DLOG(WARNING) << "#=" << i
+                    << ", ptr=" << panels[i]
+                    << ", x=" << panels[i]->GetRestoredBounds().x()
+                    << ", y=" << panels[i]->GetRestoredBounds().y()
+                    << ", width=" << panels[i]->GetRestoredBounds().width()
+                    << ", height" << panels[i]->GetRestoredBounds().height();
     }
   }
 
-  void ValidateDragging(const std::vector<Panel*>& panels,
-                        int index_to_drag,
-                        int delta_x,
-                        int delta_y,
-                        const std::vector<int>& expected_delta_x_after_drag,
-                        const std::vector<int>& expected_delta_x_after_finish,
-                        bool should_cancel_drag) {
-    // Keep track of the initial bounds for comparison.
-    std::vector<gfx::Rect> initial_bounds(panels.size());
-    for (size_t i = 0; i < panels.size(); ++i)
-      initial_bounds[i] = panels[i]->GetRestoredBounds();
+  // This is a bit mask - a set of flags that controls the specific drag actions
+  // to be carried out by TestDragging function.
+  enum DragAction {
+    DRAG_ACTION_BEGIN = 1,
+    DRAG_ACTION_FINISH = 2,
+    DRAG_ACTION_CANCEL = 4
+  };
 
-    // Trigger the mouse-pressed event.
-    // All panels should remain in their original positions.
-    NativePanel* panel_to_drag = panels[index_to_drag]->native_panel();
+  void TestDragging(int delta_x,
+                    int delta_y,
+                    size_t drag_index,
+                    std::vector<int>expected_delta_x_after_drag,
+                    std::vector<int>expected_delta_x_after_finish,
+                    std::vector<gfx::Rect> initial_bounds,
+                    int drag_action) {
+    std::vector<Panel*> panels = PanelManager::GetInstance()->panels_;
+
+    // These are bounds at the beginning of this test.  This would be different
+    // from initial_bounds in the case where we're testing for the case of
+    // multiple drags before finishing the drag.  Here is an example:
+    //
+    // Test 1 - Create three panels and drag a panel to the right but don't
+    //          finish or cancel the drag.  initial_bounds == test_begin_bounds
+    // Test 2 - Do another drag on the same panel.  There is no button press
+    //          in this case as its the same drag that's continuing, this is
+    //          simulating multiple drag events before button release.
+    //          initial_bounds is still the same as in Test1.  So in this case
+    //              initial_bounds != test_begin_bounds.
+    std::vector<gfx::Rect> test_begin_bounds = GetAllPanelsBounds();
+
+    NativePanel* panel_to_drag = panels[drag_index]->native_panel();
     scoped_ptr<NativePanelTesting> panel_testing_to_drag(
         NativePanelTesting::Create(panel_to_drag));
 
-    gfx::Point button_press_point(initial_bounds[index_to_drag].x(),
-                                  initial_bounds[index_to_drag].y());
-    panel_testing_to_drag->PressLeftMouseButtonTitlebar(button_press_point);
-    for (size_t i = 0; i < panels.size(); ++i)
-      EXPECT_EQ(initial_bounds[i], panels[i]->GetRestoredBounds());
+    if (drag_action & DRAG_ACTION_BEGIN) {
+      // Trigger the mouse-pressed event.
+      // All panels should remain in their original positions.
+      gfx::Point button_press_point(
+          panels[drag_index]->GetRestoredBounds().x(),
+          panels[drag_index]->GetRestoredBounds().y());
+      panel_testing_to_drag->PressLeftMouseButtonTitlebar(button_press_point);
+      for (size_t i = 0; i < panels.size(); ++i)
+        EXPECT_EQ(test_begin_bounds[i], panels[i]->GetRestoredBounds());
+    }
 
     // Trigger the drag.
+    // Compare against expected bounds.
     panel_testing_to_drag->DragTitlebar(delta_x, delta_y);
-
     for (size_t i = 0; i < panels.size(); ++i) {
-      gfx::Rect expected_bounds = initial_bounds[i];
+      gfx::Rect expected_bounds = test_begin_bounds[i];
       expected_bounds.Offset(expected_delta_x_after_drag[i], 0);
       EXPECT_EQ(expected_bounds, panels[i]->GetRestoredBounds());
     }
 
-    // Cancel drag if asked.
-    // All panels should stay in their original positions.
-    if (should_cancel_drag) {
+    if (drag_action & DRAG_ACTION_CANCEL) {
+      // Cancel the drag.
+      // All panels should return to their initial positions.
       panel_testing_to_drag->CancelDragTitlebar();
+      std::vector<gfx::Rect> current_bounds = GetAllPanelsBounds();
       for (size_t i = 0; i < panels.size(); ++i)
-        EXPECT_EQ(initial_bounds[i], panels[i]->GetRestoredBounds());
-      return;
-    }
-
-    // Otherwise finish the drag.
-    panel_testing_to_drag->FinishDragTitlebar();
-    for (size_t i = 0; i < panels.size(); ++i) {
-      gfx::Rect expected_bounds = initial_bounds[i];
-      expected_bounds.Offset(expected_delta_x_after_finish[i], 0);
-      EXPECT_EQ(expected_bounds, panels[i]->GetRestoredBounds());
+        EXPECT_EQ(initial_bounds[i], current_bounds[i]);
+    } else if (drag_action & DRAG_ACTION_FINISH) {
+      // Finish the drag.
+      // Compare against expected bounds.
+      panel_testing_to_drag->FinishDragTitlebar();
+      for (size_t i = 0; i < panels.size(); ++i) {
+        gfx::Rect expected_bounds = test_begin_bounds[i];
+        expected_bounds.Offset(expected_delta_x_after_finish[i], 0);
+        EXPECT_EQ(expected_bounds, panels[i]->GetRestoredBounds());
+      }
     }
   }
 };
 
 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", gfx::Rect());
   EXPECT_EQ(1, panel_manager->num_panels());
@@ skipping 27 matching lines @@
   TestCreatePanelOnOverflow();
 }
 
 #if defined(TOOLKIT_GTK) || defined(OS_WIN)
 #define MAYBE_DragPanels DragPanels
 #else
 #define MAYBE_DragPanels DISABLED_DragPanels
 #endif
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_DragPanels) {
-  std::vector<Panel*> panels;
-  panels.push_back(CreatePanel("PanelTest0", gfx::Rect()));
-
-  int small_delta = 5;
-  int big_delta = panels[0]->GetRestoredBounds().width() * 0.5 + 5;
-
-  // Setup test data.
-  // Template - DragTestData(delta_x, delta_y, is_big_delta, should_cancel_drag)
-  std::vector<DragTestData> drag_test_data;
-  drag_test_data.push_back(DragTestData(
-      small_delta, small_delta, false, false));
-  drag_test_data.push_back(DragTestData(
-      -small_delta, -small_delta, false, false));
-  drag_test_data.push_back(DragTestData(big_delta, big_delta, true, false));
-  drag_test_data.push_back(DragTestData(big_delta, small_delta, true, false));
-  drag_test_data.push_back(DragTestData(-big_delta, -big_delta, true, false));
-  drag_test_data.push_back(DragTestData(-big_delta, 0, true, false));
-  drag_test_data.push_back(DragTestData(big_delta, big_delta, true, true));
-  drag_test_data.push_back(DragTestData(-big_delta, -big_delta, true, true));
-
-  for (int num_panels = 1; num_panels <= 3; ++num_panels) {
-    if (num_panels > 1)
-      panels.push_back(CreatePanel("PanelTest", gfx::Rect()));
-    for (size_t j = 0; j < drag_test_data.size(); ++j) {
-      // Test for each combination of drag test data and number of panels.
-      TestDragging(&panels, drag_test_data[j]);
+  // Set work area to make the test consistent on different monitor sizes.
+  SetWorkArea(gfx::Rect(0, 0, 800, 600));
+
+  static const int max_panels = 3;
+  int small_delta = 10;
+  int big_delta = 70;
+  int bigger_delta = 120;
+  int biggest_delta = 200;
+  std::vector<int> zero_delta(max_panels, 0);
+  std::vector<int> expected_delta_x_after_drag(max_panels, 0);
+  std::vector<int> expected_delta_x_after_finish(max_panels, 0);
+  std::vector<gfx::Rect> current_bounds;
+  std::vector<gfx::Rect> initial_bounds;
+
+  // Tests with a single panel.
+  {
+    CreatePanel("PanelTest1", gfx::Rect(0, 0, 100, 100));
+
+    // Drag left.
+    expected_delta_x_after_drag[0] = -big_delta;
+    expected_delta_x_after_finish = zero_delta;
+    TestDragging(-big_delta, 0, 0, expected_delta_x_after_drag,
+                 zero_delta, GetAllPanelsBounds(),
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+    // Drag left and cancel.
+    expected_delta_x_after_drag[0] = -big_delta;
+    expected_delta_x_after_finish = zero_delta;
+    TestDragging(-big_delta, 0, 0, expected_delta_x_after_drag,
+                 zero_delta, GetAllPanelsBounds(),
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_CANCEL);
+
+    // Drag right.
+    expected_delta_x_after_drag[0] = big_delta;
+    TestDragging(big_delta, 0, 0, expected_delta_x_after_drag,
+                 zero_delta, GetAllPanelsBounds(),
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+    // Drag right and up.  Expect no vertical movement.
+    TestDragging(big_delta, big_delta, 0, expected_delta_x_after_drag,
+                 zero_delta, GetAllPanelsBounds(),
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+    // Drag up.  Expect no movement on drag.
+    TestDragging(0, -big_delta, 0, zero_delta, zero_delta,
+                 GetAllPanelsBounds(), DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+    // Drag down.  Expect no movement on drag.
+    TestDragging(0, big_delta, 0, zero_delta, zero_delta,
+                 GetAllPanelsBounds(), DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+  }
+
+  // Tests with two panels.
+  {
+    CreatePanel("PanelTest2", gfx::Rect(0, 0, 120, 120));
+
+    // Drag left, small delta, expect no shuffle.
+    expected_delta_x_after_drag = zero_delta;
+    expected_delta_x_after_drag[0] = -small_delta;
+    TestDragging(-small_delta, 1, 0, expected_delta_x_after_drag, zero_delta,
+                 GetAllPanelsBounds(), DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+    // Drag right panel i.e index 0, towards left, big delta, expect shuffle.
+    initial_bounds = GetAllPanelsBounds();
+    expected_delta_x_after_drag = zero_delta;
+
+    // Deltas for panel being dragged.
+    expected_delta_x_after_drag[0] = -big_delta;
+    expected_delta_x_after_finish[0] =
+        -(initial_bounds[1].width() + horizontal_spacing());
+
+    // Deltas for panel being shuffled.
+    expected_delta_x_after_drag[1] =
+        initial_bounds[0].width() + horizontal_spacing();
+    expected_delta_x_after_finish[1] = expected_delta_x_after_drag[1];
+
+    TestDragging(-big_delta, 0, 0, expected_delta_x_after_drag,
+                 expected_delta_x_after_finish, initial_bounds,
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+    // Drag left panel i.e index 1, towards right, big delta, expect shuffle.
+    initial_bounds = GetAllPanelsBounds();
+    expected_delta_x_after_drag = zero_delta;
+    expected_delta_x_after_finish = zero_delta;
+
+    // Deltas for panel being dragged.
+    expected_delta_x_after_drag[1] = big_delta;
+    expected_delta_x_after_finish[1] =
+        initial_bounds[0].width() + horizontal_spacing();
+
+    // Deltas for panel being shuffled.
+    expected_delta_x_after_drag[0] =
+        -(initial_bounds[1].width() + horizontal_spacing());
+    expected_delta_x_after_finish[0] = expected_delta_x_after_drag[0];
+
+    TestDragging(big_delta, 0, 1, expected_delta_x_after_drag,
+                 expected_delta_x_after_finish, initial_bounds,
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+    // Drag left panel i.e index 1, towards right, big delta, expect shuffle.
+    // Cancel drag.
+    initial_bounds = GetAllPanelsBounds();
+    expected_delta_x_after_drag = zero_delta;
+
+    // Delta for panel being dragged.
+    expected_delta_x_after_drag[1] = big_delta;
+
+    // Delta for panel being shuffled.
+    expected_delta_x_after_drag[0] =
+        -(initial_bounds[1].width() + horizontal_spacing());
+
+    // As the drag is being canceled, we don't need expected_delta_x_after
+    // finish.  Instead initial_bounds will be used.
+    TestDragging(big_delta, 0, 1, expected_delta_x_after_drag,
+                 zero_delta, initial_bounds,
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_CANCEL);
+  }
+
+  // Tests with three panels.
+  {
+    CreatePanel("PanelTest3", gfx::Rect(0, 0, 110, 110));
+
+    // Drag left most panel to become right most with two shuffles.
+    // We test both shuffles.
+    {
+      // First drag and shuffle.
+      initial_bounds = GetAllPanelsBounds();
+      expected_delta_x_after_drag = zero_delta;
+
+      // Delta for panel being dragged.
+      expected_delta_x_after_drag[2] = big_delta;
+
+      // Delta for panel being shuffled.
+      expected_delta_x_after_drag[1] =
+          -(initial_bounds[2].width() + horizontal_spacing());
+
+      // There is no delta after finish as drag is done yet.
+      TestDragging(big_delta, 0, 2, expected_delta_x_after_drag,
+                   zero_delta, initial_bounds, DRAG_ACTION_BEGIN);
+
+      // Second drag and shuffle.  We finish the drag here.  The drag index
+      // changes from 2 to 1 because of the first shuffle above.
+      current_bounds = GetAllPanelsBounds();
+      expected_delta_x_after_drag = zero_delta;
+      expected_delta_x_after_finish = zero_delta;
+
+      // big_delta is not enough to cause the second shuffle as the panel being
+      // dragged is in the middle of a drag and big_delta won't go far enough.
+      // So we use bigger_delta.
+
+      // Deltas for panel being dragged.
+      expected_delta_x_after_drag[1] = bigger_delta;
+      int x_after_finish = current_bounds[0].x() +
+          (current_bounds[0].width() - current_bounds[1].width());
+      expected_delta_x_after_finish[1] = x_after_finish - current_bounds[1].x();
+
+      // Deltas for panel being shuffled.
+      expected_delta_x_after_drag[0] =
+          -(current_bounds[1].width() + horizontal_spacing());
+      expected_delta_x_after_finish[0] = expected_delta_x_after_drag[0];
+
+      TestDragging(bigger_delta, 0, 1, expected_delta_x_after_drag,
+                   expected_delta_x_after_finish, initial_bounds,
+                   DRAG_ACTION_FINISH);
     }
+
+    // Drag right most panel to become left most with two shuffles.
+    // And then cancel the drag.
+    {
+      // First drag and shuffle.
+      initial_bounds = GetAllPanelsBounds();
+      expected_delta_x_after_drag = zero_delta;
+
+      // Delta for panel being dragged.
+      expected_delta_x_after_drag[0] = -big_delta;
+
+      // Delta for panel being shuffled.
+      expected_delta_x_after_drag[1] =
+          (initial_bounds[0].width() + horizontal_spacing());
+
+      // There is no delta after finish as drag is done yet.
+      TestDragging(-big_delta, 0, 0, expected_delta_x_after_drag,
+                   zero_delta, initial_bounds, DRAG_ACTION_BEGIN);
+
+      // Second drag and shuffle.  We cancel the drag here.  The drag index
+      // changes from 0 to 1 because of the first shuffle above.
+      current_bounds = GetAllPanelsBounds();
+      expected_delta_x_after_drag = zero_delta;
+
+      // Delta for panel being dragged.
+      expected_delta_x_after_drag[1] = -bigger_delta;
+
+      // Deltas for panel being shuffled.
+      int x_after_shuffle = current_bounds[0].x() - horizontal_spacing()
+          - current_bounds[2].width();
+      expected_delta_x_after_drag[2] = x_after_shuffle - current_bounds[2].x();
+
+      // There is no delta after finish as drag canceled.
+      TestDragging(-bigger_delta, 0, 1, expected_delta_x_after_drag,
+                   zero_delta, initial_bounds, DRAG_ACTION_CANCEL);
+    }
+
+    // Drag left most panel to become the right most in a single drag.  This
+    // will shuffle middle panel to left most and right most to middle.
+    initial_bounds = GetAllPanelsBounds();
+    expected_delta_x_after_drag = zero_delta;
+    expected_delta_x_after_finish = zero_delta;
+
+    // Use a delta big enough to go across two panels.
+    // Deltas for panel being dragged.
+    expected_delta_x_after_drag[2] = biggest_delta;
+    expected_delta_x_after_finish[2] =
+        initial_bounds[1].width() + horizontal_spacing() +
+        initial_bounds[0].width() + horizontal_spacing();
+
+    // Deltas for middle panels being shuffled.
+    expected_delta_x_after_drag[1] =
+        -(initial_bounds[2].width() + horizontal_spacing());
+    expected_delta_x_after_finish[1] = expected_delta_x_after_drag[1];
+
+    expected_delta_x_after_drag[0] =  expected_delta_x_after_drag[1];
+    expected_delta_x_after_finish[0] = expected_delta_x_after_drag[0];
+
+    TestDragging(biggest_delta, 0, 2, expected_delta_x_after_drag,
+                 expected_delta_x_after_finish, initial_bounds,
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+    // Drag right most panel to become the left most in a single drag.  This
+    // will shuffle middle panel to right most and left most to middle.
+    initial_bounds = GetAllPanelsBounds();
+    expected_delta_x_after_drag = zero_delta;
+    expected_delta_x_after_finish = zero_delta;
+
+    // Deltas for panel being dragged.
+    expected_delta_x_after_drag[0] = -biggest_delta;
+    expected_delta_x_after_finish[0] =
+        -(initial_bounds[1].width() + horizontal_spacing() +
+          initial_bounds[2].width() + horizontal_spacing());
+
+    // Deltas for panels being shuffled.
+    expected_delta_x_after_drag[1] =
+        initial_bounds[0].width() + horizontal_spacing();
+    expected_delta_x_after_finish[1] = expected_delta_x_after_drag[1];
+
+    expected_delta_x_after_drag[2] = expected_delta_x_after_drag[1];
+    expected_delta_x_after_finish[2] = expected_delta_x_after_drag[2];
+
+    TestDragging(-biggest_delta, 0, 0, expected_delta_x_after_drag,
+                 expected_delta_x_after_finish, initial_bounds,
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+    // Drag right most panel to become the left most in a single drag.  Then
+    // cancel the drag.
+    initial_bounds = GetAllPanelsBounds();
+    expected_delta_x_after_drag = zero_delta;
+
+    // Deltas for panel being dragged.
+    expected_delta_x_after_drag[0] = -biggest_delta;
+
+    // Deltas for panels being shuffled.
+    expected_delta_x_after_drag[1] =
+        initial_bounds[0].width() + horizontal_spacing();
+    expected_delta_x_after_drag[2] = expected_delta_x_after_drag[1];
+
+    // No delta after finish as drag is canceled.
+    TestDragging(-biggest_delta, 0, 0, expected_delta_x_after_drag,
+                 zero_delta, initial_bounds,
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_CANCEL);
   }
 
-  for (size_t i = 0; i < panels.size(); ++i)
-    panels[i]->Close();
+  // Close panels.
+  CloseAllPanels();
 }
 
 class PanelDownloadTest : public PanelBrowserTest {
  public:
   PanelDownloadTest() : PanelBrowserTest() { }
 
   // Creates a temporary directory for downloads that is auto-deleted
   // on destruction.
   bool CreateDownloadDirectory(Profile* profile) {
     bool created = downloads_directory_.CreateUniqueTempDir();
@@ skipping 146 matching lines @@
   EXPECT_EQ(1, tabbed_browser->tab_count());
   ASSERT_TRUE(tabbed_browser->window()->IsDownloadShelfVisible());
   tabbed_browser->CloseWindow();
 #endif
 
   EXPECT_EQ(1, panel_browser->tab_count());
   ASSERT_FALSE(panel_browser->window()->IsDownloadShelfVisible());
 
   panel_browser->CloseWindow();
 }