Remove views::KeyEvent, replacing uses of it with ui::KeyEvent.

ui/views/focus/focus_manager.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/focus/focus_manager.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ui/base/accelerators/accelerator.h"
+#include "ui/base/event.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/views/focus/focus_manager_delegate.h"
 #include "ui/views/focus/focus_search.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/focus/widget_focus_manager.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
 
 namespace views {
@@ skipping 11 matching lines @@
 #endif
       is_changing_focus_(false) {
   DCHECK(widget_);
   stored_focused_view_storage_id_ =
       ViewStorage::GetInstance()->CreateStorageID();
 }
 
 FocusManager::~FocusManager() {
 }
 
-bool FocusManager::OnKeyEvent(const KeyEvent& event) {
+bool FocusManager::OnKeyEvent(const ui::KeyEvent& event) {
   const int key_code = event.key_code();
 
 #if defined(USE_X11)
   // TODO(ben): beng believes that this should be done in
   // RootWindowHosLinux for aura/linux.
 
   // Always reset |should_handle_menu_key_release_| unless we are handling a
   // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
   // be activated when handling a VKEY_MENU key release event which is preceded
   // by an un-handled VKEY_MENU key press event.
@@ skipping 381 matching lines @@
 }
 
 bool FocusManager::ProcessAccelerator(const ui::Accelerator& accelerator) {
   if (accelerator_manager_->Process(accelerator))
     return true;
   if (delegate_.get())
     return delegate_->ProcessAccelerator(accelerator);
   return false;
 }
 
-void FocusManager::MaybeResetMenuKeyState(const KeyEvent& key) {
+void FocusManager::MaybeResetMenuKeyState(const ui::KeyEvent& key) {
 #if defined(USE_X11)
   // Always reset |should_handle_menu_key_release_| unless we are handling a
   // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
   // be activated when handling a VKEY_MENU key release event which is preceded
   // by an unhandled VKEY_MENU key press event. See also HandleKeyboardEvent().
   if (key.key_code() != ui::VKEY_MENU || key.type() != ui::ET_KEY_RELEASED)
     should_handle_menu_key_release_ = false;
 #endif
 }
 
 ui::AcceleratorTarget* FocusManager::GetCurrentTargetForAccelerator(
     const ui::Accelerator& accelerator) const {
   ui::AcceleratorTarget* target =
       accelerator_manager_->GetCurrentTarget(accelerator);
   if (!target && delegate_.get())
     target = delegate_->GetCurrentTargetForAccelerator(accelerator);
   return target;
 }
 
 bool FocusManager::HasPriorityHandler(
     const ui::Accelerator& accelerator) const {
   return accelerator_manager_->HasPriorityHandler(accelerator);
 }
 
 // static
-bool FocusManager::IsTabTraversalKeyEvent(const KeyEvent& key_event) {
+bool FocusManager::IsTabTraversalKeyEvent(const ui::KeyEvent& key_event) {
   return key_event.key_code() == ui::VKEY_TAB && !key_event.IsControlDown();
 }
 
 void FocusManager::ViewRemoved(View* removed) {
   // If the view being removed contains (or is) the focused view,
   // clear the focus.  However, it's not safe to call ClearFocus()
   // (and in turn ClearNativeFocus()) here because ViewRemoved() can
   // be called while the top level widget is being destroyed.
   if (focused_view_ && removed->Contains(focused_view_))
     SetFocusedView(NULL);
 }
 
 void FocusManager::AddFocusChangeListener(FocusChangeListener* listener) {
   focus_change_listeners_.AddObserver(listener);
 }
 
 void FocusManager::RemoveFocusChangeListener(FocusChangeListener* listener) {
   focus_change_listeners_.RemoveObserver(listener);
 }
 
 }  // namespace views