Implement drag and drop testing in a platform independent way.

chrome/browser/ui/panels/panel_browsertest.cc

Index: chrome/browser/ui/panels/panel_browsertest.cc
diff --git a/chrome/browser/ui/panels/panel_browsertest.cc b/chrome/browser/ui/panels/panel_browsertest.cc
index 791dba45679a9f4f11b9f9b8efb1d2ced11c736e..945c3d51b3dbaeee41a1d637de65b21d9d17104f 100644
--- a/chrome/browser/ui/panels/panel_browsertest.cc
+++ b/chrome/browser/ui/panels/panel_browsertest.cc
@@ -12,6 +12,7 @@
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/find_bar/find_bar.h"
 #include "chrome/browser/ui/find_bar/find_bar_controller.h"
+#include "chrome/browser/ui/panels/native_panel.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
@@ -56,6 +57,8 @@ class PanelBrowserTest : public InProcessBrowserTest {
 
     Panel* panel = static_cast<Panel*>(panel_browser->window());
     panel->Show();
+    MessageLoopForUI::current()->RunAllPending();
+
     return panel;
   }
 
@@ -150,6 +153,117 @@ class PanelBrowserTest : public InProcessBrowserTest {
     panel1->Close();
     panel6->Close();
   }
+
+  struct DragTestData {
+    DragTestData(int drag_delta_x,
+                 int drag_delta_y,
+                 bool is_big_delta,
+                 bool is_cancel_drag)
+        : drag_delta_x_(drag_delta_x), drag_delta_y_(drag_delta_y),
+          is_big_delta_(is_big_delta), is_cancel_drag_(is_cancel_drag) {}
+    int drag_delta_x_;
+    int drag_delta_y_;
+    bool is_big_delta_;  // Drag big enough to cause shuffling.
+    bool is_cancel_drag_;
+  };
+
+  void TestDragging(std::vector<Panel*>& panels,
+                    const struct DragTestData& drag_test_data) {
+    // Test dragging each panel in the list.
+    for (uint drag_index = 0; drag_index < panels.size(); drag_index++) {
+      std::vector<int> expected_delta_x_after_drag;
+      std::vector<int> expected_delta_x_after_finish;
+
+      for (uint j = 0; j < panels.size(); j++) {
+        expected_delta_x_after_drag.push_back(0);
+        expected_delta_x_after_finish.push_back(0);
+      }
+
+      expected_delta_x_after_drag[drag_index] = drag_test_data.drag_delta_x_;
+      uint 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 != panels.size() - 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.is_cancel_drag_);
+
+      if (swap_index != drag_index && !drag_test_data.is_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;
+      }
+    }
+  }
+
+  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 is_cancel_drag) {
+    // Keep track of the initial bounds for comparison.
+    std::vector<gfx::Rect> initial_bounds(panels.size());
+    for (uint i = 0; i < panels.size(); i++)
+      initial_bounds[i] = panels[i]->GetRestoredBounds();
+
+    // Trigger the mouse-pressed event.
+    // All panels should remain in their original positions.
+    NativePanel* panel_to_drag = panels[index_to_drag]->native_panel();
+    NativePanelTesting* panel_to_drag_testing =
+        NativePanelTesting::Create(panel_to_drag);
+    gfx::Point button_press_point(initial_bounds[index_to_drag].x(),
+                                  initial_bounds[index_to_drag].y());
+    panel_to_drag_testing->TitlebarLeftButtonPress(button_press_point);
+    for (uint i = 0; i < panels.size(); i++)
+      EXPECT_EQ(initial_bounds[i], panels[i]->GetRestoredBounds());
+
+    if (delta_x || delta_y) {
+      panel_to_drag_testing->TitlebarDrag(delta_x, delta_y);
+
+      for (uint i = 0; i < panels.size(); i++) {
+        gfx::Rect expected_bounds = initial_bounds[i];
+        expected_bounds.Offset(expected_delta_x_after_drag[i], 0);
+        EXPECT_EQ(expected_bounds, panels[i]->GetRestoredBounds());
+      }
+    }
+
+    // Cancel the dragging if asked.
+    // All panels should stay in their original positions.
+    if (is_cancel_drag) {
+      panel_to_drag_testing->TitlebarCancelDrag();
+      for (uint i = 0; i < panels.size(); i++)
+        EXPECT_EQ(initial_bounds[i], panels[i]->GetRestoredBounds());
+      return;
+    }
+
+    // Otherwise finish the drag.
+    panel_to_drag_testing->TitlebarFinishDrag();
+    for (uint 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());
+    }
+  }
 };
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreatePanel) {
@@ -188,6 +302,46 @@ IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_CreatePanelOnOverflow) {
   TestCreatePanelOnOverflow();
 }
 
+#ifdef OS_MACOSX
+#define MAYBE_DragPanels DISABLED_DragPanels
+#else
+#define MAYBE_DragPanels 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, is_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 (uint 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]);
+    }
+  }
+
+  for (uint i = 0; i < panels.size(); i++)
+    panels[i]->Close();
+}
+
 class PanelDownloadTest : public PanelBrowserTest {
  public:
   PanelDownloadTest() : PanelBrowserTest() { }