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() {

[jianli, 2011/08/24 20:23:24]

This helper function is not needed. You can call
PanelManager::GetInstance()->RemoveAll() instead.

[prasadt, 2011/08/24 21:29:17]

Done.

+    std::vector<Panel*> panels = PanelManager::GetInstance()->panels_;
+    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 {

[jianli, 2011/08/24 20:23:24]

Please call it as DragAcitonMasks. Please comment that DRAG_ACTION_FINISH and
DRAG_ACTION_CANCEL cannot be set simultaneously.

[prasadt, 2011/08/24 21:29:17]

I like the current name better, so leaving it that way.
Added the comment though it feels too much commenting.

+    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,

[jianli, 2011/08/24 20:23:24]

Please add space between type and value. Also, please add "const &".

[prasadt, 2011/08/24 21:29:17]

Done.

+                    std::vector<int>expected_delta_x_after_finish,

[jianli, 2011/08/24 20:23:24]

ditto.

[prasadt, 2011/08/24 21:29:17]

Done.

+                    std::vector<gfx::Rect> initial_bounds,

[jianli, 2011/08/24 20:23:24]

ditto.

Also, I think it would better to name it as expected_bounds_after_cancel. Then
you do not need to explain the difference between test_begin_bounds and
initial_bounds.

[prasadt, 2011/08/24 21:29:17]

I don't believe the name change will make it any easier for someone reading the
code for the first time.  I'm sticking with initial_bounds as that makes more
sense to me.

[jianli, 2011/08/24 22:04:02]

initial_bounds passed to this function is only used to check if the expected
bounds after canceling the drag is same as the original bounds. So naming it as
expected_bounds_after_cancel serves this purpose and improves the readability
and thus you can remove the lengthy comment below. Otherwise, it took me quite
long time to figure out what you want to do here.

[prasadt, 2011/08/24 23:04:30]

Done.  Leaving the comment as I think its still useful.

+                    int drag_action) {
+    std::vector<Panel*> panels = PanelManager::GetInstance()->panels_;

[jianli, 2011/08/24 20:23:24]

Better to expose panels_ as getter with UNIT_TEST guard.

[prasadt, 2011/08/24 21:29:17]

Done.

+
+    // 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();

[jianli, 2011/08/24 20:23:24]

If we rename initial_bounds to expected_bounds_after_cancel, test_begin_bounds
could be renamed to start_bounds, for simplicity.

[prasadt, 2011/08/24 21:29:17]

Sticking with my current names as explained earlier.

+
+    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.

[jianli, 2011/08/24 20:23:24]

This comment could be moved down for the next line of code.

[prasadt, 2011/08/24 21:29:17]

Done.

     panel_testing_to_drag->DragTitlebar(delta_x, delta_y);
-
     for (size_t i = 0; i < panels.size(); ++i) {

[jianli, 2011/08/24 20:23:24]

Can we have 2 helper functions for checking the expected bounds like the
following:
  void CheckPanelBounds(const std::vector<gfx::Rect>& expected_bounds);
  void CheckPanelBoundsWithDeltas(const std::vector<int>& expected_deltas);

[prasadt, 2011/08/24 21:29:17]

Leaving it the way it is.
The function is reasonably sized and straightforward.  I don't believe helper
functions here will improve it.

[jianli, 2011/08/24 22:04:02]

I still think 2 helper functions will simplify the code here and improve the
readability.

[prasadt, 2011/08/24 23:04:30]

Done.

-      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;

[jianli, 2011/08/24 20:23:24]

This could be defined as "static const".

[prasadt, 2011/08/24 21:29:17]

Done.

+  int big_delta = 70;

[jianli, 2011/08/24 20:23:24]

ditto.

[prasadt, 2011/08/24 21:29:17]

Done.

+  int bigger_delta = 120;

[jianli, 2011/08/24 20:23:24]

ditto.

[prasadt, 2011/08/24 21:29:17]

Done.

+  int biggest_delta = 200;

[jianli, 2011/08/24 20:23:24]

ditto.

[prasadt, 2011/08/24 21:29:17]

Done.

+  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,

[jianli, 2011/08/24 20:23:24]

Maybe we can call 2nd argument '0' as zero_delta. Otherwise it is quite easy to
have it confused with 3rd argument.

[prasadt, 2011/08/24 21:29:17]

Done.
I already have a vector I call zero_delta, changed that to zero_deltas.

+                 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.

[jianli, 2011/08/24 20:23:24]

Probably better to organized like the following, for better readability:
  // Tests with two panels.
  CreatePanel("PanelTest2", gfx::Rect(0, 0, 120, 120));

  // Drag left, small delta, expect no shuffle.
  {
    ...
  }

  // Drag right panel i.e index 0, towards left, big delta, expect shuffle.
  {
    ...
  }

  ...

[prasadt, 2011/08/24 21:29:17]

The current organization sounds about right to me.  Leaving it the way it is.

[jianli, 2011/08/24 22:04:02]

Can you at least wrap all the codes for one test case into nested block, just
like what you did for testing 3 panels? This will make us easily identify the
scope of any test.

[prasadt, 2011/08/24 23:04:30]

Done.

+  {
+    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] =

[jianli, 2011/08/24 20:23:24]

expected_delta_x_after_finish[0] =
    initial_bounds[1].x() - initial_bounds[0].x();

[prasadt, 2011/08/24 21:29:17]

Just keeping it consistent across all tests.

+        -(initial_bounds[1].width() + horizontal_spacing());
+
+    // Deltas for panel being shuffled.
+    expected_delta_x_after_drag[1] =

[jianli, 2011/08/24 20:23:24]

expected_delta_x_after_drag[1] =
    initial_bounds[0].right() - initial_bounds[1].width();

For test cases that involve shuffling only 2 panels, we could figure out the
expected positions without knowing about horizontal_spacing.

[prasadt, 2011/08/24 21:29:17]

ditto.

+        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.

[jianli, 2011/08/24 20:23:24]

left-most, right-most

[prasadt, 2011/08/24 21:29:17]

Done.  But replaced with leftmost and rightmost which are actual words.

+    // We test both shuffles.
+    {
+      // First drag and shuffle.

[jianli, 2011/08/24 20:23:24]

Please explain what first drag is about, like:
  // Firstly drag the left-most panel towards right, without ending or
cancelling it. Expect shuffle.

[prasadt, 2011/08/24 21:29:17]

Done.

+      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.

[jianli, 2011/08/24 20:23:24]

as drag is not done yet.

[prasadt, 2011/08/24 21:29:17]

Done.

+      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

[jianli, 2011/08/24 20:23:24]

ditto.

[prasadt, 2011/08/24 21:29:17]

Done.

+      // 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();
 }