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..f1f3baf7a5bdb2ec5be841c951ea074bffec9b18 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_;

[jianli, 2011/08/11 01:22:54]

For struct members, we do not end with "_".

[prasadt, 2011/08/11 18:11:11]

Done.

+    int drag_delta_y_;
+    bool is_big_delta_;  // Drag big enough to cause shuffling.

[jianli, 2011/08/11 01:22:54]

Can we get rid of is_big_delta? I think we can get the conclusion by checking if
drag_delta_x_ is really big.

[prasadt, 2011/08/11 18:11:11]

I like being explicit about this at the outset.  Leaving it as it is.

+    bool is_cancel_drag_;
+  };
+
+  void TestDragging(std::vector<Panel*>& panels,

[jianli, 2011/08/11 01:22:54]

We do not like to pass by reference.

[prasadt, 2011/08/11 18:11:11]

Done.

+                    const struct DragTestData& drag_test_data) {

[jianli, 2011/08/11 01:22:54]

struct is not needed.

[prasadt, 2011/08/11 18:11:11]

Done.

+    // Test dragging each panel in the list.
+    for (size_t drag_index = 0; drag_index < panels.size(); drag_index++) {

[jianli, 2011/08/11 01:22:54]

We prefer to use ++drag_index with the iterator.

[prasadt, 2011/08/11 18:11:11]

Done.

+      std::vector<int> expected_delta_x_after_drag;
+      std::vector<int> expected_delta_x_after_finish;
+
+      for (size_t 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_;
+      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 != 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) {

[jianli, 2011/08/11 01:22:54]

is_cancel_drag => should_cancel_drag

[prasadt, 2011/08/11 18:11:11]

Done.

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

[jianli, 2011/08/11 01:22:54]

ditto.

[prasadt, 2011/08/11 18:11:11]

Done.

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

[jianli, 2011/08/11 01:22:54]

Memory leak here. Also, the name panel_to_drag_testing sounds quite confusing to
me. How about panel_testing_to_drag?

[prasadt, 2011/08/11 18:11:11]

Done.

+        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->PressLeftMouseButtonTitlebar(button_press_point);
+    for (size_t i = 0; i < panels.size(); i++)
+      EXPECT_EQ(initial_bounds[i], panels[i]->GetRestoredBounds());
+
+    if (delta_x || delta_y) {

[jianli, 2011/08/11 01:22:54]

Please add a comment:
  // Trigger the drag.

[prasadt, 2011/08/11 18:11:11]

Done.

+      panel_to_drag_testing->DragTitlebar(delta_x, delta_y);
+
+      for (size_t 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->CancelDragTitlebar();
+      for (size_t i = 0; i < panels.size(); i++)
+        EXPECT_EQ(initial_bounds[i], panels[i]->GetRestoredBounds());
+      return;
+    }
+
+    // Otherwise finish the drag.
+    panel_to_drag_testing->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());
+    }
+  }
 };
 
 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()));

[jianli, 2011/08/11 01:22:54]

The creation of 1st panel can be moved into for loop. You can pass the size to
CreatePanel.

[prasadt, 2011/08/11 18:11:11]

I would rather just use the default size than to try to guess.  We could have
different defaults for different platofrms, screen sizes etc.

[jianli, 2011/08/11 20:52:09]

It would be better to pass fixed size to CreatePanel. For now you only have 3
panels and the default panel width is 240 and it is mostly likely been fine for
nowadays screen not smaller than 800x600. However, when you add more panels for
new tests as we discussed, we have to pass specific size in order not to exceed
800x600. Furthermore, I think we should call PanelManager::SetWorkArea to use a
specific work area, like 800x600, for the testing purpose. This will make the
tests far less flaky. You can do it in your next patch to add more test cases.

[prasadt, 2011/08/11 21:07:56]

Will look at doing this in my next patch.

+
+  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 (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]);
+    }
+  }
+
+  for (size_t i = 0; i < panels.size(); i++)
+    panels[i]->Close();
+}
+
 class PanelDownloadTest : public PanelBrowserTest {
  public:
   PanelDownloadTest() : PanelBrowserTest() { }