Ash: Double-clicking on a shelf item now opens the item

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 111 matching lines @@
 
 // TestShelfItemDelegate which tracks whether it gets selected.
 class ShelfItemSelectionTracker : public TestShelfItemDelegate {
  public:
   ShelfItemSelectionTracker() : TestShelfItemDelegate(NULL), selected_(false) {
   }
 
   virtual ~ShelfItemSelectionTracker() {
   }
 
+  // Resets to the initial state.
+  void Reset() { selected_ = false; }
+
   // Returns true if the delegate was selected.
   bool WasSelected() {
     return selected_;
   }
 
   // TestShelfItemDelegate:
   virtual bool ItemSelected(const ui::Event& event) OVERRIDE {
     selected_ = true;
     return false;
   }
@@ skipping 136 matching lines @@
 
   // Temp member variable for returning a value. See the comment in the
   // GetAppIDForShelfID().
   std::string app_id_;
 
   DISALLOW_COPY_AND_ASSIGN(TestShelfDelegateForShelfView);
 };
 
 class ShelfViewTest : public AshTestBase {
  public:
-  ShelfViewTest() : model_(NULL), shelf_view_(NULL), browser_index_(1) {}
+  ShelfViewTest()
+      : model_(NULL),
+        shelf_view_(NULL),
+        browser_index_(1),
+        item_manager_(NULL) {}
   virtual ~ShelfViewTest() {}
 
   virtual void SetUp() OVERRIDE {
     AshTestBase::SetUp();
     test::ShellTestApi test_api(Shell::GetInstance());
     model_ = test_api.shelf_model();
     Shelf* shelf = Shelf::ForPrimaryDisplay();
     shelf_view_ = ShelfTestAPI(shelf).shelf_view();
 
     // The bounds should be big enough for 4 buttons + overflow chevron.
@@ skipping 101 matching lines @@
       ShelfItem item = model_->items()[model_index];
       ShelfID id = item.id;
       EXPECT_EQ(id_map[map_index].first, id);
       EXPECT_EQ(id_map[map_index].second, GetButtonByID(id));
       ++map_index;
     }
     ASSERT_EQ(map_index, id_map.size());
   }
 
   void VerifyShelfItemBoundsAreValid() {
-    for (int i=0;i <= test_api_->GetLastVisibleIndex(); ++i) {
+    for (int i = 0; i <= test_api_->GetLastVisibleIndex(); ++i) {
       if (test_api_->GetButton(i)) {
         gfx::Rect shelf_view_bounds = shelf_view_->GetLocalBounds();
         gfx::Rect item_bounds = test_api_->GetBoundsByIndex(i);
         EXPECT_GE(item_bounds.x(), 0);
         EXPECT_GE(item_bounds.y(), 0);
         EXPECT_LE(item_bounds.right(), shelf_view_bounds.width());
         EXPECT_LE(item_bounds.bottom(), shelf_view_bounds.height());
       }
     }
   }
 
-  views::View* SimulateButtonPressed(ShelfButtonHost::Pointer pointer,
+  ShelfButton* SimulateButtonPressed(ShelfButtonHost::Pointer pointer,
                                      int button_index) {
     ShelfButtonHost* button_host = shelf_view_;
-    views::View* button = test_api_->GetButton(button_index);
+    ShelfButton* button = test_api_->GetButton(button_index);
     ui::MouseEvent click_event(ui::ET_MOUSE_PRESSED,
                                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) {
+  // Simulates a single mouse click.
+  void SimulateClick(int button_index) {
     ShelfButtonHost* button_host = shelf_view_;
-    views::View* button = SimulateButtonPressed(pointer, button_index);
+    ShelfButton* button =
+        SimulateButtonPressed(ShelfButtonHost::MOUSE, button_index);
+    ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED,
+                                 gfx::Point(),
+                                 button->GetBoundsInScreen().origin(),
+                                 0,
+                                 0);
+    test_api_->ButtonPressed(button, release_event);
     button_host->PointerReleasedOnButton(button, ShelfButtonHost::MOUSE, false);
-    return button;
+  }
+
+  // Simulates the second click of a double click.
+  void SimulateDoubleClick(int button_index) {
+    ShelfButtonHost* button_host = shelf_view_;
+    ShelfButton* button =
+        SimulateButtonPressed(ShelfButtonHost::MOUSE, button_index);
+    ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED,
+                                 gfx::Point(),
+                                 button->GetBoundsInScreen().origin(),
+                                 ui::EF_IS_DOUBLE_CLICK,
+                                 0);
+    test_api_->ButtonPressed(button, release_event);
+    button_host->PointerReleasedOnButton(button, ShelfButtonHost::MOUSE, false);
   }
 
   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);
@@ skipping 150 matching lines @@
   ShelfItemDelegateManager* item_manager_;
 
   scoped_ptr<ShelfViewTestAPI> test_api_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShelfViewTest);
 };
 
 class ScopedTextDirectionChange {
  public:
-  ScopedTextDirectionChange(bool is_rtl)
-      : is_rtl_(is_rtl) {
+  explicit ScopedTextDirectionChange(bool is_rtl) : is_rtl_(is_rtl) {
     original_locale_ = l10n_util::GetApplicationLocale(std::string());
     if (is_rtl_)
       base::i18n::SetICUDefaultLocale("he");
     CheckTextDirectionIsCorrect();
   }
 
   ~ScopedTextDirectionChange() {
     if (is_rtl_)
       base::i18n::SetICUDefaultLocale(original_locale_);
   }
@@ skipping 415 matching lines @@
 
 // Check that clicking first on one item and then dragging another works as
 // expected.
 TEST_F(ShelfViewTest, ClickOneDragAnother) {
   ShelfButtonHost* button_host = shelf_view_;
 
   std::vector<std::pair<ShelfID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // A click on item 1 is simulated.
-  SimulateClick(ShelfButtonHost::MOUSE, 1);
+  SimulateClick(1);
 
   // Dragging browser index at 0 should change the model order correctly.
   EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
   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);
 }
 
+// Tests that double-clicking an item does not activate it twice.
+TEST_F(ShelfViewTest, ClickingTwiceActivatesOnce) {
+  // Watch for selection of the browser shortcut.
+  ShelfID browser_shelf_id = model_->items()[browser_index_].id;
+  ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
+  item_manager_->SetShelfItemDelegate(
+      browser_shelf_id,
+      scoped_ptr<ShelfItemDelegate>(selection_tracker).Pass());
+
+  // A single click selects the item.
+  SimulateClick(browser_index_);
+  EXPECT_TRUE(selection_tracker->WasSelected());
+
+  // A double-click does not select the item.
+  selection_tracker->Reset();
+  SimulateDoubleClick(browser_index_);
+  EXPECT_FALSE(selection_tracker->WasSelected());
+}
+
 // 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
@@ skipping 599 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