Support global keyboard commands on Chrome OS.

ash/accelerators/accelerator_controller.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 ASH_ACCELERATORS_ACCELERATOR_CONTROLLER_H_
 #define ASH_ACCELERATORS_ACCELERATOR_CONTROLLER_H_
 
 #include <map>
 #include <set>
 
@@ skipping 20 matching lines @@
 class VolumeControlDelegate;
 
 // AcceleratorController provides functions for registering or unregistering
 // global keyboard accelerators, which are handled earlier than any windows. It
 // also implements several handlers as an accelerator target.
 class ASH_EXPORT AcceleratorController : public ui::AcceleratorTarget {
  public:
   AcceleratorController();
   virtual ~AcceleratorController();
 
+  // A list of possible ways in which an accelerator should be restricted before
+  // processing.

[Finnur, 2014/06/26 10:37:35]

I think we should flesh out this comment a little more, as in why are we doing
this and whether the restriction is global (applies to everything or limited to
some targets).

[David Tseng, 2014/06/27 00:49:11]

It is a non-enforced restriction at the moment.

Any target registered with AcceleratorController should respect the restriction,
but it is currently only enforced by each target.

Unfortunately, the class isn't well flushed out because it also acts as an
AcceleratorTarget; at some point, we should break up the class, but I don't
think that's within scope of this cl?

I left a better comment.

+  enum AcceleratorProcessRestriction {

[Finnur, 2014/06/26 10:37:35]

nit: Process is ambiguous. Processing?

[David Tseng, 2014/06/27 00:49:10]

Yup :); getting wordy, but it does make more sense.

+    // Process the accelerator normally.
+    RESTRICTION_NONE,
+
+    // Don't process the accelerator.
+    RESTRICTION_PREVENT_PROCESSING,
+
+    // Don't process the accelerator and prevent propagation to other targets.
+    RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION
+  };
+
   // Registers a global keyboard accelerator for the specified target. If
   // multiple targets are registered for an accelerator, a target registered
   // later has higher priority.
   void Register(const ui::Accelerator& accelerator,
                 ui::AcceleratorTarget* target);
 
   // Unregisters the specified keyboard accelerator for the specified target.
   void Unregister(const ui::Accelerator& accelerator,
                   ui::AcceleratorTarget* target);
 
@@ skipping 13 matching lines @@
 
   // Returns true if the |accelerator| is one of the |reserved_actions_|.
   bool IsReservedAccelerator(const ui::Accelerator& accelerator) const;
 
   // Performs the specified action. The |accelerator| may provide additional
   // data the action needs. Returns whether an action was performed
   // successfully.
   bool PerformAction(int action,
                      const ui::Accelerator& accelerator);
 
+  // Gets any restriction for the given accelerator and action.

[Finnur, 2014/06/26 10:37:35]

nit: "Returns which restriction applies to a given ..."

[David Tseng, 2014/06/27 00:49:11]

Done.

+  AcceleratorProcessRestriction GetAcceleratorProcessRestriction(

[Finnur, 2014/06/26 10:37:35]

ditto: Ambiguous word "Process".

[David Tseng, 2014/06/27 00:49:10]

Done, everywhere.

+      int action,
+      ui::Accelerator accelerator);

[Finnur, 2014/06/26 10:37:35]

const ui::Accelerator& ?

[David Tseng, 2014/06/27 00:49:10]

Done.

+
   // Overridden from ui::AcceleratorTarget:
   virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
   virtual bool CanHandleAccelerators() const OVERRIDE;
 
   void SetBrightnessControlDelegate(
       scoped_ptr<BrightnessControlDelegate> brightness_control_delegate);
   void SetImeControlDelegate(
       scoped_ptr<ImeControlDelegate> ime_control_delegate);
   void SetScreenshotDelegate(
       scoped_ptr<ScreenshotDelegate> screenshot_delegate);
@@ skipping 65 matching lines @@
   std::set<int> actions_allowed_in_app_mode_;
   // Actions disallowed if there are no windows.
   std::set<int> actions_needing_window_;
 
   DISALLOW_COPY_AND_ASSIGN(AcceleratorController);
 };
 
 }  // namespace ash
 
 #endif  // ASH_ACCELERATORS_ACCELERATOR_CONTROLLER_H_