Move views::Accelerator to ui in order to use it from aura code.

views/focus/focus_manager.cc

 // Copyright (c) 2011 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 "base/auto_reset.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ui/base/keycodes/keyboard_codes.h"
-#include "views/accelerator.h"
+#include "ui/base/models/accelerator.h"
 #include "views/focus/focus_search.h"
 #include "views/focus/view_storage.h"
 #include "views/focus/widget_focus_manager.h"
 #include "views/view.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget.h"
 
 namespace views {
 
 FocusManager::FocusManager(Widget* widget)
@@ skipping 55 matching lines @@
     } else if (index >= static_cast<int>(views.size())) {
       index = 0;
     }
     SetFocusedViewWithReason(views[index], kReasonFocusTraversal);
     return false;
   }
 
   // Process keyboard accelerators.
   // If the key combination matches an accelerator, the accelerator is
   // triggered, otherwise the key event is processed as usual.
-  Accelerator accelerator(event.key_code(),
-                          event.IsShiftDown(),
-                          event.IsControlDown(),
-                          event.IsAltDown());
+  ui::Accelerator accelerator(event.key_code(),
+                              event.IsShiftDown(),
+                              event.IsControlDown(),
+                              event.IsAltDown());
   if (ProcessAccelerator(accelerator)) {
     // If a shortcut was activated for this keydown message, do not propagate
     // the event further.
     return false;
   }
   return true;
 }
 
 void FocusManager::ValidateFocusedView() {
   if (focused_view_) {
@@ skipping 249 matching lines @@
         reverse,
         FocusSearch::DOWN,
         false,
         &new_focus_traversable,
         &new_starting_view);
   }
   return v;
 }
 
 void FocusManager::RegisterAccelerator(
-    const Accelerator& accelerator,
-    AcceleratorTarget* target) {
+    const ui::Accelerator& accelerator,
+    ui::AcceleratorTarget* target) {
   AcceleratorTargetList& targets = accelerators_[accelerator];
   DCHECK(std::find(targets.begin(), targets.end(), target) == targets.end())
       << "Registering the same target multiple times";
   targets.push_front(target);
 }
 
-void FocusManager::UnregisterAccelerator(const Accelerator& accelerator,
-                                         AcceleratorTarget* target) {
+void FocusManager::UnregisterAccelerator(const ui::Accelerator& accelerator,
+                                         ui::AcceleratorTarget* target) {
   AcceleratorMap::iterator map_iter = accelerators_.find(accelerator);
   if (map_iter == accelerators_.end()) {
     NOTREACHED() << "Unregistering non-existing accelerator";
     return;
   }
 
   AcceleratorTargetList* targets = &map_iter->second;
   AcceleratorTargetList::iterator target_iter =
       std::find(targets->begin(), targets->end(), target);
   if (target_iter == targets->end()) {
     NOTREACHED() << "Unregistering accelerator for wrong target";
     return;
   }
 
   targets->erase(target_iter);
 }
 
-void FocusManager::UnregisterAccelerators(AcceleratorTarget* target) {
+void FocusManager::UnregisterAccelerators(ui::AcceleratorTarget* target) {
   for (AcceleratorMap::iterator map_iter = accelerators_.begin();
        map_iter != accelerators_.end(); ++map_iter) {
     AcceleratorTargetList* targets = &map_iter->second;
     targets->remove(target);
   }
 }
 
-bool FocusManager::ProcessAccelerator(const Accelerator& accelerator) {
+bool FocusManager::ProcessAccelerator(const ui::Accelerator& accelerator) {
   AcceleratorMap::iterator map_iter = accelerators_.find(accelerator);
   if (map_iter != accelerators_.end()) {
     // We have to copy the target list here, because an AcceleratorPressed
     // event handler may modify the list.
     AcceleratorTargetList targets(map_iter->second);
     for (AcceleratorTargetList::iterator iter = targets.begin();
          iter != targets.end(); ++iter) {
       if ((*iter)->AcceleratorPressed(accelerator))
         return true;
     }
   }
   return false;
 }
 
-AcceleratorTarget* FocusManager::GetCurrentTargetForAccelerator(
-    const views::Accelerator& accelerator) const {
+ui::AcceleratorTarget* FocusManager::GetCurrentTargetForAccelerator(
+    const ui::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();
 }
 
 void FocusManager::FocusNativeView(gfx::NativeView native_view) {
   widget_->FocusNativeView(native_view);
 }
 
@@ skipping 13 matching lines @@
 
 void FocusManager::AddFocusChangeListener(FocusChangeListener* listener) {
   focus_change_listeners_.AddObserver(listener);
 }
 
 void FocusManager::RemoveFocusChangeListener(FocusChangeListener* listener) {
   focus_change_listeners_.RemoveObserver(listener);
 }
 
 }  // namespace views