Move app/key* to ui/base/keycodes/*

views/focus/focus_manager.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/focus/focus_manager.h"
 
 #include <algorithm>
 
 #include "build/build_config.h"
 
 #if defined(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
-#include "app/keyboard_codes.h"
 #include "base/logging.h"
+#include "ui/base/keycodes/keyboard_codes.h"
 #include "views/accelerator.h"
 #include "views/focus/focus_search.h"
 #include "views/focus/view_storage.h"
 #include "views/view.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget.h"
 
 namespace views {
 
 // FocusManager::WidgetFocusManager ---------------------------------
@@ skipping 86 matching lines @@
     return false;
   }
 #else
   if (IsTabTraversalKeyEvent(event)) {
     AdvanceFocus(event.IsShiftDown());
     return false;
   }
 #endif
 
   // Intercept arrow key messages to switch between grouped views.
-  app::KeyboardCode key_code = event.GetKeyCode();
+  ui::KeyboardCode key_code = event.GetKeyCode();
   if (focused_view_ && focused_view_->GetGroup() != -1 &&
-      (key_code == app::VKEY_UP || key_code == app::VKEY_DOWN ||
-       key_code == app::VKEY_LEFT || key_code == app::VKEY_RIGHT)) {
-    bool next = (key_code == app::VKEY_RIGHT || key_code == app::VKEY_DOWN);
+      (key_code == ui::VKEY_UP || key_code == ui::VKEY_DOWN ||
+       key_code == ui::VKEY_LEFT || key_code == ui::VKEY_RIGHT)) {
+    bool next = (key_code == ui::VKEY_RIGHT || key_code == ui::VKEY_DOWN);
     std::vector<View*> views;
     focused_view_->GetParent()->GetViewsWithGroup(focused_view_->GetGroup(),
                                                   &views);
     std::vector<View*>::const_iterator iter = std::find(views.begin(),
                                                         views.end(),
                                                         focused_view_);
     DCHECK(iter != views.end());
     int index = static_cast<int>(iter - views.begin());
     index += next ? 1 : -1;
     if (index < 0) {
@@ skipping 364 matching lines @@
 AcceleratorTarget* FocusManager::GetCurrentTargetForAccelerator(
     const views::Accelerator& accelerator) const {
   AcceleratorMap::const_iterator map_iter = accelerators_.find(accelerator);
   if (map_iter == accelerators_.end() || map_iter->second.empty())
     return NULL;
   return map_iter->second.front();
 }
 
 // static
 bool FocusManager::IsTabTraversalKeyEvent(const KeyEvent& key_event) {
-  return key_event.GetKeyCode() == app::VKEY_TAB &&
+  return key_event.GetKeyCode() == ui::VKEY_TAB &&
          !key_event.IsControlDown();
 }
 
 void FocusManager::ViewRemoved(View* parent, View* removed) {
   if (focused_view_ && focused_view_ == removed)
     ClearFocus();
 }
 
 void FocusManager::AddFocusChangeListener(FocusChangeListener* listener) {
   DCHECK(std::find(focus_change_listeners_.begin(),
                    focus_change_listeners_.end(), listener) ==
       focus_change_listeners_.end()) << "Adding a listener twice.";
   focus_change_listeners_.push_back(listener);
 }
 
 void FocusManager::RemoveFocusChangeListener(FocusChangeListener* listener) {
   FocusChangeListenerList::iterator place =
       std::find(focus_change_listeners_.begin(), focus_change_listeners_.end(),
                 listener);
   if (place == focus_change_listeners_.end()) {
     NOTREACHED() << "Removing a listener that isn't registered.";
     return;
   }
   focus_change_listeners_.erase(place);
 }
 
 }  // namespace views