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
 
@@ skipping 89 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;
 }
 
+#if defined(USE_AURA)

[tapted, 2014/05/02 00:22:57]

I think there will be resistance to this many #ifdefs :(. But I could be wrong
(we could ask :).

Ideally helper functions - maybe on menu_config_foo, drag_utils_foo or
native_widget_private/native_widget_foo (and menu_host..) mean the #ifdefs and
aura dependencies disappear from this file. However, I explored this a bit
yesterday and a neat solution didn't start standing out.

You can see my early attempts here: https://codereview.chromium.org/264953005 .
But I didn't get very far (currently swamped in code review for m36 things..).

One option (just came to me..) might be a new class with a virtual interface,
like


class MenuActivationHelper {
 pubilc:
  virtual void RunMessageLoop();
  virtual void RepostMouseEventToRootWindow(const ui::MouseEvent& event) = 0;

  static bool IsDragDropInProgress();

  static scoped_ptr<MenuActivationHelper> Create(MenuController* controller,
gfx::NativeWindow* window);
};


Then do classes/files forMenuActivationHelperAura MenuActivationHelperMac etc. I
*think* this will be nicer than #ifdefs, but I haven't tried it out yet.

 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,
@@ skipping 40 matching lines @@
     root_->RemovePreTargetHandler(this);
     root_->RemoveObserver(this);
     root_ = NULL;
   }
 
   MenuController* controller_;
   aura::Window* root_;
 
   DISALLOW_COPY_AND_ASSIGN(ActivationChangeObserverImpl);
 };
+#endif // USE_AURA
 
 }  // 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())
@@ skipping 1004 matching lines @@
       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();
   }
 }
+#elif defined(OS_MACOSX)
+void MenuController::RunMessageLoop(bool nested_menu) {
+  base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
+  base::MessageLoop::ScopedNestableTaskAllower allow(loop);
+  base::RunLoop run_loop;
+  run_loop.Run();
+}
 #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);
   }
@@ skipping 1018 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;
 
+#if defined(USE_AURA)
   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);
+#endif
 }
 
 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 118 matching lines @@
   // 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_;
 
   if (quit_now) {
+#if defined(USE_AURA)
     if (owner_) {
       aura::Window* root = owner_->GetNativeWindow()->GetRootWindow();
       aura::client::GetDispatcherClient(root)->QuitNestedMessageLoop();
     } else {
       base::MessageLoop::current()->QuitNow();
     }
+#else
+    base::MessageLoop::current()->QuitNow();
+#endif
     // Restore the previous dispatcher.
     nested_dispatcher_.reset();
   }
 }
 
 bool MenuController::ShouldQuitNow() const {
+#if defined(USE_AURA)
   aura::Window* root = GetOwnerRootWindow(owner_);
   return !aura::client::GetDragDropClient(root) ||
          !aura::client::GetDragDropClient(root)->IsDragDropInProgress();
+#else
+  return true;
+#endif
 }
 
 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_->GetTopLevelWidget();
+  return root ? gfx::Screen::GetScreenFor(root->GetNativeView())

[Andre, 2014/05/01 22:38:43]

I'm not sure about this change (limited experience with views code). I will run
on linux and test if this works.
Trent, let me know if this looks wrong.

[tapted, 2014/05/02 00:22:57]

This looks good! (I think :)

               : gfx::Screen::GetNativeScreen();
 }
 
 }  // namespace views