Refactor menu controller to isolate aura dependency.

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"
 
-#if defined(OS_WIN)
-#include <windowsx.h>
-#endif
-
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
-#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
-#include "ui/aura/client/screen_position_client.h"
-#include "ui/aura/env.h"
-#include "ui/aura/window.h"
-#include "ui/aura/window_event_dispatcher.h"
-#include "ui/aura/window_tree_host.h"
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
-#include "ui/events/platform/platform_event_source.h"
-#include "ui/events/platform/scoped_event_dispatcher.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/vector2d.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"
-#include "ui/wm/public/activation_change_observer.h"
-#include "ui/wm/public/activation_client.h"
-#include "ui/wm/public/dispatcher_client.h"
-#include "ui/wm/public/drag_drop_client.h"
 
 #if defined(OS_WIN)
 #include "ui/base/win/internal_constants.h"
-#include "ui/views/controls/menu/menu_message_pump_dispatcher_win.h"
 #include "ui/views/win/hwnd_util.h"
-#else
-#include "ui/views/controls/menu/menu_event_dispatcher_linux.h"
 #endif
 
-using aura::client::ScreenPositionClient;
 using base::Time;
 using base::TimeDelta;
 using ui::OSExchangeData;
 
 // Period of the scroll timer (in milliseconds).
 static const int kScrollTimerMS = 30;
 
 // Amount of time from when the drop exits the menu and the menu is hidden.
 static const int kCloseOnExitTime = 1200;
 
@@ skipping 27 matching lines @@
 // Returns true if |menu| doesn't have a mnemonic and first character of the its
 // title is |key|.
 bool TitleMatchesMnemonic(MenuItemView* menu, base::char16 key) {
   if (menu->GetMnemonic())
     return false;
 
   base::string16 lower_title = base::i18n::ToLower(menu->title());
   return !lower_title.empty() && lower_title[0] == key;
 }
 
-aura::Window* GetOwnerRootWindow(views::Widget* owner) {
-  return owner ? owner->GetNativeWindow()->GetRootWindow() : NULL;
-}
-
-// ActivationChangeObserverImpl is used to observe activation changes and close
-// the menu. Additionally it listens for the root window to be destroyed and
-// cancel the menu as well.
-class ActivationChangeObserverImpl
-    : public aura::client::ActivationChangeObserver,
-      public aura::WindowObserver,
-      public ui::EventHandler {
- public:
-  ActivationChangeObserverImpl(MenuController* controller, aura::Window* root)
-      : controller_(controller),
-        root_(root) {
-    aura::client::GetActivationClient(root_)->AddObserver(this);
-    root_->AddObserver(this);
-    root_->AddPreTargetHandler(this);
-  }
-
-  virtual ~ActivationChangeObserverImpl() {
-    Cleanup();
-  }
-
-  // aura::client::ActivationChangeObserver:
-  virtual void OnWindowActivated(aura::Window* gained_active,
-                                 aura::Window* lost_active) OVERRIDE {
-    if (!controller_->drag_in_progress())
-      controller_->CancelAll();
-  }
-
-  // aura::WindowObserver:
-  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
-    Cleanup();
-  }
-
-  // ui::EventHandler:
-  virtual void OnCancelMode(ui::CancelModeEvent* event) OVERRIDE {
-    controller_->CancelAll();
-  }
-
- private:
-  void Cleanup() {
-    if (!root_)
-      return;
-    // The ActivationClient may have been destroyed by the time we get here.
-    aura::client::ActivationClient* client =
-        aura::client::GetActivationClient(root_);
-    if (client)
-      client->RemoveObserver(this);
-    root_->RemovePreTargetHandler(this);
-    root_->RemoveObserver(this);
-    root_ = NULL;
-  }
-
-  MenuController* controller_;
-  aura::Window* root_;
-
-  DISALLOW_COPY_AND_ASSIGN(ActivationChangeObserverImpl);
-};
-
 }  // namespace
 
 // Returns the first descendant of |view| that is hot tracked.
 static CustomButton* GetFirstHotTrackedView(View* view) {
   if (!view)
     return NULL;
   CustomButton* button = CustomButton::AsCustomButton(view);
   if (button) {
     if (button->IsHotTracked())
       return button;
@@ skipping 250 matching lines @@
     return NULL;
   }
 
   if (button)
     menu_button_ = button;
 
   // Make sure Chrome doesn't attempt to shut down while the menu is showing.
   if (ViewsDelegate::views_delegate)
     ViewsDelegate::views_delegate->AddRef();
 
-  // 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);
-  message_loop_depth_--;
 
   if (ViewsDelegate::views_delegate)
     ViewsDelegate::views_delegate->ReleaseRef();
 
   // Close any open menus.
   SetSelection(NULL, SELECTION_UPDATE_IMMEDIATELY | SELECTION_EXIT);
 
 #if defined(OS_WIN)
   // On Windows, if we select the menu item by touch and if the window at the
   // location is another window on the same thread, that window gets a
@@ skipping 408 matching lines @@
         submenu->GetMenuItem()->GetRootMenuItem()->GetSubmenu();
     View::ConvertPointFromScreen(
         root_submenu->GetWidget()->GetRootView(), &point);
     HandleMouseLocation(submenu, point);
   }
 }
 
 void MenuController::OnWidgetDestroying(Widget* widget) {
   DCHECK_EQ(owner_, widget);
   owner_->RemoveObserver(this);
   owner_ = NULL;

[sky, 2014/05/15 16:07:32]

I think you should NULL out owner_ in MenuMessageLoopAura here too.

[Andre, 2014/05/15 18:45:59]

MenuMessageLoop clears owner_ when exiting the loop.
Are you thinking about a case where the widget destroys while the menu loop is
still running?
Should I add SetOwner() to MenuMessageLoop and call it with NULL here?
Or should we tell the loop to exit here if the widget is destroying?

[sky, 2014/05/15 19:33:01]

Exactly. I don't like it that MenuMessageLoop may be holding a Widget that has
been deleted.
Go with the SetOwner for now. I believe quitting is already handled.

[Andre, 2014/05/15 20:57:12]

Done.
I went with ClearOwner because owner was passed in as part of the call to Run()
and it doesn't make sense to change while running.

 }
 
 // static
 void MenuController::TurnOffMenuSelectionHoldForTest() {
   menu_selection_hold_time_ms = -1;
 }
 
 void MenuController::SetSelection(MenuItemView* menu_item,
                                   int selection_types) {
   size_t paths_differ_at = 0;
@@ skipping 259 matching lines @@
       drop_position_(MenuDelegate::DROP_UNKNOWN),
       owner_(NULL),
       possible_drag_(false),
       drag_in_progress_(false),
       valid_drop_coordinates_(false),
       last_drop_operation_(MenuDelegate::DROP_UNKNOWN),
       showing_submenu_(false),
       menu_button_(NULL),
       active_mouse_view_id_(ViewStorage::GetInstance()->CreateStorageID()),
       delegate_(delegate),
-      message_loop_depth_(0),
       menu_config_(theme),
       closing_event_time_(base::TimeDelta()),
       menu_start_time_(base::TimeTicks()),
       is_combobox_(false),
-      item_selected_by_touch_(false) {
+      item_selected_by_touch_(false),
+      message_loop_(MenuMessageLoop::Create()) {
   active_instance_ = this;
 }
 
 MenuController::~MenuController() {
   DCHECK(!showing_);
   if (owner_)
     owner_->RemoveObserver(this);
   if (active_instance_ == this)
     active_instance_ = NULL;
   StopShowTimer();
   StopCancelAllTimer();
 }
 
-#if defined(OS_WIN)
 void MenuController::RunMessageLoop(bool nested_menu) {
-  internal::MenuMessagePumpDispatcher nested_dispatcher(this);
-
-  // |owner_| may be NULL.
-  aura::Window* root = GetOwnerRootWindow(owner_);
-  if (root) {
-    scoped_ptr<ActivationChangeObserverImpl> observer;
-    if (!nested_menu)
-      observer.reset(new ActivationChangeObserverImpl(this, root));
-    aura::client::GetDispatcherClient(root)
-        ->RunWithDispatcher(&nested_dispatcher);
-  } else {
-    base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
-    base::MessageLoop::ScopedNestableTaskAllower allow(loop);
-    base::RunLoop run_loop(&nested_dispatcher);
-    run_loop.Run();
-  }
+  message_loop_->Run(this, owner_, nested_menu);

[sky, 2014/05/15 16:07:32]

Inline this and remove the RunMessageLoop function (it's only called from one
place).

[Andre, 2014/05/15 18:45:59]

The RunMessageLoop public method is also called by MenuControllerTest.

 }
-#else
-void MenuController::RunMessageLoop(bool nested_menu) {
-  internal::MenuEventDispatcher event_dispatcher(this);
-  scoped_ptr<ui::ScopedEventDispatcher> old_dispatcher =
-      nested_dispatcher_.Pass();
-  if (ui::PlatformEventSource::GetInstance()) {
-    nested_dispatcher_ =
-        ui::PlatformEventSource::GetInstance()->OverrideDispatcher(
-            &event_dispatcher);
-  }
-  // |owner_| may be NULL.
-  aura::Window* root = GetOwnerRootWindow(owner_);
-  if (root) {
-    scoped_ptr<ActivationChangeObserverImpl> observer;
-    if (!nested_menu)
-      observer.reset(new ActivationChangeObserverImpl(this, root));
-    aura::client::GetDispatcherClient(root)->RunWithDispatcher(NULL);
-  } else {
-    base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
-    base::MessageLoop::ScopedNestableTaskAllower allow(loop);
-    base::RunLoop run_loop;
-    run_loop.Run();
-  }
-  nested_dispatcher_ = old_dispatcher.Pass();
-}
-#endif
 
 MenuController::SendAcceleratorResultType
     MenuController::SendAcceleratorToHotTrackedView() {
   CustomButton* hot_view = GetFirstHotTrackedView(pending_state_.item);
   if (!hot_view)
     return ACCELERATOR_NOT_PROCESSED;
 
   ui::Accelerator accelerator(ui::VKEY_RETURN, ui::EF_NONE);
   hot_view->AcceleratorPressed(accelerator);
   CustomButton* button = static_cast<CustomButton*>(hot_view);
@@ skipping 991 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-Windows Aura or |window| is in metro mode.
   if (!window)
     return;
 
-  aura::Window* root = window->GetRootWindow();
-  ScreenPositionClient* spc = aura::client::GetScreenPositionClient(root);
-  if (!spc)
-    return;
-
-  gfx::Point root_loc(screen_loc);
-  spc->ConvertPointFromScreen(root, &root_loc);
-
-  ui::MouseEvent clone(static_cast<const ui::MouseEvent&>(event));
-  clone.set_location(root_loc);
-  clone.set_root_location(root_loc);
-  root->GetHost()->dispatcher()->RepostEvent(clone);
+  message_loop_->RepostEventToWindow(event, window, screen_loc);
 }
 
 void MenuController::SetDropMenuItem(
     MenuItemView* new_target,
     MenuDelegate::DropPosition new_position) {
   if (new_target == drop_target_ && new_position == drop_position_)
     return;
 
   if (drop_target_) {
     drop_target_->GetParentMenuItem()->GetSubmenu()->SetDropMenuItem(
@@ skipping 114 matching lines @@
   exit_type_ = type;
   // Exit nested message loops as soon as possible. We do this as
   // MessagePumpDispatcher is only invoked before native events, which means
   // its 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.
   //
   // It's safe to invoke QuitNestedMessageLoop() multiple times, it only effects
   // the current loop.
-  bool quit_now = ShouldQuitNow() && exit_type_ != EXIT_NONE &&
-      message_loop_depth_;
+  bool quit_now = message_loop_->ShouldQuitNow() && exit_type_ != EXIT_NONE &&
+                  message_loop_->message_loop_depth();
   if (quit_now)
     TerminateNestedMessageLoop();
 }
 
 void MenuController::TerminateNestedMessageLoop() {
-  if (owner_) {
-    aura::Window* root = owner_->GetNativeWindow()->GetRootWindow();
-    aura::client::GetDispatcherClient(root)->QuitNestedMessageLoop();
-  } else {
-    base::MessageLoop::current()->QuitNow();
-  }
-  // Restore the previous dispatcher.
-  nested_dispatcher_.reset();
-}
-
-bool MenuController::ShouldQuitNow() const {
-  aura::Window* root = GetOwnerRootWindow(owner_);
-  return !aura::client::GetDragDropClient(root) ||
-         !aura::client::GetDragDropClient(root)->IsDragDropInProgress();
+  message_loop_->QuitNow();
 }
 
 void MenuController::HandleMouseLocation(SubmenuView* source,
                                          const gfx::Point& mouse_location) {
   if (showing_submenu_)
     return;
 
   // Ignore mouse events if we're closing the menu.
   if (exit_type_ != EXIT_NONE)
     return;
@@ skipping 15 matching lines @@
              (!pending_state_.item->HasSubmenu() ||
               !pending_state_.item->GetSubmenu()->IsShowing())) {
     // On exit if the user hasn't selected an item with a submenu, move the
     // selection back to the parent menu item.
     SetSelection(pending_state_.item->GetParentMenuItem(),
                  SELECTION_OPEN_SUBMENU);
   }
 }
 
 gfx::Screen* MenuController::GetScreen() {
-  aura::Window* root = GetOwnerRootWindow(owner_);
-  return root ? gfx::Screen::GetScreenFor(root)
+  Widget* root = owner_ ? owner_->GetTopLevelWidget() : NULL;
+  return root ? gfx::Screen::GetScreenFor(root->GetNativeView())
               : gfx::Screen::GetNativeScreen();
 }
 
 }  // namespace views