Re-lands 58186:

views/controls/menu/menu_controller.cc

 // Copyright (c) 2010 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 "views/controls/menu/menu_controller.h"
 
+#include "app/keyboard_codes.h"
 #include "app/l10n_util.h"
 #include "app/os_exchange_data.h"
 #include "base/i18n/rtl.h"
-#include "base/keyboard_codes.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "gfx/canvas_skia.h"
 #include "views/controls/button/menu_button.h"
 #include "views/controls/menu/menu_scroll_view_container.h"
 #include "views/controls/menu/submenu_view.h"
 #include "views/drag_utils.h"
 #include "views/screen.h"
 #include "views/view_constants.h"
 #include "views/views_delegate.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget.h"
 
 #if defined(OS_LINUX)
-#include "base/keyboard_code_conversion_gtk.h"
+#include "app/keyboard_code_conversion_gtk.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 
 // Period of the scroll timer (in milliseconds).
 static const int kScrollTimerMS = 30;
 
 // Delay, in ms, between when menus are selected are moused over and the menu
 // appears.
@@ skipping 770 matching lines @@
 
 #else
 bool MenuController::Dispatch(GdkEvent* event) {
   if (exit_type_ == EXIT_ALL || exit_type_ == EXIT_DESTROYED) {
     gtk_main_do_event(event);
     return false;
   }
 
   switch (event->type) {
     case GDK_KEY_PRESS: {
-      base::KeyboardCode win_keycode =
-          base::WindowsKeyCodeForGdkKeyCode(event->key.keyval);
+      app::KeyboardCode win_keycode =
+          app::WindowsKeyCodeForGdkKeyCode(event->key.keyval);
 
       if (!OnKeyDown(win_keycode))
         return false;
 
       // OnKeyDown may have set exit_type_.
       if (exit_type_ != EXIT_NONE)
         return false;
 
       guint32 keycode = gdk_keyval_to_unicode(event->key.keyval);
       if (keycode)
@@ skipping 18 matching lines @@
 
 bool MenuController::OnKeyDown(int key_code
 #if defined(OS_WIN)
                                , const MSG& msg
 #else
 #endif
                                ) {
   DCHECK(blocking_run_);
 
   switch (key_code) {
-    case base::VKEY_UP:
+    case app::VKEY_UP:
       IncrementSelection(-1);
       break;
 
-    case base::VKEY_DOWN:
+    case app::VKEY_DOWN:
       IncrementSelection(1);
       break;
 
     // Handling of VK_RIGHT and VK_LEFT is different depending on the UI
     // layout.
-    case base::VKEY_RIGHT:
+    case app::VKEY_RIGHT:
       if (base::i18n::IsRTL())
         CloseSubmenu();
       else
         OpenSubmenuChangeSelectionIfCan();
       break;
 
-    case base::VKEY_LEFT:
+    case app::VKEY_LEFT:
       if (base::i18n::IsRTL())
         OpenSubmenuChangeSelectionIfCan();
       else
         CloseSubmenu();
       break;
 
-    case base::VKEY_SPACE:
+    case app::VKEY_SPACE:
       SendAcceleratorToHotTrackedView();
       break;
 
-    case base::VKEY_RETURN:
+    case app::VKEY_RETURN:
       if (pending_state_.item) {
         if (pending_state_.item->HasSubmenu()) {
           OpenSubmenuChangeSelectionIfCan();
         } else if (!SendAcceleratorToHotTrackedView() &&
                    pending_state_.item->IsEnabled()) {
           Accept(pending_state_.item, 0);
           return false;
         }
       }
       break;
 
-    case base::VKEY_ESCAPE:
+    case app::VKEY_ESCAPE:
       if (!state_.item->GetParentMenuItem() ||
           (!state_.item->GetParentMenuItem()->GetParentMenuItem() &&
            (!state_.item->HasSubmenu() ||
             !state_.item->GetSubmenu()->IsShowing()))) {
         // User pressed escape and only one menu is shown, cancel it.
         Cancel(EXIT_OUTERMOST);
         return false;
       } else {
         CloseSubmenu();
       }
@@ skipping 42 matching lines @@
   instance_count--;
   DLOG(INFO) << "destroyed MC, count=" << instance_count;
 #endif
 }
 
 bool MenuController::SendAcceleratorToHotTrackedView() {
   View* hot_view = GetFirstHotTrackedView(pending_state_.item);
   if (!hot_view)
     return false;
 
-  Accelerator accelerator(base::VKEY_RETURN, false, false, false);
+  Accelerator accelerator(app::VKEY_RETURN, false, false, false);
   hot_view->AcceleratorPressed(accelerator);
   hot_view->SetHotTracked(true);
   return true;
 }
 
 void MenuController::UpdateInitialLocation(
     const gfx::Rect& bounds,
     MenuItemView::AnchorPosition position) {
   pending_state_.initial_bounds = bounds;
   if (bounds.height() > 1) {
@@ skipping 794 matching lines @@
 
   MouseEvent release_event(Event::ET_MOUSE_RELEASED, -1, -1, 0);
   // Reset the active_mouse_view_ before sending mouse released. That way if if
   // calls back to use we aren't in a weird state.
   View* active_view = active_mouse_view_;
   active_mouse_view_ = NULL;
   active_view->OnMouseReleased(release_event, true);
 }
 
 }  // namespace views