Delete MenuController Nested Message Loop

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"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/menu/menu_config.h"
 #include "ui/views/controls/menu/menu_controller_delegate.h"
 #include "ui/views/controls/menu/menu_host_root_view.h"
 #include "ui/views/controls/menu/menu_item_view.h"
-#include "ui/views/controls/menu/menu_message_loop.h"
 #include "ui/views/controls/menu/menu_scroll_view_container.h"
 #include "ui/views/controls/menu/submenu_view.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/mouse_constants.h"
 #include "ui/views/view.h"
 #include "ui/views/view_constants.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_WIN)
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/win/internal_constants.h"
 #include "ui/display/win/screen_win.h"
 #include "ui/views/win/hwnd_util.h"
 #endif
 
 #if defined(USE_AURA)
+#include "ui/aura/client/screen_position_client.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_event_dispatcher.h"
+#include "ui/aura/window_tree_host.h"
 #include "ui/views/controls/menu/menu_pre_target_handler.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using ui::OSExchangeData;
 
 namespace views {
 
 namespace {
@@ skipping 184 matching lines @@
     WPARAM target = client_area ? event->native_event().wParam : nc_hit_result;
     LPARAM window_coords = MAKELPARAM(window_x, window_y);
     PostMessage(target_window, event_type, target, window_coords);
     return;
   }
 #endif
   // Non Aura window.
   if (!window)
     return;
 
-  MenuMessageLoop::RepostEventToWindow(event, window, screen_loc);
+#if defined(USE_AURA)
+  aura::Window* root = window->GetRootWindow();
+  aura::client::ScreenPositionClient* spc =
+      aura::client::GetScreenPositionClient(root);
+  if (!spc)
+    return;
+
+  gfx::Point root_loc(screen_loc);
+  spc->ConvertPointFromScreen(root, &root_loc);
+
+  std::unique_ptr<ui::Event> clone = ui::Event::Clone(*event);
+  std::unique_ptr<ui::LocatedEvent> located_event(
+      static_cast<ui::LocatedEvent*>(clone.release()));
+  located_event->set_location(root_loc);
+  located_event->set_root_location(root_loc);
+
+  root->GetHost()->dispatcher()->RepostEvent(located_event.get());
+#endif  // defined(USE_AURA)
 }
 #endif  // defined(OS_WIN) || defined(OS_CHROMEOS)
 
 }  // namespace
 
 // MenuScrollTask --------------------------------------------------------------
 
 // MenuScrollTask is used when the SubmenuView does not all fit on screen and
 // the mouse is over the scroll up/down buttons. MenuScrollTask schedules
 // itself with a RepeatingTimer. When Run is invoked MenuScrollTask scrolls
@@ skipping 199 matching lines @@
     return NULL;
   }
 
   if (button)
     pressed_lock_.reset(new MenuButton::PressedLock(button));
 
   // Make sure Chrome doesn't attempt to shut down while the menu is showing.
   if (ViewsDelegate::GetInstance())
     ViewsDelegate::GetInstance()->AddRef();
 
-  if (async_run_)
-    return nullptr;
-
-  // 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_++;
-  DCHECK_LE(message_loop_depth_, 2);
-  RunMessageLoop();
-  message_loop_depth_--;
-
-  if (ViewsDelegate::GetInstance())
-    ViewsDelegate::GetInstance()->ReleaseRef();
-
-  if (result_event_flags)
-    *result_event_flags = accept_event_flags_;
-
-  // The nested message loop could have been killed externally. Check to see if
-  // there are nested asynchronous menus to shutdown.
-  if (async_run_ && delegate_stack_.size() > 1)
-    ExitAsyncRun();
-
-  return ExitMenuRun();
+  return nullptr;
 }
 
 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_) {
@@ skipping 34 matching lines @@
   // On Windows and Linux the destruction of this menu's Widget leads to the
   // teardown of the platform specific drag-and-drop Widget. Do not shutdown
   // while dragging, leave the Widget hidden until drag-and-drop has completed,
   // at which point all menus will be destroyed.
   if (!drag_in_progress_)
     ExitAsyncRun();
 }
 
 void MenuController::AddNestedDelegate(
     internal::MenuControllerDelegate* delegate) {
-  delegate_stack_.push_back(std::make_pair(delegate, async_run_));
+  delegate_stack_.push_back(delegate);
   delegate_ = delegate;
 }
 
-void MenuController::SetAsyncRun(bool is_async) {
-  delegate_stack_.back().second = is_async;
-  async_run_ = is_async;
-}
-
 bool MenuController::OnMousePressed(SubmenuView* source,
                                     const ui::MouseEvent& event) {
   // We should either have no current_mouse_event_target_, or should have a
   // pressed state stored.
   DCHECK(!current_mouse_event_target_ || current_mouse_pressed_state_);
 
   // Find the root view to check. If any buttons were previously pressed, this
   // is the same root view we've been forwarding to. Otherwise, it's the root
   // view of the target.
   MenuHostRootView* forward_to_root =
@@ skipping 476 matching lines @@
       // We may have been canceled during the drag. If so we still need to fully
       // shutdown.
       ExitAsyncRun();
     }
   }
 }
 
 ui::PostDispatchAction MenuController::OnWillDispatchKeyEvent(
     ui::KeyEvent* event) {
   if (exit_type() == EXIT_ALL || exit_type() == EXIT_DESTROYED) {
-    // If the event has arrived after the menu's exit type had changed but
-    // before its message loop terminated, the event will continue its normal
-    // propagation for the following reason:
-    // If the user accepts a menu item in a nested menu, the menu item action is
-    // run after the base::RunLoop for the innermost menu has quit but before
-    // the base::RunLoop for the outermost menu has quit. If the menu item
-    // action starts a base::RunLoop, the outermost menu's base::RunLoop will
-    // not quit till the action's base::RunLoop ends. IDC_BOOKMARK_BAR_OPEN_ALL
-    // sometimes opens a modal dialog. The modal dialog starts a base::RunLoop
-    // and keeps the base::RunLoop running for the duration of its lifetime.
-    TerminateNestedMessageLoopIfNecessary();
+    // If the event has arrived after the menu's exit type has changed but
+    // before its Widgets have been destroyed, the event will continue its
+    // normal propagation for the following reason:
+    // If the user accepts a menu item in a nested menu, and the menu item
+    // action starts a base::RunLoop; IDC_BOOKMARK_BAR_OPEN_ALL sometimes opens
+    // a modal dialog. The modal dialog starts a base::RunLoop and keeps the
+    // base::RunLoop running for the duration of its lifetime.
     return ui::POST_DISPATCH_PERFORM_DEFAULT;
   }
 
   event->StopPropagation();
 
   if (event->type() == ui::ET_KEY_PRESSED) {
     base::WeakPtr<MenuController> this_ref = AsWeakPtr();
     OnKeyDown(event->key_code());
     // Key events can lead to this being deleted.
     if (!this_ref)
       return ui::POST_DISPATCH_NONE;
 
     // Do not check mnemonics if the Alt or Ctrl modifiers are pressed. For
     // example Ctrl+<T> is an accelerator, but <T> only is a mnemonic.
     const int kKeyFlagsMask = ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN;
     const int flags = event->flags();
     if (exit_type() == EXIT_NONE && (flags & kKeyFlagsMask) == 0) {
       base::char16 c = event->GetCharacter();
       SelectByChar(c);
       // SelectByChar can lead to this being deleted.
       if (!this_ref)
         return ui::POST_DISPATCH_NONE;
     }
   }
 
-  if (!TerminateNestedMessageLoopIfNecessary()) {
-    ui::Accelerator accelerator(*event);
-    ViewsDelegate::ProcessMenuAcceleratorResult result =
-        ViewsDelegate::GetInstance()->ProcessAcceleratorWhileMenuShowing(
-            accelerator);
-    if (result == ViewsDelegate::ProcessMenuAcceleratorResult::CLOSE_MENU)
-      CancelAll();
-  }
+  ui::Accelerator accelerator(*event);
+  ViewsDelegate::ProcessMenuAcceleratorResult result =
+      ViewsDelegate::GetInstance()->ProcessAcceleratorWhileMenuShowing(
+          accelerator);
+  if (result == ViewsDelegate::ProcessMenuAcceleratorResult::CLOSE_MENU)
+    CancelAll();
   return ui::POST_DISPATCH_NONE;
 }
 
 void MenuController::UpdateSubmenuSelection(SubmenuView* submenu) {
   if (submenu->IsShowing()) {
     gfx::Point point = display::Screen::GetScreen()->GetCursorScreenPoint();
     const SubmenuView* root_submenu =
         submenu->GetMenuItem()->GetRootMenuItem()->GetSubmenu();
     View::ConvertPointFromScreen(
         root_submenu->GetWidget()->GetRootView(), &point);
@@ skipping 150 matching lines @@
   drag_utils::SetDragImageOnDataObject(*canvas,
                                        press_loc.OffsetFromOrigin(),
                                        &data);
   StopScrolling();
   int drag_ops = item->GetDelegate()->GetDragOperations(item);
   did_initiate_drag_ = true;
   base::WeakPtr<MenuController> this_ref = AsWeakPtr();
   // TODO(varunjain): Properly determine and send DRAG_EVENT_SOURCE below.
   item->GetWidget()->RunShellDrag(NULL, data, widget_loc, drag_ops,
       ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE);
-  // MenuController may have been deleted if |async_run_| so check before
-  // accessing member variables.
+  // MenuController may have been deleted so check before accessing member
+  // variables.
   if (this_ref)
     did_initiate_drag_ = false;
 }
 
 void MenuController::OnKeyDown(ui::KeyboardCode key_code) {
   // Do not process while performing drag-and-drop
   if (!blocking_run_)
     return;
 
   switch (key_code) {
@@ skipping 113 matching lines @@
       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),
-      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_));
+      current_mouse_pressed_state_(0) {
+  delegate_stack_.push_back(delegate_);
   active_instance_ = this;
 }
 
 MenuController::~MenuController() {
   DCHECK(!showing_);
   if (owner_)
     owner_->RemoveObserver(this);
   if (active_instance_ == this)
     active_instance_ = NULL;
   StopShowTimer();
   StopCancelAllTimer();
 }
 
-void MenuController::RunMessageLoop() {
-  message_loop_->Run();
-}
-
 bool MenuController::SendAcceleratorToHotTrackedView() {
   CustomButton* hot_view = GetFirstHotTrackedView(pending_state_.item);
   if (!hot_view)
     return false;
 
   base::WeakPtr<MenuController> this_ref = AsWeakPtr();
   ui::Accelerator accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   hot_view->AcceleratorPressed(accelerator);
   // An accelerator may have canceled the menu after activation.
   if (this_ref) {
@@ skipping 956 matching lines @@
   gfx::NativeWindow window = nullptr;
   if (native_view) {
     display::Screen* screen = display::Screen::GetScreen();
     window = screen->GetWindowAtScreenPoint(screen_loc);
   }
 #endif
 
 #if defined(OS_WIN)
   if (event->IsMouseEvent() || event->IsTouchEvent()) {
     base::WeakPtr<MenuController> this_ref = AsWeakPtr();
-    bool async_run = async_run_;
     if (state_.item) {
       state_.item->GetRootMenuItem()->GetSubmenu()->ReleaseCapture();
       // We're going to close and we own the event capture. We need to repost
       // the event, otherwise the window the user clicked on won't get the
       // event.
       RepostEventImpl(event, screen_loc, native_view, window);
     } else {
       // 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());
     }
 
     // Reposting the event may have deleted this, if so exit.
-    if (!this_ref) {
-      DCHECK(async_run);
+    if (!this_ref)
       return;
-    }
   }
 #endif
 
   // Determine target to see if a complete or partial close of the menu should
   // occur.
   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.
     MenuPart last_part = GetMenuPartByScreenCoordinateUsingMenu(
@@ skipping 127 matching lines @@
   else
     ViewStorage::GetInstance()->RemoveView(active_mouse_view_id_);
 }
 
 View* MenuController::GetActiveMouseView() {
   return ViewStorage::GetInstance()->RetrieveView(active_mouse_view_id_);
 }
 
 void MenuController::SetExitType(ExitType type) {
   exit_type_ = type;
-  // Exit nested message loops as soon as possible. We do this as
-  // it's entirely possible for a Widget::CloseNow() task to be processed before
-  // the next native message. We quite the nested message loop as soon as
-  // possible to avoid having deleted views classes (such as widgets and
-  // rootviews) on the stack when the nested message loop stops.
-  TerminateNestedMessageLoopIfNecessary();
-}
-
-bool MenuController::TerminateNestedMessageLoopIfNecessary() {
-  // It is necessary to check both |async_run_| and |message_loop_depth_|
-  // because the topmost async menu could be nested in a sync parent menu.
-  bool quit_now = !async_run_ && exit_type_ != EXIT_NONE && message_loop_depth_;
-  if (quit_now)
-    message_loop_->QuitNow();
-  return quit_now;
 }
 
 void MenuController::ExitAsyncRun() {
-  if (!async_run_)
-    return;
   bool nested = delegate_stack_.size() > 1;
   // ExitMenuRun unwinds nested delegates
   internal::MenuControllerDelegate* delegate = delegate_;
   // MenuController may have been deleted when releasing ViewsDelegate ref.
   // However as |delegate| can outlive this, it must still be notified of the
   // menu closing so that it can perform teardown.
   int accept_event_flags = accept_event_flags_;
   base::WeakPtr<MenuController> this_ref = AsWeakPtr();
   MenuItemView* result = ExitMenuRun();
   delegate->OnMenuClosed(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
                          result, accept_event_flags);
   // |delegate| may have deleted this.
   if (this_ref && nested && exit_type_ == EXIT_ALL)
     ExitAsyncRun();
 }
 
 MenuItemView* MenuController::ExitMenuRun() {
   base::WeakPtr<MenuController> this_ref = AsWeakPtr();
 
   // Release the lock which prevents Chrome from shutting down while the menu is
   // showing.
-  if (async_run_ && ViewsDelegate::GetInstance())
+  if (ViewsDelegate::GetInstance())
     ViewsDelegate::GetInstance()->ReleaseRef();
 
   // Releasing the lock can result in Chrome shutting down, deleting this.
   if (!this_ref)
     return nullptr;
 
   // Close any open menus.
   SetSelection(nullptr, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
 
 #if defined(OS_WIN)
@@ skipping 23 matching lines @@
     // 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().first;
     pending_state_ = menu_stack_.back().first;
     hot_button_ = state_.hot_button;
     nested_pressed_lock = std::move(menu_stack_.back().second);
     menu_stack_.pop_back();
     // Even though the menus are nested, there may not be nested delegates.
     if (delegate_stack_.size() > 1) {
       delegate_stack_.pop_back();
-      delegate_ = delegate_stack_.back().first;
-      async_run_ = delegate_stack_.back().second;
+      delegate_ = delegate_stack_.back();
     }
   } else {
 #if defined(USE_AURA)
     menu_pre_target_handler_.reset();
 #endif
 
     showing_ = false;
     did_capture_ = false;
   }
 
   MenuItemView* result = result_;
   // In case we're nested, reset |result_|.
   result_ = nullptr;
 
   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(nullptr, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
+  } 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(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();
-    }
+    // Set exit_all_, which makes sure all nested loops exit immediately.
+    if (exit_type_ != EXIT_DESTROYED)
+      SetExitType(EXIT_ALL);
   }
 
   // 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_ = std::move(nested_pressed_lock);
   if (hot_button_)
     hot_button_->SetHotTracked(true);
 
   return result;
 }
@@ skipping 53 matching lines @@
   if (hot_button_)
     hot_button_->SetHotTracked(false);
   hot_button_ = hot_button;
   if (hot_button) {
     hot_button->SetHotTracked(true);
     hot_button->NotifyAccessibilityEvent(ui::AX_EVENT_SELECTION, true);
   }
 }
 
 }  // namespace views