1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_KEYBINDING_REGISTRY_H_ 6 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_KEYBINDING_REGISTRY_H_ 7 8 #include <list> 9 #include <map> 10 #include <string> 11 12 #include "base/compiler_specific.h" 13 #include "content/public/browser/notification_details.h" 14 #include "content/public/browser/notification_observer.h" 15 #include "content/public/browser/notification_registrar.h" 16 #include "content/public/browser/notification_source.h" 17 18 class Profile; 19 20 namespace ui { 21 class Accelerator; 22 } 23 24 namespace extensions { 25 26 class ActiveTabPermissionGranter; 27 class Extension; 28 29 // The ExtensionKeybindingRegistry is a class that handles the cross-platform 30 // logic for keyboard accelerators. See platform-specific implementations for 31 // implementation details for each platform. 32 class ExtensionKeybindingRegistry : public content::NotificationObserver { 33 public: 34 enum ExtensionFilter { 35 ALL_EXTENSIONS, 36 PLATFORM_APPS_ONLY 37 }; 38 39 class Delegate { 40 public: 41 // Gets the ActiveTabPermissionGranter for the active tab, if any. 42 // If there is no active tab then returns NULL. 43 virtual ActiveTabPermissionGranter* GetActiveTabPermissionGranter() = 0; 44 }; 45 46 // If |extension_filter| is not ALL_EXTENSIONS, only keybindings by 47 // by extensions that match the filter will be registered. 48 ExtensionKeybindingRegistry(Profile* profile, 49 ExtensionFilter extension_filter, 50 Delegate* delegate); 51 52 virtual ~ExtensionKeybindingRegistry(); 53 54 // Enables/Disables general shortcut handing in Chrome. Implemented in 55 // platform-specific ExtensionKeybindingsRegistry* files. 56 static void SetShortcutHandlingSuspended(bool suspended); 57 58 // Overridden from content::NotificationObserver: 59 virtual void Observe(int type, 60 const content::NotificationSource& source, 61 const content::NotificationDetails& details) OVERRIDE; 62 63 protected: 64 // Add extension keybinding for the events defined by the |extension|. 65 // |command_name| is optional, but if not blank then only the command 66 // specified will be added. 67 virtual void AddExtensionKeybinding( 68 const Extension* extension, 69 const std::string& command_name) = 0; 70 // Remove extension bindings for |extension|. |command_name| is optional, 71 // but if not blank then only the command specified will be removed. 72 void RemoveExtensionKeybinding( 73 const Extension* extension, 74 const std::string& command_name); 75 // Overridden by platform specific implementations to provide additional 76 // unregistration (which varies between platforms). 77 virtual void RemoveExtensionKeybindingImpl( 78 const ui::Accelerator& accelerator, 79 const std::string& command_name) = 0; 80 81 // Make sure all extensions registered have keybindings added. 82 void Init(); 83 84 // Whether to ignore this command. Only browserAction commands and pageAction 85 // commands are currently ignored, since they are handled elsewhere. 86 bool ShouldIgnoreCommand(const std::string& command) const; 87 88 // Fire event targets which the specified |accelerator| is binding with. 89 // Returns true if we can find the appropriate event targets. 90 bool NotifyEventTargets(const ui::Accelerator& accelerator); 91 92 // Notifies appropriate parties that a command has been executed. 93 void CommandExecuted(const std::string& extension_id, 94 const std::string& command); 95 96 // Maps an accelerator to a list of string pairs (extension id, command name) 97 // for commands that have been registered. This keeps track of the targets for 98 // the keybinding event (which named command to call in which extension). On 99 // GTK this map contains registration for pageAction and browserAction 100 // commands, whereas on other platforms it does not. Note that normal 101 // accelerator (which isn't media keys) has only one target, while the media 102 // keys can have more than one. 103 typedef std::list<std::pair<std::string, std::string> > TargetList; 104 typedef std::map<ui::Accelerator, TargetList> EventTargets; 105 EventTargets event_targets_; 106 107 private: 108 // Returns true if the |extension| matches our extension filter. 109 bool ExtensionMatchesFilter(const extensions::Extension* extension); 110 111 // The content notification registrar for listening to extension events. 112 content::NotificationRegistrar registrar_; 113 114 // Weak pointer to our profile. Not owned by us. 115 Profile* profile_; 116 117 // What extensions to register keybindings for. 118 ExtensionFilter extension_filter_; 119 120 // Weak pointer to our delegate. Not owned by us. Must outlive this class. 121 Delegate* delegate_; 122 123 DISALLOW_COPY_AND_ASSIGN(ExtensionKeybindingRegistry); 124 }; 125 126 } // namespace extensions 127 128 #endif // CHROME_BROWSER_EXTENSIONS_EXTENSION_KEYBINDING_REGISTRY_H_ 129