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 346 matching lines @@
   // If there are multiple matches this is the index of the item after the
   // currently selected item whose mnemonic matches. This may remain -1 even
   // though there are matches.
   int next_match;
 };
 
 // MenuController:State ------------------------------------------------------
 
 MenuController::State::State()
     : item(NULL),
+      hot_button(NULL),

[sky, 2016/03/23 21:42:40]

nullptr (feel free to change NULL on the previous line too).

[varkha, 2016/03/24 18:36:18]

Done.

       submenu_open(false),
       anchor(MENU_ANCHOR_TOPLEFT),
       context_menu(false) {
 }
 
 MenuController::State::State(const State& other) = default;
 
 MenuController::State::~State() {}
 
 // MenuController ------------------------------------------------------------
@@ skipping 40 matching lines @@
       }
     }
   }
 
   bool nested_menu = showing_;
   if (showing_) {
     // Only support nesting of blocking_run menus, nesting of
     // blocking/non-blocking shouldn't be needed.
     DCHECK(blocking_run_);
 
+    state_.hot_button = pending_state_.hot_button;
     // We're already showing, push the current state.
     menu_stack_.push_back(
         std::make_pair(state_, make_linked_ptr(pressed_lock_.release())));
 
     // The context menu should be owned by the same parent.
     DCHECK_EQ(owner_, parent);
   } else {
     showing_ = true;
 
 #if defined(USE_AURA)
@@ skipping 114 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);
+    if (pending_state_.hot_button != button)
+      SetHotTrackedButton(button);
 
     // 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 178 matching lines @@
 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)
+    if (pending_state_.hot_button && pending_state_.hot_button != button)
       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());
@@ skipping 55 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;
+    // Update |pending_state_.hot_button| if it gets removed while a menu is up.
+    if (details.child == pending_state_.hot_button)
+      pending_state_.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 459 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 787 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);
+      DCHECK_EQ(pending_state_.hot_button, button);
       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);
       return;
@@ skipping 443 matching lines @@
       SetSelection(nullptr, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
 
       // Set exit_all_, which makes sure all nested loops exit immediately.
       if (exit_type_ != EXIT_DESTROYED)
         SetExitType(EXIT_ALL);
     } else {
       TerminateNestedMessageLoopIfNecessary();
     }
   }
 
-  // Reset our pressed lock to the previous state's, if there was one.
-  // The lock handles the case if the button was destroyed.
+  // Reset our pressed lock and hot-tracked state to the previous state's, if
+  // they were active. The lock handles the case if the button was destroyed.
   pressed_lock_.reset(nested_pressed_lock.release());
+  if (pending_state_.hot_button)
+    pending_state_.hot_button->SetHotTracked(true);
 
   return result;
 }
 
 void MenuController::HandleMouseLocation(SubmenuView* source,
                                          const gfx::Point& mouse_location) {
   if (showing_submenu_)
     return;
 
   // Ignore mouse events if we're closing the menu.
@@ skipping 28 matching lines @@
     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_) {
+  if (hot_button == pending_state_.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 (pending_state_.hot_button)
+    pending_state_.hot_button->SetHotTracked(false);
+  pending_state_.hot_button = hot_button;
   if (hot_button)
     hot_button->SetHotTracked(true);
 }
 
 }  // namespace views