Experimental Extension Keybinding (first cut).

ui/views/focus/focus_manager.h

 // 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.
 
 #ifndef UI_VIEWS_FOCUS_FOCUS_MANAGER_H_
 #define UI_VIEWS_FOCUS_FOCUS_MANAGER_H_
 #pragma once
 
 #include <list>
 #include <map>
 
 #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"
 #include "ui/views/views_export.h"
 
 // The FocusManager class is used to handle focus traversal, store/restore
 // focused views and handle keyboard accelerators.
 //
 // There are 2 types of focus:
 // - the native focus, which is the focus that an gfx::NativeView has.
@@ skipping 157 matching lines @@
 
   // Clears the stored focused view.
   void ClearStoredFocusedView();
 
   // Returns true if in the process of changing the focused view.
   bool is_changing_focus() const { return is_changing_focus_; }
 
   // 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 RegisterAccelerator(const ui::Accelerator& accelerator,
+                           ui::AcceleratorManager::HandlerPriority priority,
                            ui::AcceleratorTarget* target);
 
   // Unregister the specified keyboard accelerator for the specified target.
   void UnregisterAccelerator(const ui::Accelerator& accelerator,
                              ui::AcceleratorTarget* target);
 
   // Unregister all keyboard accelerator for the specified target.
   void UnregisterAccelerators(ui::AcceleratorTarget* target);
 
   // Activate the target associated with the specified accelerator.
@@ skipping 23 matching lines @@
   // the focused view is about to change.
   void AddFocusChangeListener(FocusChangeListener* listener);
   void RemoveFocusChangeListener(FocusChangeListener* listener);
 
   // Returns the AcceleratorTarget that should be activated for the specified
   // keyboard accelerator, or NULL if no view is registered for that keyboard
   // accelerator.
   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();
 
   // Convenience method that returns true if the passed |key_event| should
   // trigger tab traversal (if it is a TAB key press with or without SHIFT
   // pressed).
   static bool IsTabTraversalKeyEvent(const KeyEvent& key_event);
 
  private:
   // Returns the next focusable view.
@@ skipping 33 matching lines @@
 
   // See description above getter.
   bool is_changing_focus_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManager);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_FOCUS_FOCUS_MANAGER_H_