Fixes incorrect clearing of hot-tracked state when context menu is opened from a menu item

ui/views/controls/menu/menu_controller.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 "ui/views/controls/menu/menu_controller.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 540 matching lines @@
 
   current_mouse_pressed_state_ |= event.changed_button_flags();
 
   if (forward_to_root) {
     ui::MouseEvent event_for_root(event);
     // Reset hot-tracking if a different view is getting a mouse press.
     ConvertLocatedEventForRootView(source, forward_to_root, &event_for_root);
     View* view =
         forward_to_root->GetEventHandlerForPoint(event_for_root.location());
     CustomButton* button = CustomButton::AsCustomButton(view);
-    if (hot_button_ && hot_button_ != button)
-      SetHotTrackedButton(nullptr);
+    MenuItemView* item = static_cast<MenuItemView*>(
+        button->GetAncestorWithClassName(MenuItemView::kViewClassName));

[sky, 2016/03/08 16:45:37]

What if button is null?

[varkha, 2016/03/23 21:16:01]

Acknowledged (this is no longer necessary if I don't use menu items for
hot-tracking).

+    if (item && item->hot_button() != button)
+      item->SetHotTrackedButton(nullptr);
 
     // Empty menu items are always handled by the menu controller.
     if (!view || view->id() != MenuItemView::kEmptyMenuItemViewID) {
       bool processed = forward_to_root->ProcessMousePressed(event_for_root);
       // If the event was processed, the root view becomes our current mouse
       // handler...
       if (processed && !current_mouse_event_target_) {
         current_mouse_event_target_ = forward_to_root;
       }
 
@@ skipping 138 matching lines @@
                                   const ui::MouseEvent& event) {
   if (current_mouse_event_target_) {
     ui::MouseEvent event_for_root(event);
     ConvertLocatedEventForRootView(source, current_mouse_event_target_,
                                    &event_for_root);
     current_mouse_event_target_->ProcessMouseMoved(event_for_root);
     return;
   }
 
   MenuHostRootView* root_view = GetRootView(source, event.location());
-  if (root_view) {
+  if (root_view)
     root_view->ProcessMouseMoved(event);
 
+  HandleMouseLocation(source, event.location());
+  if (pending_state_.item && root_view) {
     // Update hot-tracked button when a button state is changed with a mouse
     // event. It is necessary to track it for accurate hot-tracking when both
     // mouse and keyboard are used to navigate the menu.
     ui::MouseEvent event_for_root(event);
     ConvertLocatedEventForRootView(source, root_view, &event_for_root);
     View* view =
         root_view->GetEventHandlerForPoint(event_for_root.location());
     CustomButton* button = CustomButton::AsCustomButton(view);
-    if (button && button->IsHotTracked())
-      SetHotTrackedButton(button);
+    if (button && button->IsHotTracked() &&
+        button->GetAncestorWithClassName(MenuItemView::kViewClassName) ==
+            pending_state_.item) {
+      pending_state_.item->SetHotTrackedButton(button);
+    }
   }
-
-  HandleMouseLocation(source, event.location());
 }
 
 void MenuController::OnMouseEntered(SubmenuView* source,
                                     const ui::MouseEvent& event) {
   // MouseEntered is always followed by a mouse moved, so don't need to
   // do anything here.
 }
 
 bool MenuController::OnMouseWheel(SubmenuView* source,
                                   const ui::MouseWheelEvent& event) {
   MenuPart part = GetMenuPart(source, event.location());
   return part.submenu && part.submenu->OnMouseWheel(event);
 }
 
 void MenuController::OnGestureEvent(SubmenuView* source,
                                     ui::GestureEvent* event) {
   MenuHostRootView* root_view = GetRootView(source, event->location());
   if (root_view) {
     // Reset hot-tracking if a different view is getting a touch event.
     ui::GestureEvent event_for_root(*event);
     ConvertLocatedEventForRootView(source, root_view, &event_for_root);
     View* view =
         root_view->GetEventHandlerForPoint(event_for_root.location());
     CustomButton* button = CustomButton::AsCustomButton(view);
-    if (hot_button_ && hot_button_ != button)
-      SetHotTrackedButton(nullptr);
+    MenuItemView* item = static_cast<MenuItemView*>(
+        button->GetAncestorWithClassName(MenuItemView::kViewClassName));
+    if (item && item->hot_button() != button)
+      item->SetHotTrackedButton(nullptr);
   }
 
   MenuPart part = GetMenuPart(source, event->location());
   if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
     SetSelectionOnPointerDown(source, event);
     event->StopPropagation();
   } else if (event->type() == ui::ET_GESTURE_LONG_PRESS) {
     if (part.type == MenuPart::MENU_ITEM && part.menu) {
       gfx::Point screen_location(event->location());
       View::ConvertPointToScreen(source->GetScrollViewContainer(),
@@ skipping 54 matching lines @@
 
 void MenuController::ViewHierarchyChanged(
     SubmenuView* source,
     const View::ViewHierarchyChangedDetails& details) {
   if (!details.is_add) {
     // If the current mouse handler is removed, remove it as the handler.
     if (details.child == current_mouse_event_target_) {
       current_mouse_event_target_ = nullptr;
       current_mouse_pressed_state_ = 0;
     }
-    // Update |hot_button_| if it gets removed while a menu is up.
-    if (details.child == hot_button_)
-      hot_button_ = nullptr;
   }
 }
 
 bool MenuController::GetDropFormats(
       SubmenuView* source,
       int* formats,
       std::set<ui::Clipboard::FormatType>* format_types) {
   return source->GetMenuItem()->GetDelegate()->GetDropFormats(
       source->GetMenuItem(), formats, format_types);
 }
@@ skipping 207 matching lines @@
   size_t paths_differ_at = 0;
   std::vector<MenuItemView*> current_path;
   std::vector<MenuItemView*> new_path;
   BuildPathsAndCalculateDiff(pending_state_.item, menu_item, &current_path,
                              &new_path, &paths_differ_at);
 
   size_t current_size = current_path.size();
   size_t new_size = new_path.size();
 
   bool pending_item_changed = pending_state_.item != menu_item;
-  if (pending_item_changed && pending_state_.item)
-    SetHotTrackedButton(nullptr);
 
   // Notify the old path it isn't selected.
   MenuDelegate* current_delegate =
       current_path.empty() ? NULL : current_path.front()->GetDelegate();
   for (size_t i = paths_differ_at; i < current_size; ++i) {
     if (current_delegate &&
         current_path[i]->GetType() == MenuItemView::SUBMENU) {
       current_delegate->WillHideMenu(current_path[i]);
     }
     current_path[i]->SetSelected(false);
@@ skipping 230 matching lines @@
       drop_target_(NULL),
       drop_position_(MenuDelegate::DROP_UNKNOWN),
       owner_(NULL),
       possible_drag_(false),
       drag_in_progress_(false),
       did_initiate_drag_(false),
       valid_drop_coordinates_(false),
       last_drop_operation_(MenuDelegate::DROP_UNKNOWN),
       showing_submenu_(false),
       active_mouse_view_id_(ViewStorage::GetInstance()->CreateStorageID()),
-      hot_button_(nullptr),
       delegate_(delegate),
       message_loop_depth_(0),
       closing_event_time_(base::TimeDelta()),
       menu_start_time_(base::TimeTicks()),
       async_run_(false),
       is_combobox_(false),
       item_selected_by_touch_(false),
       current_mouse_event_target_(nullptr),
       current_mouse_pressed_state_(0),
       message_loop_(MenuMessageLoop::Create()) {
   delegate_stack_.push_back(std::make_pair(delegate_, async_run_));
   active_instance_ = this;
 }
 
 MenuController::~MenuController() {
   DCHECK(!showing_);
   if (owner_)
     owner_->RemoveObserver(this);
   if (active_instance_ == this)
     active_instance_ = NULL;
   StopShowTimer();
   StopCancelAllTimer();
 }
 
 void MenuController::RunMessageLoop(bool nested_menu) {
   message_loop_->Run(this, owner_, nested_menu);
 }
 
 bool MenuController::SendAcceleratorToHotTrackedView() {
-  CustomButton* hot_view = GetFirstHotTrackedView(pending_state_.item);
+  MenuItemView* item = pending_state_.item;
+  CustomButton* hot_view = GetFirstHotTrackedView(item);
   if (!hot_view)
     return false;
-
   ui::Accelerator accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   hot_view->AcceleratorPressed(accelerator);
   CustomButton* button = static_cast<CustomButton*>(hot_view);
-  SetHotTrackedButton(button);
+  item->SetHotTrackedButton(button);
   return true;
 }
 
 void MenuController::UpdateInitialLocation(const gfx::Rect& bounds,
                                            MenuAnchorPosition position,
                                            bool context_menu) {
   pending_state_.context_menu = context_menu;
   pending_state_.initial_bounds = bounds;
   if (bounds.height() > 1) {
     // Inset the bounds slightly, otherwise drag coordinates don't line up
@@ skipping 749 matching lines @@
     if (item->GetSubmenu()->GetMenuItemCount()) {
       MenuItemView* to_select = FindInitialSelectableMenuItem(item, direction);
       SetInitialHotTrackedView(to_select, direction);
       return;
     }
   }
 
   if (item->has_children()) {
     CustomButton* button = GetFirstHotTrackedView(item);
     if (button) {
-      DCHECK_EQ(hot_button_, button);
-      SetHotTrackedButton(nullptr);
+      DCHECK_EQ(item->hot_button(), button);
+      item->SetHotTrackedButton(nullptr);
     }
     bool direction_is_down = direction == INCREMENT_SELECTION_DOWN;
     View* to_make_hot = button
         ? GetNextFocusableView(item, button, direction_is_down)
         : GetInitialFocusableView(item, direction_is_down);
     CustomButton* hot_button = CustomButton::AsCustomButton(to_make_hot);
     if (hot_button) {
-      SetHotTrackedButton(hot_button);
+      item->SetHotTrackedButton(hot_button);
       return;
     }
   }
 
   MenuItemView* parent = item->GetParentMenuItem();
   if (parent) {
     int parent_count = parent->GetSubmenu()->GetMenuItemCount();
     if (parent_count > 1) {
       for (int i = 0; i < parent_count; ++i) {
         if (parent->GetSubmenu()->GetMenuItemAt(i) == item) {
@@ skipping 481 matching lines @@
 }
 
 void MenuController::SetInitialHotTrackedView(
     MenuItemView* item,
     SelectionIncrementDirectionType direction) {
   if (!item)
     return;
   SetSelection(item, SELECTION_DEFAULT);
   View* hot_view =
       GetInitialFocusableView(item, direction == INCREMENT_SELECTION_DOWN);
-  SetHotTrackedButton(CustomButton::AsCustomButton(hot_view));
-}
-
-void MenuController::SetHotTrackedButton(CustomButton* hot_button) {
-  if (hot_button == hot_button_) {
-    // Hot-tracked state may change outside of the MenuController. Correct it.
-    if (hot_button && !hot_button->IsHotTracked())
-      hot_button->SetHotTracked(true);
-    return;
-  }
-  if (hot_button_)
-    hot_button_->SetHotTracked(false);
-  hot_button_ = hot_button;
-  if (hot_button)
-    hot_button->SetHotTracked(true);
+  item->SetHotTrackedButton(CustomButton::AsCustomButton(hot_view));
 }
 
 }  // namespace views