Make the second click on the app shelf icon close the window-list bubble.

ash/shelf/shelf_view.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 "ash/ash_constants.h"
 #include "ash/ash_switches.h"
@@ skipping 371 matching lines @@
       closing_event_time_(base::TimeDelta()),
       got_deleted_(NULL),
       drag_and_drop_item_pinned_(false),
       drag_and_drop_shelf_id_(0),
       dragged_off_shelf_(false),
       snap_back_from_rip_off_view_(NULL),
       item_manager_(Shell::GetInstance()->shelf_item_delegate_manager()),
       layout_manager_(manager),
       overflow_mode_(false),
       main_shelf_(NULL),
-      dragged_off_from_overflow_to_shelf_(false) {
+      dragged_off_from_overflow_to_shelf_(false),
+      is_repost_event_(false),
+      last_index_at_repost_(-1) {
   DCHECK(model_);
   bounds_animator_.reset(new views::BoundsAnimator(this));
   bounds_animator_->AddObserver(this);
   set_context_menu_controller(this);
   focus_search_.reset(new ShelfFocusSearch(view_model_.get()));
   tooltip_.reset(new ShelfTooltipManager(manager, this));
 }
 
 ShelfView::~ShelfView() {
   bounds_animator_->RemoveObserver(this);
@@ skipping 1161 matching lines @@
 
   int index = view_model_->GetIndexOfView(view);
   if (index == -1)
     return;
 
   ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
       model_->items()[index].id);
   if (view_model_->view_size() <= 1 || !item_delegate->IsDraggable())
     return;  // View is being deleted or not draggable, ignore request.
 
+  if (IsRepostEvent(event))
+    is_repost_event_ = true;

[Mr4D (OOO till 08-26), 2014/12/05 20:57:13]

As stated above: You might want to do

is_repost_event_ = IsRepostEvent(event) &&
                   index == last_pressed_index_;

here.

+
   CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
   drag_view_ = static_cast<ShelfButton*>(view);
   drag_origin_ = gfx::Point(event.x(), event.y());
   UMA_HISTOGRAM_ENUMERATION("Ash.ShelfAlignmentUsage",
       layout_manager_->SelectValueForShelfAlignment(
           SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM,
           SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT,
           SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT,
           -1),
       SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT);
@@ skipping 72 matching lines @@
   if (sender == overflow_button_) {
     ToggleOverflowBubble();
     return;
   }
 
   int view_index = view_model_->GetIndexOfView(sender);
   // May be -1 while in the process of animating closed.
   if (view_index == -1)
     return;
 
-  // If the previous menu was closed by the same event as this one, we ignore
-  // the call.
-  if (!IsUsableEvent(event))
+  // If the menu was just closed by the same event as this one, we ignore
+  // the call and don't open the menu again. See crbug.com/343005 for more
+  // detail.
+  if (is_repost_event_ && (view_index == last_index_at_repost_)) {

[Mr4D (OOO till 08-26), 2014/12/05 20:57:13]

line 1674 - 1683 could then be replaced with this:
 
if (is_repost_event_) 
  return;

last_pressed_index_ = view_index;

+    is_repost_event_ = false;
     return;
+  }
+
+  // Reset the |is_repost_event_ | to false and record the
+  // |last_index_at_repost_|.
+  is_repost_event_ = false;
+  last_index_at_repost_ = view_index;
 
   // Don't activate the item twice on double-click. Otherwise the window starts
   // animating open due to the first click, then immediately minimizes due to
   // the second click. The user most likely intended to open or minimize the
   // item once, not do both.
   if (event.flags() & ui::EF_IS_DOUBLE_CLICK)
     return;
 
   {
     ScopedTargetRootWindow scoped_target(
@@ skipping 190 matching lines @@
           ShelfButton* button = static_cast<ShelfButton*>(view);
           button->ClearState(ShelfButton::STATE_HIDDEN);
           break;
         }
       }
       snap_back_from_rip_off_view_ = NULL;
     }
   }
 }
 
-bool ShelfView::IsUsableEvent(const ui::Event& event) {
+bool ShelfView::IsRepostEvent(const ui::Event& event) {
   if (closing_event_time_ == base::TimeDelta())
-    return true;
+    return false;
 
   base::TimeDelta delta =
       base::TimeDelta(event.time_stamp() - closing_event_time_);
   closing_event_time_ = base::TimeDelta();
-  // TODO(skuhne): This time seems excessive, but it appears that the reposting
-  // takes that long.  Need to come up with a better way of doing this.
-  return (delta.InMilliseconds() < 0 || delta.InMilliseconds() > 130);
+  // If the current (press down) event is a repost event, the time stamp of
+  // these two events should be the same.
+  return (delta.InMilliseconds() == 0);
 }
 
 const ShelfItem* ShelfView::ShelfItemForView(const views::View* view) const {
   int view_index = view_model_->GetIndexOfView(view);
   if (view_index == -1)
     return NULL;
   return &(model_->items()[view_index]);
 }
 
 bool ShelfView::ShouldShowTooltipForView(const views::View* view) const {
@@ skipping 25 matching lines @@
       distance = bounds.x() - coordinate.x();
       break;
     case SHELF_ALIGNMENT_TOP:
       distance = coordinate.y() - bounds.bottom();
       break;
   }
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash