Allow permission bubbles to participate in key event dispatch as if they were a Browser.

ui/base/cocoa/command_dispatcher.h

 // Copyright 2015 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_COCOA_COMMAND_DISPATCHER_H_
 #define UI_BASE_COCOA_COMMAND_DISPATCHER_H_
 
 #import <Cocoa/Cocoa.h>
 
 #import "base/mac/scoped_nsobject.h"
@@ skipping 14 matching lines @@
 
 @property(assign, nonatomic) id<CommandDispatcherDelegate> delegate;
 
 - (instancetype)initWithOwner:(NSWindow<CommandDispatchingWindow>*)owner;
 
 // The main entry point for key events. The CommandDispatchingWindow should
 // override -[NSResponder performKeyEquivalent:] and call this instead. Returns
 // YES if the event is handled.
 - (BOOL)performKeyEquivalent:(NSEvent*)event;
 
+// Validate a user interface item (e.g. an NSMenuItem), consulting |handler| for
+// -commandDispatch: item actions.
+- (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item
+                       forHandler:(id<UserInterfaceItemCommandHandler>)handler;
+
 // Sends a key event to -[NSApp sendEvent:]. This is used to allow default
 // AppKit handling of an event that comes back from CommandDispatcherTarget,
 // e.g. key equivalents in the menu, or window manager commands like Cmd+`. Once
 // the event returns to the window at -preSendEvent:, handling will stop. The
 // event must be of type |NSKeyDown|, |NSKeyUp|, or |NSFlagsChanged|. Returns
 // YES if the event is handled.
 - (BOOL)redispatchKeyEvent:(NSEvent*)event;
 
 // The CommandDispatchingWindow should override -[NSWindow sendEvent:] and call
 // this before a native -sendEvent:. Ensures that a redispatched event is not
 // reposted infinitely. Returns YES if the event is handled.
 - (BOOL)preSendEvent:(NSEvent*)event;
 
+// Dispatch a -commandDispatch: action either to |handler| or a parent window's
+// handler.
+- (void)dispatch:(id)sender
+      forHandler:(id<UserInterfaceItemCommandHandler>)handler;
+- (void)dispatchUsingKeyModifiers:(id)sender
+                       forHandler:(id<UserInterfaceItemCommandHandler>)handler;
+
 @end
 
 // If the NSWindow's firstResponder implements CommandDispatcherTarget, it is
 // given the first opportunity to process a command.
 @protocol CommandDispatcherTarget
 
 // To handle an event asynchronously, return YES. If the event is ultimately not
 // handled, return the event to the CommandDispatchingWindow via -[[event
 // window] redispatchKeyEvent:event].
 - (BOOL)performKeyEquivalent:(NSEvent*)event;
@@ skipping 30 matching lines @@
 -(void)setCommandHandler:(id<UserInterfaceItemCommandHandler>) commandHandler;
 
 // This can be implemented with -[CommandDispatcher redispatchKeyEvent:]. It's
 // so that callers can simply return events to the NSWindow.
 - (BOOL)redispatchKeyEvent:(NSEvent*)event;
 
 // Short-circuit to the default -[NSResponder performKeyEquivalent:] which
 // CommandDispatcher calls as part of its -performKeyEquivalent: flow.
 - (BOOL)defaultPerformKeyEquivalent:(NSEvent*)event;
 
+// Short-circuit to the default -validateUserInterfaceItem: implementation.
+- (BOOL)defaultValidateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item;
+
 // AppKit will call -[NSUserInterfaceValidations validateUserInterfaceItem:] to
 // validate UI items. Any item whose target is FirstResponder, or nil, will
 // traverse the responder chain looking for a responder that implements the
 // item's selector. Thus NSWindow is usually the last to be checked and will
 // handle any items that are not validated elsewhere in the chain. Implement the
 // following so that menu items with these selectors are validated by
 // CommandDispatchingWindow.
 - (void)commandDispatch:(id)sender;
 - (void)commandDispatchUsingKeyModifiers:(id)sender;
 
 @end
 
 #endif  // UI_BASE_COCOA_COMMAND_DISPATCHER_H_