Revert 58388 - Revert 58215 - Revert 58186 - Move the keyboard files from bas...

views/focus/focus_manager_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
 #include "app/combobox_model.h"
-#include "app/keyboard_codes.h"
+#include "base/keyboard_codes.h"
 #include "base/logging.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "gfx/rect.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "views/background.h"
 #include "views/border.h"
 #include "views/controls/button/checkbox.h"
 #include "views/controls/button/native_button.h"
@@ skipping 10 matching lines @@
 #include "views/focus/accelerator_handler.h"
 #include "views/widget/root_view.h"
 #include "views/window/non_client_view.h"
 #include "views/window/window.h"
 #include "views/window/window_delegate.h"
 
 #if defined(OS_WIN)
 #include "views/widget/widget_win.h"
 #include "views/window/window_win.h"
 #elif defined(OS_LINUX)
-#include "app/keyboard_code_conversion_gtk.h"
+#include "base/keyboard_code_conversion_gtk.h"
 #include "views/window/window_gtk.h"
 #endif
 
 namespace {
 const int kWindowWidth = 600;
 const int kWindowHeight = 500;
 
 int count = 1;
 
 const int kTopCheckBoxID = count++;  // 1
@@ skipping 152 matching lines @@
   Window* window_;
   View* content_view_;
 
   void AddFocusChangeListener(FocusChangeListener* listener) {
     ASSERT_FALSE(focus_change_listener_);
     focus_change_listener_ = listener;
     GetFocusManager()->AddFocusChangeListener(listener);
   }
 
 #if defined(OS_WIN)
-  void PostKeyDown(app::KeyboardCode key_code) {
+  void PostKeyDown(base::KeyboardCode key_code) {
     ::PostMessage(window_->GetNativeWindow(), WM_KEYDOWN, key_code, 0);
   }
 
-  void PostKeyUp(app::KeyboardCode key_code) {
+  void PostKeyUp(base::KeyboardCode key_code) {
     ::PostMessage(window_->GetNativeWindow(), WM_KEYUP, key_code, 0);
   }
 #elif defined(OS_LINUX)
-  void PostKeyDown(app::KeyboardCode key_code) {
+  void PostKeyDown(base::KeyboardCode key_code) {
     PostKeyEvent(key_code, true);
   }
 
-  void PostKeyUp(app::KeyboardCode key_code) {
+  void PostKeyUp(base::KeyboardCode key_code) {
     PostKeyEvent(key_code, false);
   }
 
-  void PostKeyEvent(app::KeyboardCode key_code, bool pressed) {
+  void PostKeyEvent(base::KeyboardCode key_code, bool pressed) {
     int keyval = GdkKeyCodeForWindowsKeyCode(key_code, false);
     GdkKeymapKey* keys;
     gint n_keys;
     gdk_keymap_get_entries_for_keyval(
         gdk_keymap_get_default(),
         keyval,
         &keys,
         &n_keys);
     GdkEvent* event = gdk_event_new(pressed ? GDK_KEY_PRESS : GDK_KEY_RELEASE);
     GdkEventKey* key_event = reinterpret_cast<GdkEventKey*>(event);
@@ skipping 1054 matching lines @@
 
  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(app::VKEY_RETURN, false, false, false);
-  Accelerator escape_accelerator(app::VKEY_ESCAPE, false, false, false);
+  Accelerator return_accelerator(base::VKEY_RETURN, false, false, false);
+  Accelerator escape_accelerator(base::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 96 matching lines @@
  private:
   Accelerator accelerator_;
   FocusManager* focus_manager_;
   int accelerator_count_;
 
   DISALLOW_COPY_AND_ASSIGN(SelfUnregisteringAcceleratorTarget);
 };
 
 TEST_F(FocusManagerTest, CallsSelfDeletingAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
-  Accelerator return_accelerator(app::VKEY_RETURN, false, false, false);
+  Accelerator return_accelerator(base::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 27 matching lines @@
     accelerator_pressed_ = true;
     return true;
   }
 
   void Reset() {
     accelerator_pressed_ = false;
     keys_pressed_.clear();
     keys_released_.clear();
   }
 
-  const std::vector<app::KeyboardCode>& keys_pressed() const {
+  const std::vector<base::KeyboardCode>& keys_pressed() const {
     return keys_pressed_;
   }
 
-  const std::vector<app::KeyboardCode>& keys_released() const {
+  const std::vector<base::KeyboardCode>& keys_released() const {
     return keys_released_;
   }
 
   bool accelerator_pressed() const {
     return accelerator_pressed_;
   }
 
  private:
   bool accelerator_pressed_;
-  std::vector<app::KeyboardCode> keys_pressed_;
-  std::vector<app::KeyboardCode> keys_released_;
+  std::vector<base::KeyboardCode> keys_pressed_;
+  std::vector<base::KeyboardCode> keys_released_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageTrackingView);
 };
 
 #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
 // WidgetGtk::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(app::VKEY_0, false, false, false));
-  mtv->AddAccelerator(Accelerator(app::VKEY_1, false, false, false));
+  mtv->AddAccelerator(Accelerator(base::VKEY_0, false, false, false));
+  mtv->AddAccelerator(Accelerator(base::VKEY_1, false, false, false));
   content_view_->AddChildView(mtv);
   focus_manager->SetFocusedView(mtv);
 
   // First send a non-accelerator key sequence.
-  PostKeyDown(app::VKEY_9);
-  PostKeyUp(app::VKEY_9);
+  PostKeyDown(base::VKEY_9);
+  PostKeyUp(base::VKEY_9);
   AcceleratorHandler accelerator_handler;
   MessageLoopForUI::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   MessageLoopForUI::current()->Run(&accelerator_handler);
   // Make sure we get a key-up and key-down.
   ASSERT_EQ(1U, mtv->keys_pressed().size());
-  EXPECT_EQ(app::VKEY_9, mtv->keys_pressed().at(0));
+  EXPECT_EQ(base::VKEY_9, mtv->keys_pressed().at(0));
   ASSERT_EQ(1U, mtv->keys_released().size());
-  EXPECT_EQ(app::VKEY_9, mtv->keys_released().at(0));
+  EXPECT_EQ(base::VKEY_9, mtv->keys_released().at(0));
   EXPECT_FALSE(mtv->accelerator_pressed());
   mtv->Reset();
 
   // Same thing with repeat and more than one key at once.
-  PostKeyDown(app::VKEY_9);
-  PostKeyDown(app::VKEY_9);
-  PostKeyDown(app::VKEY_8);
-  PostKeyDown(app::VKEY_9);
-  PostKeyDown(app::VKEY_7);
-  PostKeyUp(app::VKEY_9);
-  PostKeyUp(app::VKEY_7);
-  PostKeyUp(app::VKEY_8);
+  PostKeyDown(base::VKEY_9);
+  PostKeyDown(base::VKEY_9);
+  PostKeyDown(base::VKEY_8);
+  PostKeyDown(base::VKEY_9);
+  PostKeyDown(base::VKEY_7);
+  PostKeyUp(base::VKEY_9);
+  PostKeyUp(base::VKEY_7);
+  PostKeyUp(base::VKEY_8);
   MessageLoopForUI::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   MessageLoopForUI::current()->Run(&accelerator_handler);
   // Make sure we get a key-up and key-down.
   ASSERT_EQ(5U, mtv->keys_pressed().size());
-  EXPECT_EQ(app::VKEY_9, mtv->keys_pressed().at(0));
-  EXPECT_EQ(app::VKEY_9, mtv->keys_pressed().at(1));
-  EXPECT_EQ(app::VKEY_8, mtv->keys_pressed().at(2));
-  EXPECT_EQ(app::VKEY_9, mtv->keys_pressed().at(3));
-  EXPECT_EQ(app::VKEY_7, mtv->keys_pressed().at(4));
+  EXPECT_EQ(base::VKEY_9, mtv->keys_pressed().at(0));
+  EXPECT_EQ(base::VKEY_9, mtv->keys_pressed().at(1));
+  EXPECT_EQ(base::VKEY_8, mtv->keys_pressed().at(2));
+  EXPECT_EQ(base::VKEY_9, mtv->keys_pressed().at(3));
+  EXPECT_EQ(base::VKEY_7, mtv->keys_pressed().at(4));
   ASSERT_EQ(3U, mtv->keys_released().size());
-  EXPECT_EQ(app::VKEY_9, mtv->keys_released().at(0));
-  EXPECT_EQ(app::VKEY_7, mtv->keys_released().at(1));
-  EXPECT_EQ(app::VKEY_8, mtv->keys_released().at(2));
+  EXPECT_EQ(base::VKEY_9, mtv->keys_released().at(0));
+  EXPECT_EQ(base::VKEY_7, mtv->keys_released().at(1));
+  EXPECT_EQ(base::VKEY_8, mtv->keys_released().at(2));
   EXPECT_FALSE(mtv->accelerator_pressed());
   mtv->Reset();
 
   // Now send an accelerator key sequence.
-  PostKeyDown(app::VKEY_0);
-  PostKeyUp(app::VKEY_0);
+  PostKeyDown(base::VKEY_0);
+  PostKeyUp(base::VKEY_0);
   MessageLoopForUI::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   MessageLoopForUI::current()->Run(&accelerator_handler);
   EXPECT_TRUE(mtv->keys_pressed().empty());
   EXPECT_TRUE(mtv->keys_released().empty());
   EXPECT_TRUE(mtv->accelerator_pressed());
   mtv->Reset();
 
   // Same thing with repeat and more than one key at once.
-  PostKeyDown(app::VKEY_0);
-  PostKeyDown(app::VKEY_1);
-  PostKeyDown(app::VKEY_1);
-  PostKeyDown(app::VKEY_0);
-  PostKeyDown(app::VKEY_0);
-  PostKeyUp(app::VKEY_1);
-  PostKeyUp(app::VKEY_0);
+  PostKeyDown(base::VKEY_0);
+  PostKeyDown(base::VKEY_1);
+  PostKeyDown(base::VKEY_1);
+  PostKeyDown(base::VKEY_0);
+  PostKeyDown(base::VKEY_0);
+  PostKeyUp(base::VKEY_1);
+  PostKeyUp(base::VKEY_0);
   MessageLoopForUI::current()->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   MessageLoopForUI::current()->Run(&accelerator_handler);
   EXPECT_TRUE(mtv->keys_pressed().empty());
   EXPECT_TRUE(mtv->keys_released().empty());
   EXPECT_TRUE(mtv->accelerator_pressed());
   mtv->Reset();
 }
 #endif
 
 #if defined(OS_WIN)
@@ skipping 150 matching lines @@
   // 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;
 }
 
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace views