Keep reference view pressed while extension actions have a popup

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/strings/utf_string_conversions.h"
 #include "base/time/time.h"
@@ skipping 307 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_);
 
     // We're already showing, push the current state.
-    menu_stack_.push_back(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;
   }
 
   // Reset current state.
   pending_state_ = State();
   state_ = State();
@@ skipping 11 matching lines @@
   if (!blocking_run_) {
     if (!is_nested_drag) {
       // Start the timer to hide the menu. This is needed as we get no
       // notification when the drag has finished.
       StartCancelAllTimer();
     }
     return NULL;
   }
 
   if (button)
-    menu_button_ = button;
+    pressed_lock_.reset(new MenuButton::PressedLock(button));
 
   // Make sure Chrome doesn't attempt to shut down while the menu is showing.
   if (ViewsDelegate::views_delegate)
     ViewsDelegate::views_delegate->AddRef();
 
   // We need to turn on nestable tasks as in some situations (pressing alt-f for
   // one) the menus are run from a task. If we don't do this and are invoked
   // from a task none of the tasks we schedule are processed and the menu
   // appears totally broken.
   message_loop_depth_++;
@@ skipping 21 matching lines @@
     ::GetCursorPos(&cursor_pos);
      HWND window = ::WindowFromPoint(cursor_pos);
      if (::GetWindowThreadProcessId(window, NULL) ==
                                     ::GetCurrentThreadId()) {
        ::SetProp(window, ui::kIgnoreTouchMouseActivateForWindow,
                  reinterpret_cast<HANDLE>(true));
      }
   }
 #endif
 
+  linked_ptr<MenuButton::PressedLock> nested_pressed_lock;
   if (nested_menu) {
     DCHECK(!menu_stack_.empty());
     // We're running from within a menu, restore the previous state.
     // The menus are already showing, so we don't have to show them.
-    state_ = menu_stack_.back();
-    pending_state_ = menu_stack_.back();
+    state_ = menu_stack_.back().first;
+    pending_state_ = menu_stack_.back().first;
+    nested_pressed_lock = menu_stack_.back().second;
     menu_stack_.pop_back();
   } else {
     showing_ = false;
     did_capture_ = false;
   }
 
   MenuItemView* result = result_;
   // In case we're nested, reset result_.
   result_ = NULL;
 
   if (result_event_flags)
     *result_event_flags = accept_event_flags_;
 
   if (exit_type_ == EXIT_OUTERMOST) {
     SetExitType(EXIT_NONE);
   } else {
     if (nested_menu && result) {
       // We're nested and about to return a value. The caller might enter
       // another blocking loop. We need to make sure all menus are hidden
       // before that happens otherwise the menus will stay on screen.
       CloseAllNestedMenus();
       SetSelection(NULL, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
 
       // Set exit_all_, which makes sure all nested loops exit immediately.
       if (exit_type_ != EXIT_DESTROYED)
         SetExitType(EXIT_ALL);
     }
   }
 
-  // If we stopped running because one of the menus was destroyed chances are
-  // the button was also destroyed.
-  if (exit_type_ != EXIT_DESTROYED && menu_button_) {
-    menu_button_->SetState(CustomButton::STATE_NORMAL);
-    menu_button_->SchedulePaint();
-  }
+  // Reset our pressed lock to the previous state's, if there was one.
+  // The lock handles the case if the button was destroyed.
+  pressed_lock_.reset(nested_pressed_lock.release());
+
   return result;
 }
 
 void MenuController::Cancel(ExitType type) {
   // If the menu has already been destroyed, no further cancellation is
   // needed.  We especially don't want to set the |exit_type_| to a lesser
   // value.
   if (exit_type_ == EXIT_DESTROYED || exit_type_ == type)
     return;
 
@@ skipping 473 matching lines @@
 #endif
 
     // And close.
     ExitType exit_type = EXIT_ALL;
     if (!menu_stack_.empty()) {
       // We're running nested menus. Only exit all if the mouse wasn't over one
       // of the menus from the last run.
       gfx::Point screen_loc(event.location());
       View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
       MenuPart last_part = GetMenuPartByScreenCoordinateUsingMenu(
-          menu_stack_.back().item, screen_loc);
+          menu_stack_.back().first.item, screen_loc);
       if (last_part.type != MenuPart::NONE)
         exit_type = EXIT_OUTERMOST;
     }
     Cancel(exit_type);
 
 #if defined(OS_CHROMEOS)
     // We're going to exit the menu and want to repost the event so that is
     // is handled normally after the context menu has exited. We call
     // RepostEvent after Cancel so that mouse capture has been released so
     // that finding the event target is unaffected by the current capture.
@@ skipping 138 matching lines @@
       accept_event_flags_(0),
       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),
-      menu_button_(NULL),
       active_mouse_view_id_(ViewStorage::GetInstance()->CreateStorageID()),
       delegate_(delegate),
       message_loop_depth_(0),
       menu_config_(theme),
       closing_event_time_(base::TimeDelta()),
       menu_start_time_(base::TimeTicks()),
       is_combobox_(false),
       item_selected_by_touch_(false),
       message_loop_(MenuMessageLoop::Create()) {
   active_instance_ = this;
@@ skipping 70 matching lines @@
       !item->GetDelegate()->ShouldCloseAllMenusOnExecute(item->GetCommand())) {
     SetExitType(EXIT_OUTERMOST);
   } else {
     SetExitType(EXIT_ALL);
   }
   accept_event_flags_ = event_flags;
 }
 
 bool MenuController::ShowSiblingMenu(SubmenuView* source,
                                      const gfx::Point& mouse_location) {
-  if (!menu_stack_.empty() || !menu_button_)
+  if (!menu_stack_.empty() || !pressed_lock_.get())
     return false;
 
   View* source_view = source->GetScrollViewContainer();
   if (mouse_location.x() >= 0 &&
       mouse_location.x() < source_view->width() &&
       mouse_location.y() >= 0 &&
       mouse_location.y() < source_view->height()) {
     // The mouse is over the menu, no need to continue.
     return false;
   }
@@ skipping 19 matching lines @@
   delegate_->SiblingMenuCreated(alt_menu);
 
   if (!button) {
     // If the delegate returns a menu, they must also return a button.
     NOTREACHED();
     return false;
   }
 
   // There is a sibling menu, update the button state, hide the current menu
   // and show the new one.
-  menu_button_->SetState(CustomButton::STATE_NORMAL);
-  menu_button_->SchedulePaint();
-  menu_button_ = button;
-  menu_button_->SetState(CustomButton::STATE_PRESSED);
-  menu_button_->SchedulePaint();
+  pressed_lock_.reset(new MenuButton::PressedLock(button));
 
   // Need to reset capture when we show the menu again, otherwise we aren't
   // going to get any events.
   did_capture_ = false;
   gfx::Point screen_menu_loc;
   View::ConvertPointToScreen(button, &screen_menu_loc);
 
   // It is currently not possible to show a submenu recursively in a bubble.
   DCHECK(!MenuItemView::IsBubble(anchor));
   // Subtract 1 from the height to make the popup flush with the button border.
@@ skipping 23 matching lines @@
 
   if (menu_item->GetDelegate()->ShowContextMenu(
           menu_item, menu_item->GetCommand(), loc, source_type)) {
     SendMouseCaptureLostToActiveView();
     return true;
   }
   return false;
 }
 
 void MenuController::CloseAllNestedMenus() {
-  for (std::list<State>::iterator i = menu_stack_.begin();
+  for (std::list<NestedState>::iterator i = menu_stack_.begin();
        i != menu_stack_.end(); ++i) {
-    MenuItemView* last_item = i->item;
+    State& state = i->first;
+    MenuItemView* last_item = state.item;
     for (MenuItemView* item = last_item; item;
          item = item->GetParentMenuItem()) {
       CloseMenu(item);
       last_item = item;
     }
-    i->submenu_open = false;
-    i->item = last_item;
+    state.submenu_open = false;
+    state.item = last_item;
   }
 }
 
 MenuItemView* MenuController::GetMenuItemAt(View* source, int x, int y) {
   // Walk the view hierarchy until we find a menu item (or the root).
   View* child_under_mouse = source->GetEventHandlerForPoint(gfx::Point(x, y));
   while (child_under_mouse &&
          child_under_mouse->id() != MenuItemView::kMenuItemViewID) {
     child_under_mouse = child_under_mouse->parent();
   }
@@ skipping 1015 matching lines @@
   }
 }
 
 gfx::Screen* MenuController::GetScreen() {
   Widget* root = owner_ ? owner_->GetTopLevelWidget() : NULL;
   return root ? gfx::Screen::GetScreenFor(root->GetNativeView())
               : gfx::Screen::GetNativeScreen();
 }
 
 }  // namespace views