Remove Nested Message Loop from MenuController

ui/views/controls/menu/menu_controller.h

 // 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.
 
 #ifndef UI_VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_
 #define UI_VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_
 
 #include <stddef.h>
 
 #include <list>
@@ skipping 15 matching lines @@
 #include "ui/views/widget/widget_observer.h"
 
 namespace ui {
 class OSExchangeData;
 }
 namespace views {
 
 class MenuButton;
 class MenuHostRootView;
 class MenuItemView;
-class MenuMessageLoop;
 class MouseEvent;
 class SubmenuView;
 class View;
 
 #if defined(USE_AURA)
 class MenuPreTargetHandler;
 #endif
 
 namespace internal {
 class MenuControllerDelegate;
@@ skipping 69 matching lines @@
   void Cancel(ExitType type);
 
   // An alternative to Cancel(EXIT_ALL) that can be used with a OneShotTimer.
   void CancelAll() { Cancel(EXIT_ALL); }
 
   // When is_nested_run() this will add a delegate to the stack. The most recent
   // delegate will be notified. It will be removed upon the exiting of the
   // nested menu. Ownership is not taken.
   void AddNestedDelegate(internal::MenuControllerDelegate* delegate);
 
-  // Sets whether the subsequent call to Run is asynchronous. When nesting calls
-  // to Run, if a new MenuControllerDelegate has been nested, the previous
-  // asynchronous state will be reapplied once nesting has ended.
-  void SetAsyncRun(bool is_async);
-
   // Returns the current exit type. This returns a value other than EXIT_NONE if
   // the menu is being canceled.
   ExitType exit_type() const { return exit_type_; }
 
   // Returns the time from the event which closed the menu - or 0.
   base::TimeTicks closing_event_time() const { return closing_event_time_; }
 
   void set_is_combobox(bool is_combobox) { is_combobox_ = is_combobox; }
 
   // Various events, forwarded from the submenu.
@@ skipping 390 matching lines @@
   // it to null.
   void SendMouseCaptureLostToActiveView();
 
   // Sets/gets the active mouse view. See UpdateActiveMouseView() for details.
   void SetActiveMouseView(View* view);
   View* GetActiveMouseView();
 
   // Sets exit type. Calling this can terminate the active nested message-loop.
   void SetExitType(ExitType type);
 
-  // Terminates the current nested message-loop, if there is any. Returns |true|
-  // if any message loop is terminated.
-  bool TerminateNestedMessageLoopIfNecessary();
-
-  // Performs the teardown of menus launched with |async_run_|. This will
-  // notifiy the |delegate_|. If |exit_type_| is EXIT_ALL all nested
-  // asynchronous runs will be exited.
-  void ExitAsyncRun();
+  // Performs the teardown of menus. This will notifiy the |delegate_|. If
+  // |exit_type_| is EXIT_ALL all nested runs will be exited.
+  void ExitMenu();
 
   // Performs the teardown of the menu launched by Run(). The selected item is
   // returned.
-  MenuItemView* ExitMenuRun();
+  MenuItemView* ExitTopMostMenu();
 
   // Handles the mouse location event on the submenu |source|.
   void HandleMouseLocation(SubmenuView* source,
                            const gfx::Point& mouse_location);
 
   // Sets hot-tracked state to the first focusable descendant view of |item|.
   void SetInitialHotTrackedView(MenuItemView* item,
                                 SelectionIncrementDirectionType direction);
 
   // Updates the current |hot_button_| and its hot tracked state.
@@ skipping 34 matching lines @@
   int accept_event_flags_;
 
   // If not empty, it means we're nested. When Run is invoked from within
   // Run, the current state (state_) is pushed onto menu_stack_. This allows
   // MenuController to restore the state when the nested run returns.
   using NestedState =
       std::pair<State, std::unique_ptr<MenuButton::PressedLock>>;
   std::list<NestedState> menu_stack_;
 
   // When Run is invoked during an active Run, it may be called from a separate
-  // MenuControllerDelegate. If not empty is means we are nested, and the
+  // MenuControllerDelegate. If not empty it means we are nested, and the
   // stacked delegates should be notified instead of |delegate_|.
-  typedef std::pair<internal::MenuControllerDelegate*, bool> NestedDelegate;
-  std::list<NestedDelegate> delegate_stack_;
+  std::list<internal::MenuControllerDelegate*> delegate_stack_;
 
   // As the mouse moves around submenus are not opened immediately. Instead
   // they open after this timer fires.
   base::OneShotTimer show_timer_;
 
   // Used to invoke CancelAll(). This is used during drag and drop to hide the
   // menu after the mouse moves out of the of the menu. This is necessitated by
   // the lack of an ability to detect when the drag has completed from the drop
   // side.
   base::OneShotTimer cancel_all_timer_;
@@ skipping 38 matching lines @@
 
   // ViewStorage id used to store the view mouse drag events are forwarded to.
   // See UpdateActiveMouseView() for details.
   const int active_mouse_view_id_;
 
   // Current hot tracked child button if any.
   CustomButton* hot_button_;
 
   internal::MenuControllerDelegate* delegate_;
 
-  // How deep we are in nested message loops. This should be at most 2 (when
-  // showing a context menu from a menu).
-  int message_loop_depth_;
-
   // The timestamp of the event which closed the menu - or 0 otherwise.
   base::TimeTicks closing_event_time_;
 
   // Time when the menu is first shown.
   base::TimeTicks menu_start_time_;
 
   // If a mouse press triggered this menu, this will have its location (in
   // screen coordinates). Otherwise this will be (0, 0).
   gfx::Point menu_start_mouse_press_loc_;
 
-  // Controls behaviour differences between an asynchronous run, and other types
-  // of run (blocking, drag and drop).
-  bool async_run_;
-
   // Controls behavior differences between a combobox and other types of menu
   // (like a context menu).
   bool is_combobox_;
 
   // Set to true if the menu item was selected by touch.
   bool item_selected_by_touch_;
 
   // During mouse event handling, this is the RootView to forward mouse events
   // to. We need this, because if we forward one event to it (e.g., mouse
   // pressed), subsequent events (like dragging) should also go to it, even if
   // the mouse is no longer over the view.
   MenuHostRootView* current_mouse_event_target_;
 
   // A mask of the EventFlags for the mouse buttons currently pressed.
   int current_mouse_pressed_state_;
 
-  std::unique_ptr<MenuMessageLoop> message_loop_;
-
 #if defined(USE_AURA)
   std::unique_ptr<MenuPreTargetHandler> menu_pre_target_handler_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(MenuController);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_