Implement drag and drop testing in a platform independent way.

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/download/download_manager.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"
 #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"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
@@ skipping 24 matching lines @@
                                                    bounds,
                                                    browser()->profile());
     EXPECT_TRUE(panel_browser->is_type_panel());
 
     TabContentsWrapper* tab_contents =
         new TabContentsWrapper(new TestTabContents(browser()->profile(), NULL));
     panel_browser->AddTab(tab_contents, PageTransition::LINK);
 
     Panel* panel = static_cast<Panel*>(panel_browser->window());
     panel->Show();
+    MessageLoopForUI::current()->RunAllPending();
+
     return panel;
   }
 
   // Creates a testing extension.
   scoped_refptr<Extension> CreateExtension(const FilePath::StringType& path) {
 #if defined(OS_WIN)
     FilePath full_path(FILE_PATH_LITERAL("c:\\"));
 #else
     FilePath full_path(FILE_PATH_LITERAL("/"));
 #endif
@@ skipping 74 matching lines @@
         web_app::GenerateApplicationNameFromExtensionId(extension3->id()),
         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 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) {
   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());
 
   gfx::Rect bounds = panel->GetBounds();
@@ skipping 18 matching lines @@
 #ifdef OS_MACOSX
 #define MAYBE_CreatePanelOnOverflow DISABLED_CreatePanelOnOverflow
 #else
 #define MAYBE_CreatePanelOnOverflow CreatePanelOnOverflow
 #endif
 
 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() { }
 
   // Creates a temporary directory for downloads that is auto-deleted
   // on destruction.
   bool CreateDownloadDirectory(Profile* profile) {
     bool created = downloads_directory_.CreateUniqueTempDir();
     if (!created)
       return false;
@@ skipping 144 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();
 }