Update closing of nested asynchronous menus

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 400 matching lines @@
   if (!blocking_run_) {
     // If we didn't block the caller we need to notify the menu, which
     // triggers deleting us.
     DCHECK(selected);
     showing_ = false;
     delegate_->OnMenuClosed(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
                             selected->GetRootMenuItem(), accept_event_flags_);
     // WARNING: the call to MenuClosed deletes us.
     return;
   }
-  if (async_run_) {
-    internal::MenuControllerDelegate* delegate = delegate_;
-    MenuItemView* result = ExitMenuRun();
-    delegate->OnMenuClosed(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
-                           result, accept_event_flags_);
-  }
+  ExitAsyncRun();
 }
 
 void MenuController::AddNestedDelegate(
     internal::MenuControllerDelegate* delegate) {
   delegate_stack_.push_back(std::make_pair(delegate, async_run_));
   delegate_ = delegate;
 }
 
 void MenuController::SetAsyncRun(bool is_async) {
   delegate_stack_.back().second = is_async;
@@ skipping 413 matching lines @@
   DCHECK(drag_in_progress_);
   drag_in_progress_ = false;
   // During a drag, mouse events are processed directly by the widget, and not
   // sent to the MenuController. At drag completion, reset pressed state and
   // the event target.
   current_mouse_pressed_state_ = 0;
   current_mouse_event_target_ = nullptr;
   if (showing_ && should_close && GetActiveInstance() == this) {
     CloseAllNestedMenus();
     Cancel(EXIT_ALL);
+  } else if (async_run_) {
+    ExitAsyncRun();
   }
 }
 
 ui::PostDispatchAction MenuController::OnWillDispatchKeyEvent(
     base::char16 character,
     ui::KeyboardCode key_code) {
   if (exit_type() == MenuController::EXIT_ALL ||
       exit_type() == MenuController::EXIT_DESTROYED) {
     TerminateNestedMessageLoopIfNecessary();
     return ui::POST_DISPATCH_PERFORM_DEFAULT;
@@ skipping 195 matching lines @@
   item->GetDelegate()->WriteDragData(item, &data);
   drag_utils::SetDragImageOnDataObject(*canvas,
                                        press_loc.OffsetFromOrigin(),
                                        &data);
   StopScrolling();
   int drag_ops = item->GetDelegate()->GetDragOperations(item);
   did_initiate_drag_ = true;
   // 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);
-  did_initiate_drag_ = false;
+  if (GetActiveInstance())

[sky, 2016/01/11 20:56:04]

Please add a comment as to why this check is necessary.

[jonross, 2016/01/11 21:27:15]

Done.

+    did_initiate_drag_ = false;
 }
 
 void MenuController::OnKeyDown(ui::KeyboardCode key_code) {
   DCHECK(blocking_run_);
 
   switch (key_code) {
     case ui::VKEY_UP:
       IncrementSelection(INCREMENT_SELECTION_UP);
       break;
 
@@ skipping 182 matching lines @@
 void MenuController::Accept(MenuItemView* item, int event_flags) {
   DCHECK(IsBlockingRun());
   result_ = item;
   if (item && !menu_stack_.empty() &&
       !item->GetDelegate()->ShouldCloseAllMenusOnExecute(item->GetCommand())) {
     SetExitType(EXIT_OUTERMOST);
   } else {
     SetExitType(EXIT_ALL);
   }
   accept_event_flags_ = event_flags;
-  if (async_run_) {
-    internal::MenuControllerDelegate* delegate = delegate_;
-    MenuItemView* result = ExitMenuRun();
-    delegate->OnMenuClosed(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
-                           result, accept_event_flags_);
-  }
+  ExitAsyncRun();
 }
 
 bool MenuController::ShowSiblingMenu(SubmenuView* source,
                                      const gfx::Point& mouse_location) {
   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() &&
@@ skipping 1116 matching lines @@
 
 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_;
+  MenuItemView* result = ExitMenuRun();
+  delegate->OnMenuClosed(internal::MenuControllerDelegate::NOTIFY_DELEGATE,
+                         result, accept_event_flags_);
+  if (nested && exit_type_ == EXIT_ALL)
+    ExitAsyncRun();
+}
+
 MenuItemView* MenuController::ExitMenuRun() {
   // Release the lock which prevents Chrome from shutting down while the menu is
   // showing.
   if (async_run_ && ViewsDelegate::GetInstance())
     ViewsDelegate::GetInstance()->ReleaseRef();
 
   // Close any open menus.
   SetSelection(nullptr, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
 
 #if defined(OS_WIN)
@@ skipping 98 matching lines @@
   }
 }
 
 gfx::Screen* MenuController::GetScreen() {
   Widget* root = owner_ ? owner_->GetTopLevelWidget() : NULL;
   return root ? gfx::Screen::GetScreenFor(root->GetNativeView())
               : gfx::Screen::GetNativeScreen();
 }
 
 }  // namespace views