Experimental Extension Keybinding (first cut).

Implemented in this cut:

- End-to-end extension keybinding -- in one dimension, that is -- no UI, just basic functionality, such as:
  - Manifest changes to specify keybinding.
  - A simple parser to parse the keybinding from the manifest.
  - An Extension Keybinding Registry object.
  - The ability to open browser action popups, page action popups and send named events to the Extension.

Not implemented:

- All non-Windows specific code.
- Install-success-bubble UI changes (that notify the user of new keybinding -- or of keybinding conflict)
- A UI to show all keybindings and keybinding conflicts, allowing user to reconfigure keybindings.

BUG=27702
TEST=This is tested by an automated test and requires an extension to test manually (one that registers keybinding shortcuts).
Review URL: https://chromiumcodereview.appspot.com/9402018

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@123228 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 220 insertions, 33 deletions

diff --git a/ui/base/accelerators/accelerator_manager.cc b/ui/base/accelerators/accelerator_manager.cc
index d2d70c9..034593d 100644
--- a/ui/base/accelerators/accelerator_manager.cc
+++ b/ui/base/accelerators/accelerator_manager.cc
@@ -17,11 +17,29 @@ AcceleratorManager::~AcceleratorManager() {
 }
 
 void AcceleratorManager::Register(const Accelerator& accelerator,
+                                  HandlerPriority priority,
                                   AcceleratorTarget* target) {
-  AcceleratorTargetList& targets = accelerators_[accelerator];
+  AcceleratorTargetList& targets = accelerators_[accelerator].second;
   DCHECK(std::find(targets.begin(), targets.end(), target) == targets.end())
       << "Registering the same target multiple times";
-  targets.push_front(target);
+
+  // All priority accelerators go to the front of the line.
+  if (priority) {
+    DCHECK(!accelerators_[accelerator].first)
+        << "Only one _priority_ handler can be registered";
+    targets.push_front(target);
+    // Mark that we have a priority accelerator at the front.
+    accelerators_[accelerator].first = true;
+    return;
+  }
+
+  // We are registering a normal priority handler. If no priority accelerator
+  // handler has been registered before us, just add the new handler to the
+  // front. Otherwise, register it after the first (only) priority handler.
+  if (!accelerators_[accelerator].first)
+    targets.push_front(target);
+  else
+    targets.insert(++targets.begin(), target);
 }
 
 void AcceleratorManager::Unregister(const Accelerator& accelerator,
@@ -32,7 +50,7 @@ void AcceleratorManager::Unregister(const Accelerator& accelerator,
     return;
   }
 
-  AcceleratorTargetList* targets = &map_iter->second;
+  AcceleratorTargetList* targets = &map_iter->second.second;
   AcceleratorTargetList::iterator target_iter =
       std::find(targets->begin(), targets->end(), target);
   if (target_iter == targets->end()) {
@@ -40,13 +58,19 @@ void AcceleratorManager::Unregister(const Accelerator& accelerator,
     return;
   }
 
+  // Check to see if we have a priority handler and whether we are removing it.
+  if (accelerators_[accelerator].first && target_iter == targets->begin()) {
+    // We've are taking the priority accelerator away, flip the priority flag.
+    accelerators_[accelerator].first = false;
+  }
+
   targets->erase(target_iter);
 }
 
 void AcceleratorManager::UnregisterAll(AcceleratorTarget* target) {
   for (AcceleratorMap::iterator map_iter = accelerators_.begin();
        map_iter != accelerators_.end(); ++map_iter) {
-    AcceleratorTargetList* targets = &map_iter->second;
+    AcceleratorTargetList* targets = &map_iter->second.second;
     targets->remove(target);
   }
 }
@@ -57,7 +81,7 @@ bool AcceleratorManager::Process(const Accelerator& accelerator) {
   if (map_iter != accelerators_.end() && ShouldHandle(accelerator)) {
     // We have to copy the target list here, because an AcceleratorPressed
     // event handler may modify the list.
-    AcceleratorTargetList targets(map_iter->second);
+    AcceleratorTargetList targets(map_iter->second.second);
     for (AcceleratorTargetList::iterator iter = targets.begin();
          iter != targets.end(); ++iter) {
       if ((*iter)->CanHandleAccelerators() &&
@@ -74,9 +98,24 @@ bool AcceleratorManager::Process(const Accelerator& accelerator) {
 AcceleratorTarget* AcceleratorManager::GetCurrentTarget(
     const Accelerator& accelerator) const {
   AcceleratorMap::const_iterator map_iter = accelerators_.find(accelerator);
-  if (map_iter == accelerators_.end() || map_iter->second.empty())
+  if (map_iter == accelerators_.end() || map_iter->second.second.empty())
     return NULL;
-  return map_iter->second.front();
+  return map_iter->second.second.front();
+}
+
+bool AcceleratorManager::HasPriorityHandler(
+    const Accelerator& accelerator) const {
+  AcceleratorMap::const_iterator map_iter = accelerators_.find(accelerator);
+  if (map_iter == accelerators_.end() || map_iter->second.second.empty())
+    return false;
+
+  // Check if we have a priority handler. If not, there's no more work needed.
+  if (!map_iter->second.first)
+    return false;
+
+  // If the priority handler says it cannot handle the accelerator, we must not
+  // count it as one.
+  return map_iter->second.second.front()->CanHandleAccelerators();
 }
 
 bool AcceleratorManager::ShouldHandle(const Accelerator& accelerator) const {
diff --git a/ui/base/accelerators/accelerator_manager.h b/ui/base/accelerators/accelerator_manager.h
index c54ea1d..7164acb 100644
--- a/ui/base/accelerators/accelerator_manager.h
+++ b/ui/base/accelerators/accelerator_manager.h
@@ -8,6 +8,7 @@
 
 #include <list>
 #include <map>
+#include <utility>
 
 #include "base/basictypes.h"
 #include "ui/base/accelerators/accelerator.h"
@@ -19,19 +20,34 @@ namespace ui {
 // The AcceleratorManger is used to handle keyboard accelerators.
 class UI_EXPORT AcceleratorManager {
  public:
+  enum HandlerPriority {
+    kNormalPriority,
+    kHighPriority,
+  };
+
   AcceleratorManager();
   ~AcceleratorManager();
 
   // Register a keyboard accelerator for the specified target. If multiple
   // targets are registered for an accelerator, a target registered later has
   // higher priority.
+  // |accelerator| is the accelerator to register.
+  // |priority| denotes the priority of the handler.
+  // NOTE: In almost all cases, you should specify kPriorityNormal for this
+  // parameter. Setting it to kPriorityHigh prevents Chrome from sending the
+  // shortcut to the webpage if the renderer has focus, which is not desirable
+  // except for very isolated cases.
+  // |target| is the AcceleratorTarget that handles the event once the
+  // accelerator is pressed.
   // Note that we are currently limited to accelerators that are either:
   // - a key combination including Ctrl or Alt
   // - the escape key
   // - the enter key
   // - any F key (F1, F2, F3 ...)
   // - any browser specific keys (as available on special keyboards)
-  void Register(const Accelerator& accelerator, AcceleratorTarget* target);
+  void Register(const Accelerator& accelerator,
+                HandlerPriority priority,
+                AcceleratorTarget* target);
 
   // Unregister the specified keyboard accelerator for the specified target.
   void Unregister(const Accelerator& accelerator, AcceleratorTarget* target);
@@ -52,12 +68,18 @@ class UI_EXPORT AcceleratorManager {
   // accelerator.
   AcceleratorTarget* GetCurrentTarget(const Accelerator& accelertor) const;
 
+  // Whether the given |accelerator| has a priority handler associated with it.
+  bool HasPriorityHandler(const Accelerator& accelerator) const;
+
  private:
   bool ShouldHandle(const Accelerator& accelerator) const;
 
   // The accelerators and associated targets.
   typedef std::list<AcceleratorTarget*> AcceleratorTargetList;
-  typedef std::map<Accelerator, AcceleratorTargetList> AcceleratorMap;
+  // This construct pairs together a |bool| (denoting whether the list contains
+  // a priority_handler at the front) with the list of AcceleratorTargets.
+  typedef std::pair<bool, AcceleratorTargetList> AcceleratorTargets;
+  typedef std::map<Accelerator, AcceleratorTargets> AcceleratorMap;
   AcceleratorMap accelerators_;
 
   // An event passed to Process() last time.
diff --git a/ui/views/accessible_pane_view.cc b/ui/views/accessible_pane_view.cc
index 09c4a6b..0849c36 100644
--- a/ui/views/accessible_pane_view.cc
+++ b/ui/views/accessible_pane_view.cc
@@ -1,4 +1,4 @@
-// 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.
 
@@ -60,11 +60,13 @@ bool AccessiblePaneView::SetPaneFocus(views::View* initial_focus) {
 
   // Otherwise, set accelerators and start listening for focus change events.
   pane_has_focus_ = true;
-  focus_manager_->RegisterAccelerator(home_key_, this);
-  focus_manager_->RegisterAccelerator(end_key_, this);
-  focus_manager_->RegisterAccelerator(escape_key_, this);
-  focus_manager_->RegisterAccelerator(left_key_, this);
-  focus_manager_->RegisterAccelerator(right_key_, this);
+  ui::AcceleratorManager::HandlerPriority normal =
+      ui::AcceleratorManager::kNormalPriority;
+  focus_manager_->RegisterAccelerator(home_key_, normal, this);
+  focus_manager_->RegisterAccelerator(end_key_, normal, this);
+  focus_manager_->RegisterAccelerator(escape_key_, normal, this);
+  focus_manager_->RegisterAccelerator(left_key_, normal, this);
+  focus_manager_->RegisterAccelerator(right_key_, normal, this);
   focus_manager_->AddFocusChangeListener(this);
 
   return true;
diff --git a/ui/views/focus/focus_manager.cc b/ui/views/focus/focus_manager.cc
index 4ec263c..317a1a7 100644
--- a/ui/views/focus/focus_manager.cc
+++ b/ui/views/focus/focus_manager.cc
@@ -10,7 +10,6 @@
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ui/base/accelerators/accelerator.h"
-#include "ui/base/accelerators/accelerator_manager.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/views/focus/focus_search.h"
 #include "ui/views/focus/view_storage.h"
@@ -74,11 +73,17 @@ bool FocusManager::OnKeyEvent(const KeyEvent& event) {
     return false;
 #endif
 
+  ui::Accelerator accelerator(event.key_code(),
+                              event.IsShiftDown(),
+                              event.IsControlDown(),
+                              event.IsAltDown());
+
 #if defined(OS_WIN)
   // If the focused view wants to process the key event as is, let it be.
   // On Linux we always dispatch key events to the focused view first, so
   // we should not do this check here. See also NativeWidgetGtk::OnKeyEvent().
-  if (focused_view_ && focused_view_->SkipDefaultKeyEventProcessing(event))
+  if (focused_view_ && focused_view_->SkipDefaultKeyEventProcessing(event) &&
+      !accelerator_manager_->HasPriorityHandler(accelerator))
     return true;
 #endif
 
@@ -125,10 +130,6 @@ bool FocusManager::OnKeyEvent(const KeyEvent& event) {
   // Process keyboard accelerators.
   // If the key combination matches an accelerator, the accelerator is
   // triggered, otherwise the key event is processed as usual.
-  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.
@@ -302,7 +303,7 @@ void FocusManager::StoreFocusedView() {
     return;
   }
 
-  // TODO (jcampan): when a TabContents containing a popup is closed, the focus
+  // TODO(jcivelli): when a TabContents containing a popup is closed, the focus
   // is stored twice causing an assert. We should find a better alternative than
   // removing the view from the storage explicitly.
   view_storage->RemoveView(stored_focused_view_storage_id_);
@@ -405,8 +406,9 @@ View* FocusManager::FindFocusableView(FocusTraversable* focus_traversable,
 
 void FocusManager::RegisterAccelerator(
     const ui::Accelerator& accelerator,
+    ui::AcceleratorManager::HandlerPriority priority,
     ui::AcceleratorTarget* target) {
-  accelerator_manager_->Register(accelerator, target);
+  accelerator_manager_->Register(accelerator, priority, target);
 }
 
 void FocusManager::UnregisterAccelerator(const ui::Accelerator& accelerator,
@@ -444,6 +446,11 @@ ui::AcceleratorTarget* FocusManager::GetCurrentTargetForAccelerator(
   return accelerator_manager_->GetCurrentTarget(accelerator);
 }
 
+bool FocusManager::HasPriorityHandler(
+    const ui::Accelerator& accelerator) const {
+  return accelerator_manager_->HasPriorityHandler(accelerator);
+}
+
 // static
 bool FocusManager::IsTabTraversalKeyEvent(const KeyEvent& key_event) {
   return key_event.key_code() == ui::VKEY_TAB && !key_event.IsControlDown();
diff --git a/ui/views/focus/focus_manager.h b/ui/views/focus/focus_manager.h
index 1f45bc8..262444f 100644
--- a/ui/views/focus/focus_manager.h
+++ b/ui/views/focus/focus_manager.h
@@ -12,6 +12,7 @@
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
+#include "ui/base/accelerators/accelerator_manager.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/views/events/event.h"
@@ -189,6 +190,14 @@ class VIEWS_EXPORT FocusManager {
   // Register a keyboard accelerator for the specified target. If multiple
   // targets are registered for an accelerator, a target registered later has
   // higher priority.
+  // |accelerator| is the accelerator to register.
+  // |priority| denotes the priority of the handler.
+  // NOTE: In almost all cases, you should specify kPriorityNormal for this
+  // parameter. Setting it to kPriorityHigh prevents Chrome from sending the
+  // shortcut to the webpage if the renderer has focus, which is not desirable
+  // except for very isolated cases.
+  // |target| is the AcceleratorTarget that handles the event once the
+  // accelerator is pressed.
   // Note that we are currently limited to accelerators that are either:
   // - a key combination including Ctrl or Alt
   // - the escape key
@@ -196,6 +205,7 @@ class VIEWS_EXPORT FocusManager {
   // - any F key (F1, F2, F3 ...)
   // - any browser specific keys (as available on special keyboards)
   void RegisterAccelerator(const ui::Accelerator& accelerator,
+                           ui::AcceleratorManager::HandlerPriority priority,
                            ui::AcceleratorTarget* target);
 
   // Unregister the specified keyboard accelerator for the specified target.
@@ -239,6 +249,9 @@ class VIEWS_EXPORT FocusManager {
   ui::AcceleratorTarget* GetCurrentTargetForAccelerator(
       const ui::Accelerator& accelertor) const;
 
+  // Whether the given |accelerator| has a priority handler associated with it.
+  bool HasPriorityHandler(const ui::Accelerator& accelerator) const;
+
   // Clears the native view having the focus.
   virtual void ClearNativeFocus();
 
diff --git a/ui/views/focus/focus_manager_unittest.cc b/ui/views/focus/focus_manager_unittest.cc
index 38bd9e0..aea5d19 100644
--- a/ui/views/focus/focus_manager_unittest.cc
+++ b/ui/views/focus/focus_manager_unittest.cc
@@ -1,4 +1,4 @@
-// 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.
 
@@ -211,7 +211,7 @@ class TestAcceleratorTarget : public ui::AcceleratorTarget {
  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);
 };
@@ -231,8 +231,12 @@ TEST_F(FocusManagerTest, CallsNormalAcceleratorTarget) {
             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,
@@ -253,7 +257,9 @@ TEST_F(FocusManagerTest, CallsNormalAcceleratorTarget) {
   // 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));
 
@@ -265,7 +271,9 @@ TEST_F(FocusManagerTest, CallsNormalAcceleratorTarget) {
   // 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));
 
@@ -308,6 +316,95 @@ TEST_F(FocusManagerTest, CallsNormalAcceleratorTarget) {
   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);
@@ -315,8 +412,12 @@ TEST_F(FocusManagerTest, CallsEnabledAcceleratorTargetsOnly) {
   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());
@@ -381,7 +482,9 @@ TEST_F(FocusManagerTest, CallsSelfDeletingAcceleratorTarget) {
             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));
 
diff --git a/ui/views/view.cc b/ui/views/view.cc
index 57494b3..0845825 100644
--- a/ui/views/view.cc
+++ b/ui/views/view.cc
@@ -1958,7 +1958,8 @@ void View::RegisterPendingAccelerators() {
   for (std::vector<ui::Accelerator>::const_iterator i(
            accelerators_->begin() + registered_accelerator_count_);
        i != accelerators_->end(); ++i) {
-    accelerator_focus_manager_->RegisterAccelerator(*i, this);
+    accelerator_focus_manager_->RegisterAccelerator(
+        *i, ui::AcceleratorManager::kNormalPriority, this);
   }
   registered_accelerator_count_ = accelerators_->size();
 }