Implement drag and drop testing in a platform independent way.

chrome/browser/ui/panels/panel_browser_view_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 "base/i18n/time_formatting.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 77 matching lines @@
   }
 
   void WaitTillBoundsAnimationFinished(PanelBrowserView* browser_view) {
     // The timer for the animation will only kick in as async task.
     while (browser_view->bounds_animator_->is_animating()) {
       MessageLoop::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
       MessageLoop::current()->RunAllPending();
     }
   }
 
-  void ValidateDragging(PanelBrowserView** browser_views,
-                        size_t num_browser_views,
-                        size_t index_to_drag,
-                        int delta_x,
-                        int delta_y,
-                        int* expected_delta_x_after_drag,
-                        int* expected_delta_x_after_release,
-                        bool cancel_dragging) {
-    // Keep track of the initial bounds for comparison.
-    scoped_array<gfx::Rect> initial_bounds(new gfx::Rect[num_browser_views]);
-    for (size_t i = 0; i < num_browser_views; ++i)
-      initial_bounds[i] = browser_views[i]->panel()->GetRestoredBounds();
-
-    // Trigger the mouse-pressed event.
-    // All panels should remain in their original positions.
-    views::MouseEvent pressed(ui::ET_MOUSE_PRESSED,
-                              initial_bounds[index_to_drag].x(),
-                              initial_bounds[index_to_drag].y(),
-                              ui::EF_LEFT_BUTTON_DOWN);
-    browser_views[index_to_drag]->OnTitleBarMousePressed(pressed);
-    gfx::Rect bounds_after_press =
-        browser_views[index_to_drag]->panel()->GetRestoredBounds();
-    for (size_t i = 0; i < num_browser_views; ++i) {
-      EXPECT_EQ(initial_bounds[i],
-                browser_views[i]->panel()->GetRestoredBounds());
-    }
-
-    // Trigger the mouse_dragged event if delta_x or delta_y is not 0.
-    views::MouseEvent dragged(ui::ET_MOUSE_DRAGGED,
-                              initial_bounds[index_to_drag].x() + delta_x,
-                              initial_bounds[index_to_drag].y() + delta_y,
-                              ui::EF_LEFT_BUTTON_DOWN);
-    if (delta_x || delta_y) {
-      browser_views[index_to_drag]->OnTitleBarMouseDragged(dragged);
-
-      for (size_t i = 0; i < num_browser_views; ++i) {
-        gfx::Rect expected_bounds = initial_bounds[i];
-        expected_bounds.Offset(expected_delta_x_after_drag[i], 0);
-        EXPECT_EQ(expected_bounds,
-                  browser_views[i]->panel()->GetRestoredBounds());
-      }
-    }
-
-    // Cancel the dragging if asked.
-    // All panels should stay in their original positions.
-    if (cancel_dragging) {
-      browser_views[index_to_drag]->OnTitleBarMouseCaptureLost();
-      for (size_t i = 0; i < num_browser_views; ++i) {
-        EXPECT_EQ(initial_bounds[i],
-                  browser_views[i]->panel()->GetRestoredBounds());
-      }
-      return;
-    }
-
-    // Otherwise, trigger the mouse-released event.
-    views::MouseEvent released(ui::ET_MOUSE_RELEASED, 0, 0, 0);
-    browser_views[index_to_drag]->OnTitleBarMouseReleased(released);
-    for (size_t i = 0; i < num_browser_views; ++i) {
-      gfx::Rect expected_bounds = initial_bounds[i];
-       expected_bounds.Offset(expected_delta_x_after_release[i], 0);
-      EXPECT_EQ(expected_bounds,
-                browser_views[i]->panel()->GetRestoredBounds());
-    }
-
-    // If releasing the drag causes the panels to swap, move these panels back
-    // so that the next test will not be affected.
-    if (initial_bounds[index_to_drag] !=
-        browser_views[index_to_drag]->panel()->GetRestoredBounds()) {
-      // Find the index of the panel to swap with the dragging panel.
-      size_t swapped_index = 0;
-      for (; swapped_index < num_browser_views; ++swapped_index) {
-        if (initial_bounds[index_to_drag] ==
-            browser_views[swapped_index]->panel()->GetRestoredBounds())
-          break;
-      }
-      ASSERT_NE(swapped_index, index_to_drag);
-
-      // Repeat the mouse events to this panel.
-      browser_views[swapped_index]->OnTitleBarMousePressed(pressed);
-      browser_views[swapped_index]->OnTitleBarMouseDragged(dragged);
-      browser_views[swapped_index]->OnTitleBarMouseReleased(released);
-      for (size_t i = 0; i < num_browser_views; ++i) {
-        EXPECT_EQ(initial_bounds[i],
-                  browser_views[i]->panel()->GetRestoredBounds());
-      }
-    }
-  }
-
   void ValidateSettingsMenuItems(ui::SimpleMenuModel* settings_menu_contents,
                                  size_t num_expected_menu_items,
                                  const MenuItem* expected_menu_items) {
     ASSERT_TRUE(settings_menu_contents);
     EXPECT_EQ(static_cast<int>(num_expected_menu_items),
               settings_menu_contents->GetItemCount());
     for (size_t i = 0; i < num_expected_menu_items; ++i) {
       if (expected_menu_items[i].id == -1) {
         EXPECT_EQ(ui::MenuModel::TYPE_SEPARATOR,
                   settings_menu_contents->GetTypeAt(i));
@@ skipping 335 matching lines @@
   // the panel or not.
   browser_view->panel()->Deactivate();
   EXPECT_FALSE(browser_view->panel()->IsActive());
 
   mouse_watcher->MoveMouse(true);
   EXPECT_TRUE(frame_view->settings_button_->IsVisible());
   mouse_watcher->MoveMouse(false);
   EXPECT_FALSE(frame_view->settings_button_->IsVisible());
 }
 
-IN_PROC_BROWSER_TEST_F(PanelBrowserViewTest, TitleBarMouseEvent) {
-  // TODO(jianli): Move the test to platform-independent PanelManager unittest.
-
-  // Creates the 1st panel.
-  PanelBrowserView* browser_view1 = CreatePanelBrowserView("PanelTest1",
-                                                           SHOW_AS_ACTIVE);
-
-  // The delta is from the pressed location which is the left-top corner of the
-  // panel to drag.
-  int small_negative_delta = -5;
-  int small_positive_delta = 5;
-  int big_negative_delta =
-      -(browser_view1->panel()->GetRestoredBounds().width() * 0.5 + 5);
-  int big_positive_delta =
-      browser_view1->panel()->GetRestoredBounds().width() * 1.5 + 5;
-
-  // Tests dragging a panel in single-panel environment.
-  // We should get back to the original position after the dragging is ended.
-  int expected_single_delta_x_after_drag[] = { big_negative_delta };
-  int expected_single_delta_x_after_release[] = { 0 };
-  ValidateDragging(&browser_view1,
-                   1,
-                   0,
-                   big_negative_delta,
-                   big_negative_delta,
-                   expected_single_delta_x_after_drag,
-                   expected_single_delta_x_after_release,
-                   false);
-
-  expected_single_delta_x_after_drag[0] = big_positive_delta;
-  ValidateDragging(&browser_view1,
-                   1,
-                   0,
-                   big_positive_delta,
-                   big_positive_delta,
-                   expected_single_delta_x_after_drag,
-                   expected_single_delta_x_after_release,
-                   false);
-
-  // Creates 2 more panels to test dragging a panel in multi-panel environment.
-  PanelBrowserView* browser_view2 = CreatePanelBrowserView("PanelTest2",
-                                                           SHOW_AS_ACTIVE);
-  PanelBrowserView* browser_view3 = CreatePanelBrowserView("PanelTest3",
-                                                           SHOW_AS_ACTIVE);
-  PanelBrowserView* browser_views[] =
-    { browser_view1, browser_view2, browser_view3 };
-  size_t browser_view_count = arraysize(browser_views);
-  int expected_delta_x_without_change[] = { 0, 0, 0 };
-
-  // Tests dragging a panel with small delta.
-  // We should get back to the original position after the dragging is ended.
-  for (size_t i = 0; i < browser_view_count; ++i) {
-    int expected_delta_x_after_drag[] = { 0, 0, 0 };
-
-    expected_delta_x_after_drag[i] = small_negative_delta;
-    ValidateDragging(browser_views,
-                     browser_view_count,
-                     i,
-                     small_negative_delta,
-                     small_negative_delta,
-                     expected_delta_x_after_drag,
-                     expected_delta_x_without_change,
-                     false);
-
-    expected_delta_x_after_drag[i] = small_positive_delta;
-    ValidateDragging(browser_views,
-                     browser_view_count,
-                     i,
-                     small_positive_delta,
-                     small_positive_delta,
-                     expected_delta_x_after_drag,
-                     expected_delta_x_without_change,
-                     false);
-  }
-
-  // Tests dragging a panel with big delta and then cancelling it.
-  // We should get back to the original position.
-  for (size_t i = 0; i < browser_view_count; ++i) {
-    int expected_delta_x_after_drag[] = { 0, 0, 0 };
-    expected_delta_x_after_drag[i] = big_negative_delta;
-    if (i + 1 < browser_view_count) {
-      expected_delta_x_after_drag[i + 1] =
-          browser_views[i]->panel()->GetRestoredBounds().x() -
-          browser_views[i + 1]->panel()->GetRestoredBounds().x();
-    }
-    ValidateDragging(browser_views,
-                     browser_view_count,
-                     i,
-                     big_negative_delta,
-                     big_negative_delta,
-                     expected_delta_x_after_drag,
-                     expected_delta_x_without_change,
-                     true);
-
-    int expected_delta_x_after_drag2[] = { 0, 0, 0 };
-    expected_delta_x_after_drag2[i] = big_positive_delta;
-    if (static_cast<int>(i) - 1 >= 0) {
-      expected_delta_x_after_drag2[i - 1] =
-          browser_views[i]->panel()->GetRestoredBounds().x() -
-          browser_views[i - 1]->panel()->GetRestoredBounds().x();
-    }
-    ValidateDragging(browser_views,
-                     browser_view_count,
-                     i,
-                     big_positive_delta,
-                     big_positive_delta,
-                     expected_delta_x_after_drag2,
-                     expected_delta_x_without_change,
-                     true);
-  }
-
-  // Tests dragging a panel with big delta.
-  // We should move to the new position after the dragging is ended.
-  for (size_t i = 0; i < browser_view_count; ++i) {
-    int expected_delta_x_after_drag[] = { 0, 0, 0 };
-    int expected_delta_x_after_release[] = { 0, 0, 0 };
-    expected_delta_x_after_drag[i] = big_negative_delta;
-    if (i + 1 < browser_view_count) {
-      expected_delta_x_after_drag[i + 1] =
-          browser_views[i]->panel()->GetRestoredBounds().x() -
-          browser_views[i + 1]->panel()->GetRestoredBounds().x();
-      expected_delta_x_after_release[i + 1] =
-          expected_delta_x_after_drag[i + 1];
-      expected_delta_x_after_release[i] =
-          browser_views[i + 1]->panel()->GetRestoredBounds().x() -
-          browser_views[i]->panel()->GetRestoredBounds().x();
-    }
-    ValidateDragging(browser_views,
-                     browser_view_count,
-                     i,
-                     big_negative_delta,
-                     big_negative_delta,
-                     expected_delta_x_after_drag,
-                     expected_delta_x_after_release,
-                     false);
-
-    int expected_delta_x_after_drag2[] = { 0, 0, 0 };
-    int expected_delta_x_after_release2[] = { 0, 0, 0 };
-    expected_delta_x_after_drag2[i] = big_positive_delta;
-    if (static_cast<int>(i) - 1 >= 0) {
-      expected_delta_x_after_drag2[i - 1] =
-          browser_views[i]->panel()->GetRestoredBounds().x() -
-          browser_views[i - 1]->panel()->GetRestoredBounds().x();
-      expected_delta_x_after_release2[i - 1] =
-          expected_delta_x_after_drag2[i - 1];
-      expected_delta_x_after_release2[i] =
-          browser_views[i - 1]->panel()->GetRestoredBounds().x() -
-          browser_views[i]->panel()->GetRestoredBounds().x();
-    }
-    ValidateDragging(browser_views,
-                     browser_view_count,
-                     i,
-                     big_positive_delta,
-                     big_positive_delta,
-                     expected_delta_x_after_drag2,
-                     expected_delta_x_after_release2,
-                     false);
-  }
-
-  // Closes all panels.
-  for (size_t i = 0; i < browser_view_count; ++i) {
-    browser_views[i]->panel()->Close();
-    // We're only verifying that PanelBrowserView::Close has been called when
-    // a panel is closed. This is to make sure the dragging is ended and does
-    // not interfere the closing process.
-    EXPECT_TRUE(browser_views[i]->closed());
-  }
-}
-
 IN_PROC_BROWSER_TEST_F(PanelBrowserViewTest, SetBoundsAnimation) {
   PanelBrowserView* browser_view = CreatePanelBrowserView("PanelTest",
                                                           SHOW_AS_ACTIVE);
 
   // Validate that animation should be triggered when SetBounds is called.
   gfx::Rect target_bounds(browser_view->GetBounds());
   target_bounds.Offset(20, -30);
   target_bounds.set_width(target_bounds.width() + 100);
   target_bounds.set_height(target_bounds.height() + 50);
   browser_view->SetBounds(target_bounds);
   ASSERT_TRUE(browser_view->bounds_animator_.get());
   EXPECT_TRUE(browser_view->bounds_animator_->is_animating());
   EXPECT_NE(browser_view->GetBounds(), target_bounds);
   WaitTillBoundsAnimationFinished(browser_view);
   EXPECT_EQ(browser_view->GetBounds(), target_bounds);
 
   // Validates that no animation should be triggered for the panel currently
   // being dragged.
-  views::MouseEvent pressed(ui::ET_MOUSE_PRESSED,
-                            target_bounds.x(),
-                            target_bounds.y(),
-                            ui::EF_LEFT_BUTTON_DOWN);
-  browser_view->OnTitleBarMousePressed(pressed);
-
-  views::MouseEvent dragged(ui::ET_MOUSE_DRAGGED,
-                            target_bounds.x() + 5,
-                            target_bounds.y() + 5,
-                            ui::EF_LEFT_BUTTON_DOWN);
-  browser_view->OnTitleBarMouseDragged(dragged);
+  browser_view->OnTitleBarMousePressed(gfx::Point(
+      target_bounds.x(), target_bounds.y()));
+  browser_view->OnTitleBarMouseDragged(gfx::Point(
+      target_bounds.x() + 5, target_bounds.y() + 5));
   EXPECT_FALSE(browser_view->bounds_animator_->is_animating());
   browser_view->OnTitleBarMouseCaptureLost();
 
   browser_view->panel()->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserViewTest, CreateSettingsMenu) {
   TestCreateSettingsMenuForExtension(
       FILE_PATH_LITERAL("extension1"), Extension::EXTERNAL_POLICY_DOWNLOAD,
       "", "");
   TestCreateSettingsMenuForExtension(
       FILE_PATH_LITERAL("extension2"), Extension::INVALID,
       "http://home", "options.html");
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserViewTest, MinimizeAndRestore) {
   TestMinimizeAndRestore();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserViewTest, DrawAttention) {
   TestDrawAttention();
 }
 #endif