MacViews: Fix duplicate definition of ExtensionKeyBindingRegistry::SetShortcutHandlingSuspended

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_
 
 #include <list>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/accelerators/accelerator_manager.h"
+#include "ui/base/accelerators/accelerator_processor.h"
 #include "ui/gfx/native_widget_types.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.
 // - the view focus, which is the focus that a views::View has.
 //
@@ skipping 87 matching lines @@
   // No change to focus state has occurred yet when this function is called.
   virtual void OnWillChangeFocus(View* focused_before, View* focused_now) = 0;
 
   // Called after focus state has changed.
   virtual void OnDidChangeFocus(View* focused_before, View* focused_now) = 0;
 
  protected:
   virtual ~FocusChangeListener() {}
 };
 
-class VIEWS_EXPORT FocusManager {
+class VIEWS_EXPORT FocusManager : public ui::AcceleratorProcessor {
  public:
   // The reason why the focus changed.
   enum FocusChangeReason {
     // The focus changed because the user traversed focusable views using
     // keys like Tab or Shift+Tab.
     kReasonFocusTraversal,
 
     // The focus changed due to restoring the focus.
     kReasonFocusRestore,
 
     // The focus changed due to a click or a shortcut to jump directly to
     // a particular view.
     kReasonDirectFocusChange
   };
 
   // TODO: use Direction in place of bool reverse throughout.
   enum Direction {
     kForward,
     kBackward
   };
 
   enum FocusCycleWrappingBehavior {
     kWrap,
     kNoWrap
   };
 
-  FocusManager(Widget* widget, FocusManagerDelegate* delegate);
-  virtual ~FocusManager();
+  explicit FocusManager(Widget* widget);
+  ~FocusManager() override;
 
   // Processes the passed key event for accelerators and keyboard traversal.
   // Returns false if the event has been consumed and should not be processed
   // further.
   bool OnKeyEvent(const ui::KeyEvent& event);
 
   // Returns true is the specified is part of the hierarchy of the window
   // associated with this FocusManager.
   bool ContainsView(View* view);
 
@@ skipping 56 matching lines @@
 
   // Changes the text input focus to |view->GetTextInputClient()| iff |view|
   // is focused.  Views must call this method when their internal
   // TextInputClient instance changes.
   void OnTextInputClientChanged(View* view);
 
   // Moves the text input focus into/out from |view|.
   void FocusTextInputClient(View* view);
   void BlurTextInputClient(View* view);
 
-  // Disable shortcut handling.
-  static void set_shortcut_handling_suspended(bool suspended) {
-    shortcut_handling_suspended_ = suspended;
-  }
-  // Returns whether shortcut handling is currently suspended.
-  bool shortcut_handling_suspended() { return shortcut_handling_suspended_; }
-
   // 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
   // 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.
-  // 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 ProcessAccelerator(const ui::Accelerator& accelerator);
-
   // Resets menu key state if |event| is not menu key release.
   // This is effective only on x11.
   void MaybeResetMenuKeyState(const ui::KeyEvent& key);
 
   // Called by a RootView when a view within its hierarchy is removed
   // from its parent. This will only be called by a RootView in a
   // hierarchy of Widgets that this FocusManager is attached to the
   // parent Widget of.
   void ViewRemoved(View* removed);
 
   // Adds/removes a listener.  The FocusChangeListener is notified every time
   // 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& accelerator) const;
+  // Adds/removes an accelerator processor.
+  // PreProcessors are given a chance to process an accelerator before normal
+  // processing.
+  // PostProcessors are given a chance to process unhandled accelerators.
+  void AddAcceleratorPreProcessor(ui::AcceleratorProcessor* processor);
+  void AddAcceleratorPostProcessor(ui::AcceleratorProcessor* processor);
+  void RemoveAcceleratorProcessor(ui::AcceleratorProcessor* processor);
 
   // 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();
 
   // Focuses the next keyboard-accessible pane, taken from the list of
   // views returned by WidgetDelegate::GetAccessiblePanes(). If there are
   // no panes, the widget's root view is treated as a single pane.
@@ skipping 23 matching lines @@
   // |starting_view| is NULL |starting_widget| is consuled to determine which
   // Widget to start from. See
   // WidgetDelegate::ShouldAdvanceFocusToTopLevelWidget() for details. If both
   // |starting_view| and |starting_widget| are NULL, traversal starts at
   // |widget_|.
   View* GetNextFocusableView(View* starting_view,
                              Widget* starting_widget,
                              bool reverse,
                              bool dont_loop);
 
+  // Overridden from ui::AcceleratorProcessor:
+  bool ProcessAccelerator(const ui::Accelerator& accelerator) override;
+  ui::AcceleratorTarget* GetTargetForAccelerator(
+      const ui::Accelerator& accelerator) const override;
+
  private:
   // Returns the focusable view found in the FocusTraversable specified starting
   // at the specified view. This traverses down along the FocusTraversable
   // hierarchy.
   // Returns NULL if no focusable view were found.
   View* FindFocusableView(FocusTraversable* focus_traversable,
                           View* starting_view,
                           bool reverse);
 
   // Process arrow key traversal. Returns true if the event has been consumed
   // and should not be processed further.
   bool ProcessArrowKeyTraversal(const ui::KeyEvent& event);
 
-  // Keeps track of whether shortcut handling is currently suspended.
-  static bool shortcut_handling_suspended_;
-
   // Whether arrow key traversal is enabled.
   static bool arrow_key_traversal_enabled_;
 
   // The top-level Widget this FocusManager is associated with.
   Widget* widget_;
 
-  // The object which handles an accelerator when |accelerator_manager_| doesn't
-  // handle it.
-  scoped_ptr<FocusManagerDelegate> delegate_;
-
   // The view that currently is focused.
   View* focused_view_;
 
   // The AcceleratorManager this FocusManager is associated with.
   scoped_ptr<ui::AcceleratorManager> accelerator_manager_;
 
+  std::list<ui::AcceleratorProcessor*> accelerator_processors_;
+
   // The storage id used in the ViewStorage to store/restore the view that last
   // had focus.
   int stored_focused_view_storage_id_;
 
   // The reason why the focus most recently changed.
   FocusChangeReason focus_change_reason_;
 
   // The list of registered FocusChange listeners.
   ObserverList<FocusChangeListener, true> focus_change_listeners_;
 
   // See description above getter.
   bool is_changing_focus_;
 
   DISALLOW_COPY_AND_ASSIGN(FocusManager);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_FOCUS_FOCUS_MANAGER_H_