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

views/focus/focus_manager_unittest.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 "base/logging.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/keycodes/keyboard_codes.h"
+#include "ui/base/models/accelerator.h"
 #include "ui/base/models/combobox_model.h"
 #include "ui/gfx/rect.h"
 #include "views/background.h"
 #include "views/border.h"
 #include "views/controls/button/checkbox.h"
 #include "views/controls/button/radio_button.h"
 #include "views/controls/combobox/combobox.h"
 #include "views/controls/combobox/native_combobox_wrapper.h"
 #include "views/controls/label.h"
 #include "views/controls/link.h"
@@ skipping 1263 matching lines @@
       GetFocusManager()->AdvanceFocus(true);
       View* focused_view = GetFocusManager()->GetFocusedView();
       EXPECT_TRUE(focused_view != NULL);
       if (focused_view)
         EXPECT_EQ(kRightTraversalIDs[j], focused_view->id());
     }
   }
 }
 
 // Counts accelerator calls.
-class TestAcceleratorTarget : public AcceleratorTarget {
+class TestAcceleratorTarget : public ui::AcceleratorTarget {
  public:
   explicit TestAcceleratorTarget(bool process_accelerator)
       : accelerator_count_(0), process_accelerator_(process_accelerator) {}
 
-  virtual bool AcceleratorPressed(const Accelerator& accelerator) {
+  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) {
     ++accelerator_count_;
     return process_accelerator_;
   }
 
   int accelerator_count() const { return accelerator_count_; }
 
  private:
   int accelerator_count_;  // number of times that the accelerator is activated
   bool process_accelerator_;  // return value of AcceleratorPressed
 
   DISALLOW_COPY_AND_ASSIGN(TestAcceleratorTarget);
 };
 
 TEST_F(FocusManagerTest, CallsNormalAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
-  Accelerator return_accelerator(ui::VKEY_RETURN, false, false, false);
-  Accelerator escape_accelerator(ui::VKEY_ESCAPE, false, false, false);
+  ui::Accelerator return_accelerator(ui::VKEY_RETURN, false, false, false);
+  ui::Accelerator escape_accelerator(ui::VKEY_ESCAPE, false, false, false);
 
   TestAcceleratorTarget return_target(true);
   TestAcceleratorTarget escape_target(true);
   EXPECT_EQ(return_target.accelerator_count(), 0);
   EXPECT_EQ(escape_target.accelerator_count(), 0);
   EXPECT_EQ(NULL,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
   EXPECT_EQ(NULL,
             focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
 
@@ skipping 69 matching lines @@
   // Hitting the return key and the escape key. Nothing should happen.
   EXPECT_FALSE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 2);
   EXPECT_EQ(return_target2.accelerator_count(), 2);
   EXPECT_EQ(return_target3.accelerator_count(), 2);
   EXPECT_FALSE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(escape_target.accelerator_count(), 1);
 }
 
 // Unregisters itself when its accelerator is invoked.
-class SelfUnregisteringAcceleratorTarget : public AcceleratorTarget {
+class SelfUnregisteringAcceleratorTarget : public ui::AcceleratorTarget {
  public:
-  SelfUnregisteringAcceleratorTarget(Accelerator accelerator,
+  SelfUnregisteringAcceleratorTarget(ui::Accelerator accelerator,
                                      FocusManager* focus_manager)
       : accelerator_(accelerator),
         focus_manager_(focus_manager),
         accelerator_count_(0) {
   }
 
-  virtual bool AcceleratorPressed(const Accelerator& accelerator) {
+  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) {
     ++accelerator_count_;
     focus_manager_->UnregisterAccelerator(accelerator, this);
     return true;
   }
 
   int accelerator_count() const { return accelerator_count_; }
 
  private:
-  Accelerator accelerator_;
+  ui::Accelerator accelerator_;
   FocusManager* focus_manager_;
   int accelerator_count_;
 
   DISALLOW_COPY_AND_ASSIGN(SelfUnregisteringAcceleratorTarget);
 };
 
 TEST_F(FocusManagerTest, CallsSelfDeletingAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
-  Accelerator return_accelerator(ui::VKEY_RETURN, false, false, false);
+  ui::Accelerator return_accelerator(ui::VKEY_RETURN, false, false, false);
   SelfUnregisteringAcceleratorTarget target(return_accelerator, focus_manager);
   EXPECT_EQ(target.accelerator_count(), 0);
   EXPECT_EQ(NULL,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
   // Register the target.
   focus_manager->RegisterAccelerator(return_accelerator, &target);
   EXPECT_EQ(&target,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
@@ skipping 16 matching lines @@
   virtual bool OnKeyPressed(const KeyEvent& e) {
     keys_pressed_.push_back(e.key_code());
     return true;
   }
 
   virtual bool OnKeyReleased(const KeyEvent& e) {
     keys_released_.push_back(e.key_code());
     return true;
   }
 
-  virtual bool AcceleratorPressed(const Accelerator& accelerator) {
+  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) {
     accelerator_pressed_ = true;
     return true;
   }
 
   void Reset() {
     accelerator_pressed_ = false;
     keys_pressed_.clear();
     keys_released_.clear();
   }
 
@@ skipping 18 matching lines @@
 };
 
 #if defined(OS_WIN)
 // This test is now Windows only. Linux Views port does not handle accelerator
 // keys in AcceleratorHandler anymore. The logic has been moved into
 // NativeWidgetGtk::OnKeyEvent().
 // Tests that the keyup messages are eaten for accelerators.
 TEST_F(FocusManagerTest, IgnoreKeyupForAccelerators) {
   FocusManager* focus_manager = GetFocusManager();
   MessageTrackingView* mtv = new MessageTrackingView();
-  mtv->AddAccelerator(Accelerator(ui::VKEY_0, false, false, false));
-  mtv->AddAccelerator(Accelerator(ui::VKEY_1, false, false, false));
+  mtv->AddAccelerator(ui::Accelerator(ui::VKEY_0, false, false, false));
+  mtv->AddAccelerator(ui::Accelerator(ui::VKEY_1, false, false, false));
   content_view_->AddChildView(mtv);
   focus_manager->SetFocusedView(mtv);
 
   // First send a non-accelerator key sequence.
   PostKeyDown(ui::VKEY_9);
   PostKeyUp(ui::VKEY_9);
   AcceleratorHandler accelerator_handler;
   MessageLoopForUI::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   MessageLoopForUI::current()->RunWithDispatcher(&accelerator_handler);
   // Make sure we get a key-up and key-down.
@@ skipping 232 matching lines @@
   ASSERT_EQ(3, static_cast<int>(dtor_tracker_.size()));
 
   // Focus manager should be the last one to destruct.
   ASSERT_STREQ("FocusManagerDtorTracked", dtor_tracker_[2].c_str());
 
   // Clear window_ so that we don't try to close it again.
   window_ = NULL;
 }
 
 }  // namespace views