Experimental Extension Keybinding (first cut).

ui/base/accelerators/accelerator_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_BASE_ACCELERATORS_ACCELERATOR_MANAGER_H_
 #define UI_BASE_ACCELERATORS_ACCELERATOR_MANAGER_H_
 #pragma once
 
 #include <list>
 #include <map>
+#include <utility>
 
 #include "base/basictypes.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/events.h"
 #include "ui/base/ui_export.h"
 
 namespace ui {
 
 // The AcceleratorManger is used to handle keyboard accelerators.
 class UI_EXPORT AcceleratorManager {
  public:
   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 whether the |target| is a priority handler or not.
+  // NOTE: In almost all cases, you should specify |false| for this parameter.
+  // Setting it to |true| prevents Chrome from sending the shortcut to the
+  // webpage if the renderer has focus, which is not desirable except for
+  // isolated cases.

[sadrul, 2012/02/21 16:17:28]

I have seen other code use enums for different kinds of priority (e.g. high,
low, default etc). Does it make sense to have something similar here, instead of
just high and low?

[Finnur, 2012/02/21 21:58:21]

I thought about this and decided that if we have more than two, then yes, it
definitely makes sense. But we can cross that bridge when we get to it.

On 2012/02/21 16:17:28, sadrul wrote:

[sky, 2012/02/22 18:02:52]

The style guide encourages enums for this case (see 'Argument Types' in
http://dev.chromium.org/developers/coding-style . The rationale being it's
totally non-obvious what the argument means when you look at code like
Register(accelerator, true, target).

+  // |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,
+                bool priority,
+                AcceleratorTarget* target);
 
   // Unregister the specified keyboard accelerator for the specified target.
   void Unregister(const Accelerator& accelerator, AcceleratorTarget* target);
 
   // Unregister all keyboard accelerator for the specified target.
   void UnregisterAll(AcceleratorTarget* target);
 
   // Activate the target associated with the specified accelerator.
   // First, AcceleratorPressed handler of the most recently registered target
   // is called, and if that handler processes the event (i.e. returns true),
   // this method immediately returns. If not, we do the same thing on the next
   // target, and so on.
   // Returns true if an accelerator was activated.
   bool Process(const Accelerator& accelerator);
 
   // Returns the AcceleratorTarget that should be activated for the specified
   // keyboard accelerator, or NULL if no view is registered for that keyboard
   // 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.
   EventType last_event_type_;
 
   DISALLOW_COPY_AND_ASSIGN(AcceleratorManager);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_ACCELERATORS_ACCELERATOR_MANAGER_H_