Require the cursor to move a minimum distance after the mouse press before initiating a mouse drag

ash/shelf/shelf_view_unittest.cc

 // Copyright (c) 2012 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 "ash/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 102 matching lines @@
     return Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
   }
 
  private:
   scoped_ptr<TestShelfIconObserver> observer_;
   scoped_ptr<ShelfViewTestAPI> shelf_view_test_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfViewIconObserverTest);
 };
 
+// TestShelfItemDelegate which tracks whether it gets selected.
+class ShelfItemSelectionTracker : public TestShelfItemDelegate {
+ public:
+  ShelfItemSelectionTracker() : TestShelfItemDelegate(NULL), selected_(false) {
+  }
+
+  virtual ~ShelfItemSelectionTracker() {
+  }
+
+  // Returns true if the delegate was selected.
+  bool WasSelected() {
+    return selected_;
+  }
+
+  // TestShelfItemDelegate:
+  virtual bool ItemSelected(const ui::Event& event) OVERRIDE {
+    selected_ = true;
+    return false;
+  }
+
+ private:
+  bool selected_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShelfItemSelectionTracker);
+};
+
 TEST_F(ShelfViewIconObserverTest, AddRemove) {
   TestShelfDelegate* shelf_delegate = TestShelfDelegate::instance();
   ASSERT_TRUE(shelf_delegate);
 
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW);
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.bounds = gfx::Rect(0, 0, 200, 200);
   params.context = CurrentContext();
 
   scoped_ptr<views::Widget> widget(new views::Widget());
@@ skipping 258 matching lines @@
         EXPECT_LE(item_bounds.bottom(), shelf_view_bounds.height());
       }
     }
   }
 
   views::View* SimulateButtonPressed(ShelfButtonHost::Pointer pointer,
                                      int button_index) {
     ShelfButtonHost* button_host = shelf_view_;
     views::View* button = test_api_->GetButton(button_index);
     ui::MouseEvent click_event(ui::ET_MOUSE_PRESSED,
-                               button->bounds().origin(),
+                               gfx::Point(),
                                button->GetBoundsInScreen().origin(), 0, 0);
     button_host->PointerPressedOnButton(button, pointer, click_event);
     return button;
   }
 
   views::View* SimulateClick(ShelfButtonHost::Pointer pointer,
                              int button_index) {
     ShelfButtonHost* button_host = shelf_view_;
     views::View* button = SimulateButtonPressed(pointer, button_index);
     button_host->PointerReleasedOnButton(button, ShelfButtonHost::MOUSE, false);
     return button;
   }
 
   views::View* SimulateDrag(ShelfButtonHost::Pointer pointer,
                             int button_index,
                             int destination_index) {
     ShelfButtonHost* button_host = shelf_view_;
     views::View* button = SimulateButtonPressed(pointer, button_index);
 
     // Drag.
     views::View* destination = test_api_->GetButton(destination_index);
     ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED,
-                              destination->bounds().origin(),
+                              gfx::Point(destination->x() - button->x(),
+                                         destination->y() - button->y()),
                               destination->GetBoundsInScreen().origin(), 0, 0);
     button_host->PointerDraggedOnButton(button, pointer, drag_event);
     return button;
   }
 
   void SetupForDragTest(
       std::vector<std::pair<ShelfID, views::View*> >* id_map) {
     // Initialize |id_map| with the automatically-created shelf buttons.
     for (size_t i = 0; i < model_->items().size(); ++i) {
       ShelfButton* button = test_api_->GetButton(i);
@@ skipping 588 matching lines @@
   views::View* dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3);
   std::rotate(id_map.begin() + 1,
               id_map.begin() + 2,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(
       dragged_button, ShelfButtonHost::MOUSE, false);
   EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
 }
 
+// Check that clicking an item and jittering the mouse a bit still selects the
+// item.
+TEST_F(ShelfViewTest, ClickAndMoveSlightly) {
+  std::vector<std::pair<ShelfID, views::View*> > id_map;
+  SetupForDragTest(&id_map);
+
+  ShelfID shelf_id = (id_map.begin() + 1)->first;
+  views::View* button = (id_map.begin() + 1)->second;
+
+  // Replace the ShelfItemDelegate for |shelf_id| with one which tracks whether
+  // the shelf item gets selected.
+  ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
+  item_manager_->SetShelfItemDelegate(
+      shelf_id,
+      scoped_ptr<ShelfItemDelegate>(selection_tracker).Pass());
+
+  gfx::Vector2d press_offset(5, 30);
+  gfx::Point press_location = gfx::Point() + press_offset;
+  gfx::Point press_location_in_screen =
+      button->GetBoundsInScreen().origin() + press_offset;
+
+  ui::MouseEvent click_event(ui::ET_MOUSE_PRESSED,
+                             press_location,
+                             press_location_in_screen,
+                             ui::EF_LEFT_MOUSE_BUTTON, 0);
+  button->OnMousePressed(click_event);
+
+  ui::MouseEvent drag_event1(ui::ET_MOUSE_DRAGGED,
+                             press_location + gfx::Vector2d(0, 1),
+                             press_location_in_screen + gfx::Vector2d(0, 1),
+                             ui::EF_LEFT_MOUSE_BUTTON, 0);
+  button->OnMouseDragged(drag_event1);
+
+  ui::MouseEvent drag_event2(ui::ET_MOUSE_DRAGGED,
+                             press_location + gfx::Vector2d(-1, 0),
+                             press_location_in_screen + gfx::Vector2d(-1, 0),
+                             ui::EF_LEFT_MOUSE_BUTTON, 0);
+  button->OnMouseDragged(drag_event2);
+
+  ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED,
+                               press_location + gfx::Vector2d(-1, 0),
+                               press_location_in_screen + gfx::Vector2d(-1, 0),
+                               ui::EF_LEFT_MOUSE_BUTTON, 0);
+  button->OnMouseReleased(release_event);
+
+  EXPECT_TRUE(selection_tracker->WasSelected());
+}
+
 // Confirm that item status changes are reflected in the buttons.
 TEST_F(ShelfViewTest, ShelfItemStatus) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(),
             test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
   ShelfID last_added = AddPlatformApp();
   ShelfItem item = GetItemByID(last_added);
   int index = model_->ItemIndexByID(last_added);
@@ skipping 551 matching lines @@
   test_api_->RunMessageLoopUntilAnimationsDone();
   CheckAllItemsAreInBounds();
 }
 
 INSTANTIATE_TEST_CASE_P(LtrRtl, ShelfViewTextDirectionTest, testing::Bool());
 INSTANTIATE_TEST_CASE_P(VisibleBounds, ShelfViewVisibleBoundsTest,
     testing::Bool());
 
 }  // namespace test
 }  // namespace ash