Fixes alternating keyboard and mouse hot-tracking in menus

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 551 matching lines @@
     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;
       }
 
       // ...and we always return the result of the current handler.
       if (current_mouse_event_target_)
         return processed;

[sky, 2016/02/29 16:33:32]

Do you need to update this branch to change the selection too?

[varkha, 2016/02/29 19:09:44]

Done. I could not see how another button could have acquired a HOVERED state
here but I can see how another button could get pressed or we should update
selection so that no button appears hot-tracked. This is why I think I need to
update (reset) hot-tracked state above if a view under mouse pointer is not 
equal to hot_tracked_.
Similar change done in OnGestureEvent() as well.

     }
   }
 
   // Otherwise, the menu handles this click directly.
   SetSelectionOnPointerDown(source, &event);
   return true;
 }
 
 bool MenuController::OnMouseDragged(SubmenuView* source,
                                     const ui::MouseEvent& event) {
@@ skipping 125 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);
-  // TODO(varkha): It is possible that another child CustomButton has become
-  // hot-tracked as a result of this event. We need to track it for accurate
-  // hot-tracking when both mouse and keyboard are used to navigate the menu.
+
+    // 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);
+  }
+
   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,
@@ skipping 63 matching lines @@
 View* MenuController::GetTooltipHandlerForPoint(SubmenuView* source,
                                                 const gfx::Point& point) {
   MenuHostRootView* root_view = GetRootView(source, point);
   return root_view ? root_view->ProcessGetTooltipHandlerForPoint(point)
                    : nullptr;
 }
 
 void MenuController::ViewHierarchyChanged(
     SubmenuView* source,
     const View::ViewHierarchyChangedDetails& details) {
-  // If the current mouse handler is removed, remove it as the handler.
-  if (!details.is_add && details.child == current_mouse_event_target_) {
-    current_mouse_event_target_ = nullptr;
-    current_mouse_pressed_state_ = 0;
+  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 deleted while a menu is up.

[sky, 2016/02/29 16:33:32]

deleted->removed

[varkha, 2016/02/29 19:09:44]

Done.

+    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 208 matching lines @@
   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) {
     CustomButton* button = GetFirstHotTrackedView(pending_state_.item);

[sky, 2016/02/29 16:33:32]

It doesn't seem necessary to call this anymore. Can't you just
SetHotTrackedButton(nullptr)?

[varkha, 2016/02/29 19:09:44]

Here, yes. Done.

-    if (button)
-      button->SetHotTracked(false);
+    if (button) {
+      DCHECK_EQ(hot_button_, button);
+      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]);
     }
@@ skipping 231 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()) {
@@ skipping 16 matching lines @@
 }
 
 bool MenuController::SendAcceleratorToHotTrackedView() {
   CustomButton* hot_view = GetFirstHotTrackedView(pending_state_.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);
-  button->SetHotTracked(true);
+  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) {
-      button->SetHotTracked(false);
+      DCHECK_EQ(hot_button_, button);
+      SetHotTrackedButton(nullptr);
       View* to_make_hot = GetNextFocusableView(
           item, button, direction == INCREMENT_SELECTION_DOWN);
       CustomButton* button_hot = CustomButton::AsCustomButton(to_make_hot);
       if (button_hot) {
-        button_hot->SetHotTracked(true);
+        SetHotTrackedButton(button_hot);
         return;
       }
     } else {
       View* to_make_hot =
           GetInitialFocusableView(item, direction == INCREMENT_SELECTION_DOWN);
       CustomButton* button_hot = CustomButton::AsCustomButton(to_make_hot);
       if (button_hot) {
-        button_hot->SetHotTracked(true);
+        SetHotTrackedButton(button_hot);
         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) {
@@ skipping 483 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);
-  CustomButton* hot_button = CustomButton::AsCustomButton(hot_view);
+  SetHotTrackedButton(CustomButton::AsCustomButton(hot_view));
+}
+
+void MenuController::SetHotTrackedButton(CustomButton* hot_button) {
+  if (hot_button == hot_button_)
+    return;
+  if (hot_button_)
+    hot_button_->SetHotTracked(false);
+  hot_button_ = hot_button;
   if (hot_button)
     hot_button->SetHotTracked(true);
 }
 
 }  // namespace views