Adds AcceleratorManagerDelegate

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_
 
 #include <list>
 #include <map>
 #include <utility>
 
 #include "base/macros.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/ui_base_export.h"
 #include "ui/events/event_constants.h"
 
 namespace ui {
 
-// The AcceleratorManger is used to handle keyboard accelerators.
+class AcceleratorManagerDelegate;
+
+// AcceleratorManger handles processing of accelerators. A delegate may be
+// supplied which is notified as unique accelerators are added and removed.
 class UI_BASE_EXPORT AcceleratorManager {
  public:
   enum HandlerPriority {
     kNormalPriority,
     kHighPriority,
   };
 
-  AcceleratorManager();
+  explicit AcceleratorManager(AcceleratorManagerDelegate* = nullptr);
   ~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 kNormalPriority for this
   // parameter. Setting it to kHighPriority prevents Chrome from sending the
   // shortcut to the webpage if the renderer has focus, which is not desirable
@@ skipping 25 matching lines @@
   // 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);
 
   // Whether the given |accelerator| has a priority handler associated with it.
   bool HasPriorityHandler(const Accelerator& accelerator) const;
 
  private:
   // The accelerators and associated targets.
-  typedef std::list<AcceleratorTarget*> AcceleratorTargetList;
+  using AcceleratorTargetList = std::list<AcceleratorTarget*>;
   // 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;
+  using AcceleratorTargets = std::pair<bool, AcceleratorTargetList>;
+  using AcceleratorMap = std::map<Accelerator, AcceleratorTargets>;
+
+  // Implementation of Unregister(). |map_iter| points to the accelerator to
+  // remove, and |target| the AcceleratorTarget to remove.
+  void UnregisterImpl(AcceleratorMap::iterator map_iter,
+                      AcceleratorTarget* target);
+
+  AcceleratorManagerDelegate* delegate_;
   AcceleratorMap accelerators_;
 
   DISALLOW_COPY_AND_ASSIGN(AcceleratorManager);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_ACCELERATORS_ACCELERATOR_MANAGER_H_