Move enum MenuAnchorPosition to reduce deps on menu_item_view.h

ui/views/controls/menu/menu_controller.h

 // 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.
 
 #ifndef UI_VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_
 #define UI_VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_
 
 #include "build/build_config.h"
 
 #include <list>
 #include <set>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/timer/timer.h"
+#include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/platform/platform_event_dispatcher.h"
+#include "ui/views/controls/menu/menu_config.h"
 #include "ui/views/controls/menu/menu_delegate.h"
-#include "ui/views/controls/menu/menu_item_view.h"
 #include "ui/views/widget/widget_observer.h"
 
 namespace base {
 class MessagePumpDispatcher;
 }
 namespace gfx {
 class Screen;
 }
 namespace ui {
 class NativeTheme;
 class OSExchangeData;
 class ScopedEventDispatcher;
 }
 namespace views {
 
 class MenuButton;
 class MenuHostRootView;
+class MenuItemView;
 class MouseEvent;
 class SubmenuView;
 class View;
 
 namespace internal {
 class MenuControllerDelegate;
 class MenuEventDispatcher;
 class MenuMessagePumpDispatcher;
 class MenuRunnerImpl;
 }
@@ skipping 24 matching lines @@
   // If a menu is currently active, this returns the controller for it.
   static MenuController* GetActiveInstance();
 
   // Runs the menu at the specified location. If the menu was configured to
   // block, the selected item is returned. If the menu does not block this
   // returns NULL immediately.
   MenuItemView* Run(Widget* parent,
                     MenuButton* button,
                     MenuItemView* root,
                     const gfx::Rect& bounds,
-                    MenuItemView::AnchorPosition position,
+                    MenuAnchorPosition position,
                     bool context_menu,
                     int* event_flags);
 
   // Whether or not Run blocks.
   bool IsBlockingRun() const { return blocking_run_; }
 
   // Whether or not drag operation is in progress.
   bool drag_in_progress() const { return drag_in_progress_; }
 
   // Get the anchor position wich is used to show this menu.
-  MenuItemView::AnchorPosition GetAnchorPosition() { return state_.anchor; }
+  MenuAnchorPosition GetAnchorPosition() { return state_.anchor; }
 
   // Cancels the current Run. See ExitType for a description of what happens
   // with the various parameters.
   void Cancel(ExitType type);
 
   // An alternative to Cancel(EXIT_ALL) that can be used with a OneShotTimer.
   void CancelAll() { Cancel(EXIT_ALL); }
 
   // Returns the current exit type. This returns a value other than EXIT_NONE if
   // the menu is being canceled.
@@ skipping 88 matching lines @@
     // The selected menu item.
     MenuItemView* item;
 
     // If item has a submenu this indicates if the submenu is showing.
     bool submenu_open;
 
     // Bounds passed to the run menu. Used for positioning the first menu.
     gfx::Rect initial_bounds;
 
     // Position of the initial menu.
-    MenuItemView::AnchorPosition anchor;
+    MenuAnchorPosition anchor;
 
     // The direction child menus have opened in.
     std::list<bool> open_leading;
 
     // Bounds for the monitor we're showing on.
     gfx::Rect monitor_bounds;
 
     // Is the current menu a context menu.
     bool context_menu;
   };
@@ skipping 60 matching lines @@
 
   // Runs the platform specific bits of the message loop. If |nested_menu| is
   // true we're being asked to run a menu from within a menu (eg a context
   // menu).
   void RunMessageLoop(bool nested_menu);
 
   // AcceleratorPressed is invoked on the hot tracked view if it exists.
   SendAcceleratorResultType SendAcceleratorToHotTrackedView();
 
   void UpdateInitialLocation(const gfx::Rect& bounds,
-                             MenuItemView::AnchorPosition position,
+                             MenuAnchorPosition position,
                              bool context_menu);
 
   // Invoked when the user accepts the selected item. This is only used
   // when blocking. This schedules the loop to quit.
   void Accept(MenuItemView* item, int event_flags);
 
   bool ShowSiblingMenu(SubmenuView* source, const gfx::Point& mouse_location);
 
   // Shows a context menu for |menu_item| as a result of a located event if
   // appropriate. This is invoked on long press and releasing the right mouse
@@ skipping 299 matching lines @@
   bool item_selected_by_touch_;
 
   scoped_ptr<ui::ScopedEventDispatcher> nested_dispatcher_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuController);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_MENU_MENU_CONTROLLER_H_