Panel strip refactor cleanup.

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/bind.h"
 #include "base/string_number_conversions.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"
@@ skipping 146 matching lines @@
     CloseWindowAndWait(panel4->browser());
     ASSERT_EQ(2, panel_manager->num_panels());
     EXPECT_EQ(2, panel_strip->num_panels());
     EXPECT_EQ(0, panel_overflow_strip->num_panels());
     EXPECT_NE(Panel::IN_OVERFLOW, panel5->expansion_state());
 
     panel1->Close();
     panel5->Close();
   }
 
-  int horizontal_spacing() {
-    return PanelManager::horizontal_spacing();
-  }
-
   // Helper function for debugging.
   void PrintAllPanelBounds() {
     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]->GetBounds().x()
                     << ", y=" << panels[i]->GetBounds().y()
                     << ", width=" << panels[i]->GetBounds().width()
@@ skipping 373 matching lines @@
 // platforms. http://crbug.com/105073
 #if defined(OS_WIN)
 #define MAYBE_CreatePanelOnOverflow CreatePanelOnOverflow
 #else
 #define MAYBE_CreatePanelOnOverflow DISABLED_CreatePanelOnOverflow
 #endif
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_CreatePanelOnOverflow) {
   TestCreatePanelOnOverflow();
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DragPanels) {
-  static const int max_panels = 3;
+IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DragOnePanel) {
+  static const int num_panels = 1;
+  static const int zero_delta = 0;
+  static const int big_delta = 70;
+
+  static const std::vector<int> zero_deltas(num_panels, zero_delta);
+  std::vector<int> expected_delta_x_after_drag(num_panels, zero_delta);
+  std::vector<int> expected_delta_x_after_finish(num_panels, zero_delta);
+
+  Panel* panel1 =
+      CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
+
+  // Drag left.
+  expected_delta_x_after_drag[0] = -big_delta;
+  expected_delta_x_after_finish = zero_deltas;
+  TestDragging(-big_delta, zero_delta, 0, expected_delta_x_after_drag,
+               zero_deltas, GetAllPanelBounds(),
+               DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+  // Drag left and cancel.
+  expected_delta_x_after_drag[0] = -big_delta;
+  expected_delta_x_after_finish = zero_deltas;
+  TestDragging(-big_delta, zero_delta, 0, expected_delta_x_after_drag,
+               zero_deltas, GetAllPanelBounds(),
+               DRAG_ACTION_BEGIN | DRAG_ACTION_CANCEL);
+
+  // Drag right.
+  expected_delta_x_after_drag[0] = big_delta;
+  TestDragging(big_delta, zero_delta, 0, expected_delta_x_after_drag,
+               zero_deltas, GetAllPanelBounds(),
+               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_deltas, GetAllPanelBounds(),
+               DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+  // Drag up.  Expect no movement on drag.
+  TestDragging(0, -big_delta, 0, zero_deltas, zero_deltas,
+               GetAllPanelBounds(), DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+  // Drag down.  Expect no movement on drag.
+  TestDragging(0, big_delta, 0, zero_deltas, zero_deltas,
+               GetAllPanelBounds(), DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+  panel1->Close();
+}
+
+IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DragTwoPanels) {
+  static const int num_panels = 2;
   static const int zero_delta = 0;
   static const int small_delta = 10;
   static const int big_delta = 70;
+
+  static const std::vector<int> zero_deltas(num_panels, zero_delta);
+  std::vector<int> expected_delta_x_after_drag(num_panels, zero_delta);
+  std::vector<int> expected_delta_x_after_finish(num_panels, zero_delta);
+  std::vector<gfx::Rect> initial_bounds;
+
+  Panel* panel1 =
+      CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
+  Panel* panel2 =
+      CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 120, 120));
+
+  int horizontal_spacing =
+      panel1->GetBounds().x() - panel2->GetBounds().right();
+
+  // Drag left, small delta, expect no shuffle.
+  {
+    expected_delta_x_after_drag = zero_deltas;
+    expected_delta_x_after_drag[0] = -small_delta;
+    TestDragging(-small_delta, zero_delta, 0, expected_delta_x_after_drag,
+                 zero_deltas, GetAllPanelBounds(),
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+
+    // Drag right panel i.e index 0, towards left, big delta, expect shuffle.
+    initial_bounds = GetAllPanelBounds();
+    expected_delta_x_after_drag = zero_deltas;
+
+    // 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, zero_delta, 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 = GetAllPanelBounds();
+    expected_delta_x_after_drag = zero_deltas;
+    expected_delta_x_after_finish = zero_deltas;
+
+    // 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, zero_delta, 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 = GetAllPanelBounds();
+    expected_delta_x_after_drag = zero_deltas;
+
+    // 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, zero_delta, 1, expected_delta_x_after_drag,
+                 zero_deltas, initial_bounds,
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_CANCEL);
+  }
+
+  panel1->Close();
+  panel2->Close();
+}
+
+IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DragThreePanels) {
+  static const int num_panels = 3;
+  static const int zero_delta = 0;
+  static const int big_delta = 70;
   static const int bigger_delta = 120;
   static const int biggest_delta = 200;
-  static const std::vector<int> zero_deltas(max_panels, zero_delta);
-
-  std::vector<int> expected_delta_x_after_drag(max_panels, zero_delta);
-  std::vector<int> expected_delta_x_after_finish(max_panels, zero_delta);
+
+  static const std::vector<int> zero_deltas(num_panels, zero_delta);
+  std::vector<int> expected_delta_x_after_drag(num_panels, zero_delta);
+  std::vector<int> expected_delta_x_after_finish(num_panels, zero_delta);
   std::vector<gfx::Rect> current_bounds;
   std::vector<gfx::Rect> initial_bounds;
 
-  // Tests with a single panel.
-  {
-    CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
-
-    // Drag left.
+  Panel* panel1 =
+      CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
+  Panel* panel2 =
+      CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 120, 120));
+  Panel* panel3 =
+    CreatePanelWithBounds("PanelTest3", gfx::Rect(0, 0, 110, 110));
+
+  int horizontal_spacing =
+      panel1->GetBounds().x() - panel2->GetBounds().right();
+
+  // Drag leftmost panel to become rightmost with two shuffles.
+  // We test both shuffles.
+  {
+    // Drag the left-most panel towards right without ending or cancelling it.
+    // Expect shuffle.
+    initial_bounds = GetAllPanelBounds();
+    expected_delta_x_after_drag = zero_deltas;
+
+    // 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 not done yet.
+    TestDragging(big_delta, zero_delta, 2, expected_delta_x_after_drag,
+                 zero_deltas, initial_bounds, DRAG_ACTION_BEGIN);
+
+    // The drag index changes from 2 to 1 because of the first shuffle above.
+    // Drag the panel further enough to the right to trigger a another
+    // shuffle.  We finish the drag here.
+    current_bounds = GetAllPanelBounds();
+    expected_delta_x_after_drag = zero_deltas;
+    expected_delta_x_after_finish = zero_deltas;
+
+    // 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, zero_delta, 1, expected_delta_x_after_drag,
+                 expected_delta_x_after_finish, initial_bounds,
+                 DRAG_ACTION_FINISH);
+  }
+
+  // Drag rightmost panel to become leftmost with two shuffles.
+  // And then cancel the drag.
+  {
+    // First drag and shuffle.
+    initial_bounds = GetAllPanelBounds();
+    expected_delta_x_after_drag = zero_deltas;
+
+    // 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, zero_delta, 0, expected_delta_x_after_drag,
+                 zero_deltas, 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 = GetAllPanelBounds();
+    expected_delta_x_after_drag = zero_deltas;
+
+    // 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, zero_delta, 1, expected_delta_x_after_drag,
+                 zero_deltas, initial_bounds, DRAG_ACTION_CANCEL);
+  }
+
+  // Drag leftmost panel to become the rightmost in a single drag.  This
+  // will shuffle middle panel to leftmost and rightmost to middle.
+  {
+    initial_bounds = GetAllPanelBounds();
+    expected_delta_x_after_drag = zero_deltas;
     expected_delta_x_after_finish = zero_deltas;
-    TestDragging(-big_delta, zero_delta, 0, expected_delta_x_after_drag,
-                 zero_deltas, GetAllPanelBounds(),
-                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
-
-    // Drag left and cancel.
-    expected_delta_x_after_drag[0] = -big_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, zero_delta, 2, expected_delta_x_after_drag,
+                 expected_delta_x_after_finish, initial_bounds,
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+  }
+
+  // Drag rightmost panel to become the leftmost in a single drag.  This
+  // will shuffle middle panel to rightmost and leftmost to middle.
+  {
+    initial_bounds = GetAllPanelBounds();
+    expected_delta_x_after_drag = zero_deltas;
     expected_delta_x_after_finish = zero_deltas;
-    TestDragging(-big_delta, zero_delta, 0, expected_delta_x_after_drag,
-                 zero_deltas, GetAllPanelBounds(),
+
+    // 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, zero_delta, 0, expected_delta_x_after_drag,
+                 expected_delta_x_after_finish, initial_bounds,
+                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
+  }
+
+  // Drag rightmost panel to become the leftmost in a single drag.  Then
+  // cancel the drag.
+  {
+    initial_bounds = GetAllPanelBounds();
+    expected_delta_x_after_drag = zero_deltas;
+
+    // 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, zero_delta, 0, expected_delta_x_after_drag,
+                 zero_deltas, initial_bounds,
                  DRAG_ACTION_BEGIN | DRAG_ACTION_CANCEL);
-
-    // Drag right.
-    expected_delta_x_after_drag[0] = big_delta;
-    TestDragging(big_delta, zero_delta, 0, expected_delta_x_after_drag,
-                 zero_deltas, GetAllPanelBounds(),
-                 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_deltas, GetAllPanelBounds(),
-                 DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
-
-    // Drag up.  Expect no movement on drag.
-    TestDragging(0, -big_delta, 0, zero_deltas, zero_deltas,
-                 GetAllPanelBounds(), DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
-
-    // Drag down.  Expect no movement on drag.
-    TestDragging(0, big_delta, 0, zero_deltas, zero_deltas,
-                 GetAllPanelBounds(), DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
-  }
-
-  // Tests with two panels.
-  {
-    CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 120, 120));
-
-    // Drag left, small delta, expect no shuffle.
-    {
-      expected_delta_x_after_drag = zero_deltas;
-      expected_delta_x_after_drag[0] = -small_delta;
-      TestDragging(-small_delta, zero_delta, 0, expected_delta_x_after_drag,
-                   zero_deltas, GetAllPanelBounds(),
-                   DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
-
-      // Drag right panel i.e index 0, towards left, big delta, expect shuffle.
-      initial_bounds = GetAllPanelBounds();
-      expected_delta_x_after_drag = zero_deltas;
-
-      // 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, zero_delta, 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 = GetAllPanelBounds();
-      expected_delta_x_after_drag = zero_deltas;
-      expected_delta_x_after_finish = zero_deltas;
-
-      // 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, zero_delta, 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 = GetAllPanelBounds();
-      expected_delta_x_after_drag = zero_deltas;
-
-      // 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, zero_delta, 1, expected_delta_x_after_drag,
-                   zero_deltas, initial_bounds,
-                   DRAG_ACTION_BEGIN | DRAG_ACTION_CANCEL);
-    }
-  }
-
-  // Tests with three panels.
-  {
-    CreatePanelWithBounds("PanelTest3", gfx::Rect(0, 0, 110, 110));
-
-    // Drag leftmost panel to become rightmost with two shuffles.
-    // We test both shuffles.
-    {
-      // Drag the left-most panel towards right without ending or cancelling it.
-      // Expect shuffle.
-      initial_bounds = GetAllPanelBounds();
-      expected_delta_x_after_drag = zero_deltas;
-
-      // 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 not done yet.
-      TestDragging(big_delta, zero_delta, 2, expected_delta_x_after_drag,
-                   zero_deltas, initial_bounds, DRAG_ACTION_BEGIN);
-
-      // The drag index changes from 2 to 1 because of the first shuffle above.
-      // Drag the panel further enough to the right to trigger a another
-      // shuffle.  We finish the drag here.
-      current_bounds = GetAllPanelBounds();
-      expected_delta_x_after_drag = zero_deltas;
-      expected_delta_x_after_finish = zero_deltas;
-
-      // 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, zero_delta, 1, expected_delta_x_after_drag,
-                   expected_delta_x_after_finish, initial_bounds,
-                   DRAG_ACTION_FINISH);
-    }
-
-    // Drag rightmost panel to become leftmost with two shuffles.
-    // And then cancel the drag.
-    {
-      // First drag and shuffle.
-      initial_bounds = GetAllPanelBounds();
-      expected_delta_x_after_drag = zero_deltas;
-
-      // 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, zero_delta, 0, expected_delta_x_after_drag,
-                   zero_deltas, 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 = GetAllPanelBounds();
-      expected_delta_x_after_drag = zero_deltas;
-
-      // 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, zero_delta, 1, expected_delta_x_after_drag,
-                   zero_deltas, initial_bounds, DRAG_ACTION_CANCEL);
-    }
-
-    // Drag leftmost panel to become the rightmost in a single drag.  This
-    // will shuffle middle panel to leftmost and rightmost to middle.
-    {
-      initial_bounds = GetAllPanelBounds();
-      expected_delta_x_after_drag = zero_deltas;
-      expected_delta_x_after_finish = zero_deltas;
-
-      // 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, zero_delta, 2, expected_delta_x_after_drag,
-                   expected_delta_x_after_finish, initial_bounds,
-                   DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
-    }
-
-    // Drag rightmost panel to become the leftmost in a single drag.  This
-    // will shuffle middle panel to rightmost and leftmost to middle.
-    {
-      initial_bounds = GetAllPanelBounds();
-      expected_delta_x_after_drag = zero_deltas;
-      expected_delta_x_after_finish = zero_deltas;
-
-      // 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, zero_delta, 0, expected_delta_x_after_drag,
-                   expected_delta_x_after_finish, initial_bounds,
-                   DRAG_ACTION_BEGIN | DRAG_ACTION_FINISH);
-    }
-
-    // Drag rightmost panel to become the leftmost in a single drag.  Then
-    // cancel the drag.
-    {
-      initial_bounds = GetAllPanelBounds();
-      expected_delta_x_after_drag = zero_deltas;
-
-      // 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, zero_delta, 0, expected_delta_x_after_drag,
-                   zero_deltas, initial_bounds,
-                   DRAG_ACTION_BEGIN | DRAG_ACTION_CANCEL);
-    }
-  }
-
-  PanelManager::GetInstance()->RemoveAll();
+  }
+
+  panel1->Close();
+  panel2->Close();
+  panel3->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreateSettingsMenu) {
   TestCreateSettingsMenuForExtension(
       FILE_PATH_LITERAL("extension1"), Extension::EXTERNAL_POLICY_DOWNLOAD,
       "", "");
   TestCreateSettingsMenuForExtension(
       FILE_PATH_LITERAL("extension2"), Extension::INVALID,
       "http://home", "options.html");
 }
@@ skipping 62 matching lines @@
   EXPECT_FALSE(panel_testing->IsAnimatingBounds());
   EXPECT_EQ(bounds, panel->GetBounds());
 
   panel->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, RestoredBounds) {
   // Disable mouse watcher. We don't care about mouse movements in this test.
   PanelManager* panel_manager = PanelManager::GetInstance();
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
-  panel_manager->set_mouse_watcher(mouse_watcher);
+  panel_manager->SetMouseWatcherForTesting(mouse_watcher);
   Panel* panel = CreatePanelWithBounds("PanelTest", gfx::Rect(0, 0, 100, 100));
   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
   EXPECT_EQ(panel->GetBounds(), panel->GetRestoredBounds());
-  EXPECT_EQ(0, panel_manager->minimized_panel_count());
 
   panel->SetExpansionState(Panel::MINIMIZED);
   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
   gfx::Rect bounds = panel->GetBounds();
   gfx::Rect restored = panel->GetRestoredBounds();
   EXPECT_EQ(bounds.x(), restored.x());
   EXPECT_GT(bounds.y(), restored.y());
   EXPECT_EQ(bounds.width(), restored.width());
   EXPECT_LT(bounds.height(), restored.height());
-  EXPECT_EQ(1, panel_manager->minimized_panel_count());
 
   panel->SetExpansionState(Panel::TITLE_ONLY);
   EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state());
   bounds = panel->GetBounds();
   restored = panel->GetRestoredBounds();
   EXPECT_EQ(bounds.x(), restored.x());
   EXPECT_GT(bounds.y(), restored.y());
   EXPECT_EQ(bounds.width(), restored.width());
   EXPECT_LT(bounds.height(), restored.height());
-  EXPECT_EQ(1, panel_manager->minimized_panel_count());
 
   panel->SetExpansionState(Panel::MINIMIZED);
   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
   bounds = panel->GetBounds();
   restored = panel->GetRestoredBounds();
   EXPECT_EQ(bounds.x(), restored.x());
   EXPECT_GT(bounds.y(), restored.y());
   EXPECT_EQ(bounds.width(), restored.width());
   EXPECT_LT(bounds.height(), restored.height());
-  EXPECT_EQ(1, panel_manager->minimized_panel_count());
 
   panel->SetExpansionState(Panel::EXPANDED);
   EXPECT_EQ(panel->GetBounds(), panel->GetRestoredBounds());
-  EXPECT_EQ(0, panel_manager->minimized_panel_count());
 
   // Verify that changing the panel bounds only affects restored height
   // when panel is expanded.
   int saved_restored_height = restored.height();
   panel->SetExpansionState(Panel::MINIMIZED);
   bounds = gfx::Rect(10, 20, 300, 400);
   panel->SetPanelBounds(bounds);
   EXPECT_EQ(saved_restored_height, panel->GetRestoredBounds().height());
-  EXPECT_EQ(1, panel_manager->minimized_panel_count());
 
   panel->SetExpansionState(Panel::TITLE_ONLY);
   bounds = gfx::Rect(20, 30, 100, 200);
   panel->SetPanelBounds(bounds);
   EXPECT_EQ(saved_restored_height, panel->GetRestoredBounds().height());
-  EXPECT_EQ(1, panel_manager->minimized_panel_count());
 
   panel->SetExpansionState(Panel::EXPANDED);
   bounds = gfx::Rect(40, 60, 300, 400);
   panel->SetPanelBounds(bounds);
   EXPECT_NE(saved_restored_height, panel->GetRestoredBounds().height());
-  EXPECT_EQ(0, panel_manager->minimized_panel_count());
 
   panel->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestore) {
   // We'll simulate mouse movements for test.
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
-  PanelManager::GetInstance()->set_mouse_watcher(mouse_watcher);
+  PanelManager::GetInstance()->SetMouseWatcherForTesting(mouse_watcher);
 
   // Test with one panel.
   CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
   TestMinimizeRestore();
 
   PanelManager::GetInstance()->RemoveAll();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreTwoPanels) {
   // We'll simulate mouse movements for test.
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
-  PanelManager::GetInstance()->set_mouse_watcher(mouse_watcher);
+  PanelManager::GetInstance()->SetMouseWatcherForTesting(mouse_watcher);
 
   // Test with two panels.
   CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
   CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 110, 110));
   TestMinimizeRestore();
 
   PanelManager::GetInstance()->RemoveAll();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreThreePanels) {
   // We'll simulate mouse movements for test.
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
-  PanelManager::GetInstance()->set_mouse_watcher(mouse_watcher);
+  PanelManager::GetInstance()->SetMouseWatcherForTesting(mouse_watcher);
 
   // Test with three panels.
   CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
   CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 110, 110));
   CreatePanelWithBounds("PanelTest3", gfx::Rect(0, 0, 120, 120));
   TestMinimizeRestore();
 
   PanelManager::GetInstance()->RemoveAll();
 }
 
@@ skipping 143 matching lines @@
   EXPECT_TRUE(panel->IsDrawingAttention());
   MessageLoop::current()->RunAllPending();
   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
 
   panel->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionWhileMinimized) {
   // We'll simulate mouse movements for test.
   PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
-  PanelManager::GetInstance()->set_mouse_watcher(mouse_watcher);
+  PanelManager::GetInstance()->SetMouseWatcherForTesting(mouse_watcher);
 
   CreatePanelParams params("Initially Active", gfx::Rect(), SHOW_AS_ACTIVE);
   Panel* panel = CreatePanelWithParams(params);
   NativePanel* native_panel = panel->native_panel();
   scoped_ptr<NativePanelTesting> native_panel_testing(
       NativePanelTesting::Create(native_panel));
 
   // Test that the attention is drawn and the title-bar is brought up when the
   // minimized panel is drawing attention.
   panel->SetExpansionState(Panel::MINIMIZED);
@@ skipping 760 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));
 }