wm: Change the DispatcherClient interface.

ui/views/controls/menu/menu_message_loop_aura.cc

 // Copyright 2014 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_message_loop_aura.h"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
@@ skipping 112 matching lines @@
   clone.set_root_location(root_loc);
   root->GetHost()->dispatcher()->RepostEvent(clone);
 }
 
 void MenuMessageLoopAura::Run(MenuController* controller,
                               Widget* owner,
                               bool nested_menu) {
   // |owner_| may be NULL.
   owner_ = owner;
   aura::Window* root = GetOwnerRootWindow(owner_);
+  // It is possible for the same MenuMessageLoopAura to start a nested
+  // message-loop while it is already running a nested loop. So make sure the
+  // quit-closure gets reset to the outer loop's quit-closure once the innermost
+  // loop terminates.
+  base::AutoReset<base::Closure> reset_quit_closure(&message_loop_quit_,
+                                                    base::Closure());
 
 #if defined(OS_WIN)
   internal::MenuMessagePumpDispatcher nested_dispatcher(controller);
   if (root) {
     scoped_ptr<ActivationChangeObserverImpl> observer;
     if (!nested_menu)
       observer.reset(new ActivationChangeObserverImpl(controller, root));
     aura::client::GetDispatcherClient(root)
-        ->RunWithDispatcher(&nested_dispatcher);
+        ->RunWithDispatcher(&nested_dispatcher, &message_loop_quit_);
   } else {
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoop::ScopedNestableTaskAllower allow(loop);
     base::RunLoop run_loop(&nested_dispatcher);
+    message_loop_quit_ = run_loop.QuitClosure();
     run_loop.Run();
   }
 #else
   internal::MenuEventDispatcher event_dispatcher(controller);
   scoped_ptr<ui::ScopedEventDispatcher> old_dispatcher =
       nested_dispatcher_.Pass();
   if (ui::PlatformEventSource::GetInstance()) {
     nested_dispatcher_ =
         ui::PlatformEventSource::GetInstance()->OverrideDispatcher(
             &event_dispatcher);
   }
   if (root) {
     scoped_ptr<ActivationChangeObserverImpl> observer;
     if (!nested_menu)
       observer.reset(new ActivationChangeObserverImpl(controller, root));
-    aura::client::GetDispatcherClient(root)->RunWithDispatcher(NULL);
+    aura::client::GetDispatcherClient(root)->RunWithDispatcher(
+        NULL, &message_loop_quit_);
   } else {
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoop::ScopedNestableTaskAllower allow(loop);
     base::RunLoop run_loop;
+    message_loop_quit_ = run_loop.QuitClosure();
     run_loop.Run();
   }
   nested_dispatcher_ = old_dispatcher.Pass();
 #endif
 }
 
 bool MenuMessageLoopAura::ShouldQuitNow() const {
   aura::Window* root = GetOwnerRootWindow(owner_);
   return !aura::client::GetDragDropClient(root) ||
          !aura::client::GetDragDropClient(root)->IsDragDropInProgress();
 }
 
 void MenuMessageLoopAura::QuitNow() {
-  if (owner_) {
-    // It's safe to invoke QuitNestedMessageLoop() multiple times, it only
-    // effects the current loop.
-    aura::Window* root = owner_->GetNativeWindow()->GetRootWindow();
-    aura::client::GetDispatcherClient(root)->QuitNestedMessageLoop();
-  } else {
-    base::MessageLoop::current()->QuitNow();
-  }
+  CHECK(!message_loop_quit_.is_null());
+  message_loop_quit_.Run();
   // Restore the previous dispatcher.
   nested_dispatcher_.reset();
 }
 
 void MenuMessageLoopAura::ClearOwner() {
   owner_ = NULL;
 }
 
 }  // namespace views