Send fake event when event_type is set to exit menu

views/controls/menu/menu_controller.cc

 // Copyright (c) 2011 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 "views/controls/menu/menu_controller.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/events.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/screen.h"
 #include "views/controls/button/menu_button.h"
 #include "views/controls/menu/menu_controller_delegate.h"
 #include "views/controls/menu/menu_scroll_view_container.h"
 #include "views/controls/menu/submenu_view.h"
 #include "views/drag_utils.h"
 #include "views/view_constants.h"
 #include "views/views_delegate.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget.h"
 
-#if defined(USE_AURA) && !defined(OS_WIN)
+#if defined(USE_AURA)
 #include "ui/aura/desktop.h"
 #endif
 
-#if defined(OS_LINUX)
+#if defined(TOOLKIT_USES_GTK)
 #include "ui/base/keycodes/keyboard_code_conversion_gtk.h"
 #endif
 
 #if defined(TOUCH_UI)
 #include "views/focus/accelerator_handler.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using ui::OSExchangeData;
@@ skipping 299 matching lines @@
   }
 
   MenuItemView* result = result_;
   // In case we're nested, reset result_.
   result_ = NULL;
 
   if (result_mouse_event_flags)
     *result_mouse_event_flags = result_mouse_event_flags_;
 
   if (exit_type_ == EXIT_OUTERMOST) {
-    exit_type_ = EXIT_NONE;
+    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)
-        exit_type_ = EXIT_ALL;
+        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::BS_NORMAL);
     menu_button_->SchedulePaint();
   }
 
   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;
 
   if (!showing_) {
     // This occurs if we're in the process of notifying the delegate for a drop
     // and the delegate cancels us.
     return;
   }
 
   MenuItemView* selected = state_.item;
-  exit_type_ = type;
+  SetExitType(type);
 
   SendMouseCaptureLostToActiveView();
 
   // Hide windows immediately.
   SetSelection(NULL, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
 
   if (!blocking_run_) {
     // If we didn't block the caller we need to notify the menu, which
     // triggers deleting us.
     DCHECK(selected);
@@ skipping 18 matching lines @@
     return;  // Ignore presses on scroll buttons.
 
   if (part.type == MenuPart::NONE ||
       (part.type == MenuPart::MENU_ITEM && part.menu &&
        part.menu->GetRootMenuItem() != state_.item->GetRootMenuItem())) {
     // Mouse wasn't pressed over any menu, or the active menu, cancel.
 
     // We're going to close and we own the mouse capture. We need to repost the
     // mouse down, otherwise the window the user clicked on won't get the
     // event.
-#if defined(OS_WIN)
+#if defined(OS_WIN) && !defined(USE_AURA)
     RepostEvent(source, event);
     // NOTE: not reposting on linux seems fine.
 #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());
@@ skipping 273 matching lines @@
 
   MenuItemView* drop_target = drop_target_;
   MenuDelegate::DropPosition drop_position = drop_position_;
 
   // Close all menus, including any nested menus.
   SetSelection(NULL, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
   CloseAllNestedMenus();
 
   // Set state such that we exit.
   showing_ = false;
-  exit_type_ = EXIT_ALL;
+  SetExitType(EXIT_ALL);
 
   // If over an empty menu item, drop occurs on the parent.
   if (drop_target->id() == MenuItemView::kEmptyMenuItemViewID)
     drop_target = drop_target->GetParentMenuItem();
 
   if (!IsBlockingRun()) {
     delegate_->DropMenuClosed(
         internal::MenuControllerDelegate::DONT_NOTIFY_DELEGATE,
         item->GetRootMenuItem());
   }
@@ skipping 360 matching lines @@
   // avoid repeated system queries for the info.
   pending_state_.monitor_bounds = gfx::Screen::GetMonitorWorkAreaNearestPoint(
       bounds.origin());
 }
 
 void MenuController::Accept(MenuItemView* item, int mouse_event_flags) {
   DCHECK(IsBlockingRun());
   result_ = item;
   if (item && !menu_stack_.empty() &&
       !item->GetDelegate()->ShouldCloseAllMenusOnExecute(item->GetCommand())) {
-    exit_type_ = EXIT_OUTERMOST;
+    SetExitType(EXIT_OUTERMOST);
   } else {
-    exit_type_ = EXIT_ALL;
+    SetExitType(EXIT_ALL);
   }
   result_mouse_event_flags_ = mouse_event_flags;
 }
 
 bool MenuController::ShowSiblingMenu(SubmenuView* source,
                                      const MouseEvent& event) {
   if (!menu_stack_.empty() || !menu_button_)
     return false;
 
   View* source_view = source->GetScrollViewContainer();
@@ skipping 658 matching lines @@
   }
 
   // If no mnemonics found, look at first character of titles.
   details = FindChildForMnemonic(item, key, &TitleMatchesMnemonic);
   if (details.first_match != -1)
     return AcceptOrSelect(item, details);
 
   return false;
 }
 
-#if defined(OS_WIN)
-#if defined(USE_AURA)
-void MenuController::RepostEvent(SubmenuView* source,
-                                 const MouseEvent& event) {
-}
-#else
+#if defined(OS_WIN) && !defined(USE_AURA)
 void MenuController::RepostEvent(SubmenuView* source,
                                  const MouseEvent& event) {
   if (!state_.item) {
     // We some times get an event after closing all the menus. Ignore it.
     // Make sure the menu is in fact not visible. If the menu is visible, then
     // we're in a bad state where we think the menu isn't visibile but it is.
     DCHECK(!source->GetWidget()->IsVisible());
     return;
   }
 
@@ skipping 46 matching lines @@
       if (in_client_area) {
         PostMessage(window, event_type, event.native_event().wParam,
                     MAKELPARAM(window_x, window_y));
       } else {
         PostMessage(window, event_type, nc_hit_result,
                     MAKELPARAM(screen_loc.x(), screen_loc.y()));
       }
     }
   }
 }
-#endif  // !defined(USE_AURA)
 #endif  // defined(OS_WIN)
 
 void MenuController::SetDropMenuItem(
     MenuItemView* new_target,
     MenuDelegate::DropPosition new_position) {
   if (new_target == drop_target_ && new_position == drop_position_)
     return;
 
   if (drop_target_) {
     drop_target_->GetParentMenuItem()->GetSubmenu()->SetDropMenuItem(
@@ skipping 86 matching lines @@
   if (!active_mouse_view_)
     return;
 
   // Reset the active_mouse_view_ before sending mouse capture lost. That way if
   // it calls back to us, we aren't in a weird state.
   View* active_view = active_mouse_view_;
   active_mouse_view_ = NULL;
   active_view->OnMouseCaptureLost();
 }
 
+void MenuController::SetExitType(ExitType type) {
+  exit_type_ = type;
+#if defined(USE_AURA)
+  // On aura, closing menu may not trigger next native event, which
+  // is necessary to exit from nested loop (See Dispatch methods).
+  // Send non-op event so that Dispatch method will always be called.
+  // crbug.com/104684.
+  if (exit_type_ == EXIT_ALL || exit_type_ == EXIT_DESTROYED)
+    aura::Desktop::GetInstance()->PostNativeEvent(ui::CreateNoopEvent());
+#endif
+}
+
+
 }  // namespace views