Turn Bookmark Menus Async

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 28 matching lines @@
 #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/views/controls/menu/menu_key_event_handler.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 353 matching lines @@
       if (event && event->type() == ui::ET_MOUSE_PRESSED) {
         gfx::Point screen_loc(
             static_cast<const ui::MouseEvent*>(event)->location());
         View::ConvertPointToScreen(
             static_cast<View*>(event->target()), &screen_loc);
         menu_start_mouse_press_loc_ = screen_loc;
       }
     }
   }
 
-  bool nested_menu = showing_;
+  // If we are already showing, this new menu is being nested. Such as context
+  // menus on top of normal menus.
   if (showing_) {
     // Only support nesting of blocking_run menus, nesting of
     // blocking/non-blocking shouldn't be needed.
     DCHECK(blocking_run_);
 
     state_.hot_button = hot_button_;
     hot_button_ = nullptr;
     // 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 (owner_)
+      owner_->RemoveObserver(this);
+    owner_ = parent;
+    if (owner_)
+      owner_->AddObserver(this);
+
 #if defined(USE_AURA)
-    // Only create a MenuKeyEventHandler for non-nested menus. Nested menus will
-    // use the existing one.
-    key_event_handler_.reset(new MenuKeyEventHandler);
+    // Only create a MenuPreTargetHandler for non-nested menus. Nested menus
+    // will use the existing one.
+    menu_pre_target_handler_.reset(new MenuPreTargetHandler(this, owner_));
 #endif
   }
 
   // Reset current state.
   pending_state_ = State();
   state_ = State();
   UpdateInitialLocation(bounds, position, context_menu);
 
-  if (owner_)
-    owner_->RemoveObserver(this);
-  owner_ = parent;
-  if (owner_)
-    owner_->AddObserver(this);
-
   // Set the selection, which opens the initial menu.
   SetSelection(root, SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
 
   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)
     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(nested_menu);
+  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.
@@ skipping 582 matching lines @@
     View::ConvertPointFromScreen(
         root_submenu->GetWidget()->GetRootView(), &point);
     HandleMouseLocation(submenu, point);
   }
 }
 
 void MenuController::OnWidgetDestroying(Widget* widget) {
   DCHECK_EQ(owner_, widget);
   owner_->RemoveObserver(this);
   owner_ = NULL;
-  message_loop_->ClearOwner();
 }
 
 bool MenuController::IsCancelAllTimerRunningForTest() {
   return cancel_all_timer_.IsRunning();
 }
 
 // static
 void MenuController::TurnOffMenuSelectionHoldForTest() {
   menu_selection_hold_time_ms = -1;
 }
@@ skipping 280 matching lines @@
 MenuController::~MenuController() {
   DCHECK(!showing_);
   if (owner_)
     owner_->RemoveObserver(this);
   if (active_instance_ == this)
     active_instance_ = NULL;
   StopShowTimer();
   StopCancelAllTimer();
 }
 
-void MenuController::RunMessageLoop(bool nested_menu) {
-  message_loop_->Run(this, owner_, nested_menu);
+void MenuController::RunMessageLoop() {
+  message_loop_->Run();
 }
 
 bool MenuController::SendAcceleratorToHotTrackedView() {
   CustomButton* hot_view = GetFirstHotTrackedView(pending_state_.item);
   if (!hot_view)
     return false;
 
   ui::Accelerator accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   hot_view->AcceleratorPressed(accelerator);
   CustomButton* button = static_cast<CustomButton*>(hot_view);
@@ skipping 1201 matching lines @@
     nested_pressed_lock = 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;
     }
   } else {
 #if defined(USE_AURA)
-    key_event_handler_.reset();
+    menu_pre_target_handler_.reset();
 #endif
 
     showing_ = false;
     did_capture_ = false;
   }
 
   MenuItemView* result = result_;
   // In case we're nested, reset |result_|.
   result_ = nullptr;
 
@@ skipping 79 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