Experimental Extension Keybinding (first cut).

ui/views/focus/focus_manager_unittest.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 "base/utf_string_conversions.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/views/controls/button/text_button.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/focus/accelerator_handler.h"
 #include "ui/views/focus/focus_manager_factory.h"
@@ skipping 192 matching lines @@
 
   int accelerator_count() const { return accelerator_count_; }
 
   void set_can_handle_accelerators(bool can_handle_accelerators) {
     can_handle_accelerators_ = can_handle_accelerators;
   }
 
  private:
   int accelerator_count_;  // number of times that the accelerator is activated
   bool process_accelerator_;  // return value of AcceleratorPressed
-  bool can_handle_accelerators_; // return value of CanHandleAccelerators
+  bool can_handle_accelerators_;  // return value of CanHandleAccelerators
 
   DISALLOW_COPY_AND_ASSIGN(TestAcceleratorTarget);
 };
 
 TEST_F(FocusManagerTest, CallsNormalAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
   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));
 
   // Register targets.
-  focus_manager->RegisterAccelerator(return_accelerator, &return_target);
-  focus_manager->RegisterAccelerator(escape_accelerator, &escape_target);
+  focus_manager->RegisterAccelerator(return_accelerator,
+                                     ui::AcceleratorManager::kNormalPriority,
+                                     &return_target);
+  focus_manager->RegisterAccelerator(escape_accelerator,
+                                     ui::AcceleratorManager::kNormalPriority,
+                                     &escape_target);
 
   // Checks if the correct target is registered.
   EXPECT_EQ(&return_target,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
   EXPECT_EQ(&escape_target,
             focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
 
   // Hitting the return key.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 1);
   EXPECT_EQ(escape_target.accelerator_count(), 0);
 
   // Hitting the escape key.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 1);
   EXPECT_EQ(escape_target.accelerator_count(), 1);
 
   // Register another target for the return key.
   TestAcceleratorTarget return_target2(true);
   EXPECT_EQ(return_target2.accelerator_count(), 0);
-  focus_manager->RegisterAccelerator(return_accelerator, &return_target2);
+  focus_manager->RegisterAccelerator(return_accelerator,
+                                     ui::AcceleratorManager::kNormalPriority,
+                                     &return_target2);
   EXPECT_EQ(&return_target2,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
   // Hitting the return key; return_target2 has the priority.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 1);
   EXPECT_EQ(return_target2.accelerator_count(), 1);
 
   // Register a target that does not process the accelerator event.
   TestAcceleratorTarget return_target3(false);
   EXPECT_EQ(return_target3.accelerator_count(), 0);
-  focus_manager->RegisterAccelerator(return_accelerator, &return_target3);
+  focus_manager->RegisterAccelerator(return_accelerator,
+                                     ui::AcceleratorManager::kNormalPriority,
+                                     &return_target3);
   EXPECT_EQ(&return_target3,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
   // Hitting the return key.
   // Since the event handler of return_target3 returns false, return_target2
   // should be called too.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(return_target.accelerator_count(), 1);
   EXPECT_EQ(return_target2.accelerator_count(), 2);
   EXPECT_EQ(return_target3.accelerator_count(), 1);
@@ skipping 22 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);
 }
 
+TEST_F(FocusManagerTest, HighPriorityHandlers) {
+  FocusManager* focus_manager = GetFocusManager();
+  ui::Accelerator escape_accelerator(ui::VKEY_ESCAPE, false, false, false);
+
+  TestAcceleratorTarget escape_target_high(true);
+  TestAcceleratorTarget escape_target_normal(true);
+  EXPECT_EQ(escape_target_high.accelerator_count(), 0);
+  EXPECT_EQ(escape_target_normal.accelerator_count(), 0);
+  EXPECT_EQ(NULL,
+      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_FALSE(focus_manager->HasPriorityHandler(escape_accelerator));
+
+  // Register high priority target.
+  focus_manager->RegisterAccelerator(escape_accelerator,
+                                     ui::AcceleratorManager::kHighPriority,
+                                     &escape_target_high);
+  EXPECT_EQ(&escape_target_high,
+     focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator));
+
+  // Hit the escape key.
+  EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
+  EXPECT_EQ(escape_target_high.accelerator_count(), 1);
+  EXPECT_EQ(escape_target_normal.accelerator_count(), 0);
+
+  // Add a normal priority target and make sure it doesn't see the key.
+  focus_manager->RegisterAccelerator(escape_accelerator,
+                                     ui::AcceleratorManager::kNormalPriority,
+                                     &escape_target_normal);
+
+  // Checks if the correct target is registered (same as before, the high
+  // priority one).
+  EXPECT_EQ(&escape_target_high,
+      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator));
+
+  // Hit the escape key.
+  EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
+  EXPECT_EQ(escape_target_high.accelerator_count(), 2);
+  EXPECT_EQ(escape_target_normal.accelerator_count(), 0);
+
+  // Unregister the high priority accelerator.
+  focus_manager->UnregisterAccelerator(escape_accelerator, &escape_target_high);
+  EXPECT_EQ(&escape_target_normal,
+      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_FALSE(focus_manager->HasPriorityHandler(escape_accelerator));
+
+  // Hit the escape key.
+  EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
+  EXPECT_EQ(escape_target_high.accelerator_count(), 2);
+  EXPECT_EQ(escape_target_normal.accelerator_count(), 1);
+
+  // Add the high priority target back and make sure it starts seeing the key.
+  focus_manager->RegisterAccelerator(escape_accelerator,
+                                     ui::AcceleratorManager::kHighPriority,
+                                     &escape_target_high);
+  EXPECT_EQ(&escape_target_high,
+      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator));
+
+  // Hit the escape key.
+  EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
+  EXPECT_EQ(escape_target_high.accelerator_count(), 3);
+  EXPECT_EQ(escape_target_normal.accelerator_count(), 1);
+
+  // Unregister the normal priority accelerator.
+  focus_manager->UnregisterAccelerator(
+      escape_accelerator, &escape_target_normal);
+  EXPECT_EQ(&escape_target_high,
+      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_TRUE(focus_manager->HasPriorityHandler(escape_accelerator));
+
+  // Hit the escape key.
+  EXPECT_TRUE(focus_manager->ProcessAccelerator(escape_accelerator));
+  EXPECT_EQ(escape_target_high.accelerator_count(), 4);
+  EXPECT_EQ(escape_target_normal.accelerator_count(), 1);
+
+  // Unregister the high priority accelerator.
+  focus_manager->UnregisterAccelerator(escape_accelerator, &escape_target_high);
+  EXPECT_EQ(NULL,
+      focus_manager->GetCurrentTargetForAccelerator(escape_accelerator));
+  EXPECT_FALSE(focus_manager->HasPriorityHandler(escape_accelerator));
+
+  // Hit the escape key (no change, no targets registered).
+  EXPECT_FALSE(focus_manager->ProcessAccelerator(escape_accelerator));
+  EXPECT_EQ(escape_target_high.accelerator_count(), 4);
+  EXPECT_EQ(escape_target_normal.accelerator_count(), 1);
+}
+
 TEST_F(FocusManagerTest, CallsEnabledAcceleratorTargetsOnly) {
   FocusManager* focus_manager = GetFocusManager();
   ui::Accelerator return_accelerator(ui::VKEY_RETURN, false, false, false);
 
   TestAcceleratorTarget return_target1(true);
   TestAcceleratorTarget return_target2(true);
 
-  focus_manager->RegisterAccelerator(return_accelerator, &return_target1);
-  focus_manager->RegisterAccelerator(return_accelerator, &return_target2);
+  focus_manager->RegisterAccelerator(return_accelerator,
+                                     ui::AcceleratorManager::kNormalPriority,
+                                     &return_target1);
+  focus_manager->RegisterAccelerator(return_accelerator,
+                                     ui::AcceleratorManager::kNormalPriority,
+                                     &return_target2);
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(0, return_target1.accelerator_count());
   EXPECT_EQ(1, return_target2.accelerator_count());
 
   // If CanHandleAccelerators() return false, FocusManager shouldn't call
   // AcceleratorPressed().
   return_target2.set_can_handle_accelerators(false);
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(1, return_target1.accelerator_count());
   EXPECT_EQ(1, return_target2.accelerator_count());
@@ skipping 44 matching lines @@
 
 TEST_F(FocusManagerTest, CallsSelfDeletingAcceleratorTarget) {
   FocusManager* focus_manager = GetFocusManager();
   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);
+  focus_manager->RegisterAccelerator(return_accelerator,
+                                     ui::AcceleratorManager::kNormalPriority,
+                                     &target);
   EXPECT_EQ(&target,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
   // Hitting the return key. The target will be unregistered.
   EXPECT_TRUE(focus_manager->ProcessAccelerator(return_accelerator));
   EXPECT_EQ(target.accelerator_count(), 1);
   EXPECT_EQ(NULL,
             focus_manager->GetCurrentTargetForAccelerator(return_accelerator));
 
   // Hitting the return key again; nothing should happen.
@@ skipping 104 matching lines @@
 
   // Test window, button and focus manager should all be destructed.
   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());
 }
 #endif
 
 }  // namespace views