Mac global keybindings

chrome/browser/extensions/global_shortcut_listener_mac.mm

+// Copyright (c) 2013 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.
+
+#include "chrome/browser/extensions/global_shortcut_listener_mac.h"
+
+#include <ApplicationServices/ApplicationServices.h>
+#import <Cocoa/Cocoa.h>
+#include <IOKit/hidsystem/ev_keymap.h>
+
+#include "chrome/browser/extensions/api/commands/command_service.h"
+#include "content/public/browser/browser_thread.h"
+#include "ui/base/accelerators/accelerator.h"
+#include "ui/events/event.h"
+#import "ui/events/keycodes/keyboard_code_conversion_mac.h"
+
+using content::BrowserThread;
+using extensions::GlobalShortcutListenerMac;
+
+namespace {
+
+// The media keys subtype. No official docs found, but widely known.
+// http://lists.apple.com/archives/cocoa-dev/2007/Aug/msg00499.html
+const int kSystemDefinedEventMediaKeys = 8;
+
+OSStatus HotKeyHandler(
+    EventHandlerCallRef next_handler, EventRef event, void* user_data) {
+  DVLOG(0) << "HotKeyHandler fired with event: " << event;

[Mark Mentovai, 2013/12/09 19:31:54]

Are these still useful? If development is wrapped up on this feature, I’d prefer
not including any extraneous logging.

[smus, 2013/12/09 23:37:06]

Done.

+  // Extract the hotkey from the event.
+  EventHotKeyID hot_key_id;
+  int result = GetEventParameter(event, kEventParamDirectObject,
+      typeEventHotKeyID, NULL, sizeof(hot_key_id), NULL, &hot_key_id);
+  if (result != noErr)
+    return result;
+
+  GlobalShortcutListenerMac* shortcut_listener =
+      static_cast<GlobalShortcutListenerMac*>(user_data);
+  shortcut_listener->OnKeyEvent(hot_key_id);
+  return noErr;
+}
+
+ui::KeyboardCode MediaKeyCodeToKeyboardCode(
+    int key_code) {

[Mark Mentovai, 2013/12/09 19:31:54]

No need to wrap this line.

[smus, 2013/12/09 23:37:06]

Done.

+  switch (key_code) {
+    case NX_KEYTYPE_PLAY:
+      return ui::VKEY_MEDIA_PLAY_PAUSE;
+    case NX_KEYTYPE_PREVIOUS:
+    case NX_KEYTYPE_REWIND:
+      return ui::VKEY_MEDIA_PREV_TRACK;
+    case NX_KEYTYPE_NEXT:
+    case NX_KEYTYPE_FAST:
+      return ui::VKEY_MEDIA_NEXT_TRACK;
+  }
+  return ui::VKEY_UNKNOWN;
+}
+
+

[Robert Sesek, 2013/12/09 19:17:42]

nit: extra blank line

[smus, 2013/12/09 23:37:06]

Done.

+static base::LazyInstance<extensions::GlobalShortcutListenerMac> g_instance =

[Mark Mentovai, 2013/12/09 19:31:54]

You’re already in an unnamed namespace, “static” doesn’t add anything here. But
see the next comment in GetInstance.

[smus, 2013/12/09 23:37:06]

Done.

+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+namespace extensions {
+
+// static
+GlobalShortcutListener* GlobalShortcutListener::GetInstance() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  return g_instance.Pointer();

[Mark Mentovai, 2013/12/09 19:31:54]

g_instance is only referenced here, so you can just put it at function scope
right here. If you do that, obviously, you use the “static” keyword. And since
you already have the CHECK to make sure that this is on a single thread, you
don’t need the thread-safety that LazyInstance provides on top of an ordinary
static. You can just have a static GlobalShortcutListenerMac* right here.

[smus, 2013/12/09 23:37:06]

Mark, this code is mostly based on other (Windows, X11) implementations of the
global shortcut listener. Do you think it's worth breaking consistency with
those implementations? They have the same lifecycle. Finnur, any thoughts on
this?

[Finnur, 2013/12/09 23:59:49]

As I recall, we've gotten a similar comment on one of the other platforms, so he
is probably correct. I haven't had a time to look it up further as I'm dealing
with a security issue right now (not related to this). Feel free to change it.

[smus, 2013/12/10 01:06:43]

Mark, I removed the lazy instantiation. Is this what you mean?

+}
+
+GlobalShortcutListenerMac::GlobalShortcutListenerMac() {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  is_listening_ = false;

[Robert Sesek, 2013/12/09 19:17:42]

Why not use an initializer list for this?

[smus, 2013/12/09 23:37:06]

Done.

+  hot_key_id_ = 0;
+  event_tap_ = NULL;
+  event_tap_source_ = NULL;
+}
+
+GlobalShortcutListenerMac::~GlobalShortcutListenerMac() {

[Mark Mentovai, 2013/12/09 19:31:54]

Is an object of this class ever created anywhere other than the static
GetInstance method?

[smus, 2013/12/09 23:37:06]

Don't believe so.

+  if (is_listening_)
+    StopListening();

[Robert Sesek, 2013/12/09 19:17:42]

What's the point of calling this? It just sets a boolean. Leave a comment about
when accelerators are actually unregistered. Is it possible to leak things from
RegisterAccelerator?

[smus, 2013/12/09 23:37:06]

There is some sanity checking too, which seems useful. Added a comment.

+
+  // If media keys are still registered, make sure we stop the tap.
+  if (IsAnyMediaKeyRegistered())
+    StopWatchingMediaKeys();
+}
+
+void GlobalShortcutListenerMac::StartListening() {
+  DCHECK(!is_listening_);  // Don't start twice.
+  DCHECK(!hot_key_ids_.empty());  // Don't start if no hot key registered.
+  DCHECK(!id_hot_keys_.empty());
+  is_listening_ = true;
+}
+
+void GlobalShortcutListenerMac::StopListening() {
+  DCHECK(is_listening_);  // No point if we are not already listening.
+  DCHECK(hot_key_ids_.empty());  // Make sure the set is clean.
+  DCHECK(id_hot_keys_.empty());
+  is_listening_ = false;
+}
+
+bool GlobalShortcutListenerMac::OnKeyEvent(EventHotKeyID hot_key_id) {
+  // Look up the accelerator based on this hot key ID.
+  DVLOG(0) << "OnKeyEvent! hot_key_id: " << hot_key_id.id;
+  const ui::Accelerator& accelerator = id_hot_keys_[hot_key_id.id];

[Robert Sesek, 2013/12/09 19:17:42]

What if it's not found?

[smus, 2013/12/09 23:37:06]

Done.

+  DVLOG(0) << "Key code: " << accelerator.key_code()
+          << " modifiers: " << accelerator.modifiers();

[Mark Mentovai, 2013/12/09 19:31:54]

Line up the first << operator on this new line with the one above it.
http://www.chromium.org/developers/coding-style

This comment applies throughout. But I strongly urge you to just drop this
logging.

[smus, 2013/12/09 23:37:06]

Done.

+  NotifyKeyPressed(accelerator);
+  return true;

[Mark Mentovai, 2013/12/09 19:31:54]

Seems like there’s an interface here to signal that a key wasn’t found. You use
it for media keys but not for non-media keys.

[smus, 2013/12/09 23:37:06]

Media keys and hot keys are handled differently. Media keys use a global
listener, while hot keys are registered specifically on a per-shortcut basis.
This should actually return void.

+}
+
+bool GlobalShortcutListenerMac::OnMediaKeyEvent(int media_key_code) {
+  ui::KeyboardCode key_code = MediaKeyCodeToKeyboardCode(media_key_code);
+  DVLOG(0) << "OnMediaKeyEvent! keyCode: " << key_code;
+  // Create an accelerator corresponding to the keyCode.
+  ui::Accelerator accelerator(key_code, 0);
+  // Look for a match with a bound hot_key.
+  if (hot_key_ids_.find(accelerator) != hot_key_ids_.end()) {
+    // If matched, callback to the event handling system.
+    NotifyKeyPressed(accelerator);
+    return true;
+  }
+  return false;
+}
+
+void GlobalShortcutListenerMac::RegisterAccelerator(
+    const ui::Accelerator& accelerator,
+    GlobalShortcutListener::Observer* observer) {
+  DVLOG(0) << "Registered keyCode: " << accelerator.key_code()
+      << ", modifiers: " << accelerator.modifiers();
+
+  if (hot_key_ids_.find(accelerator) != hot_key_ids_.end()) {
+    // The shortcut has already been registered. Some shortcuts, such as
+    // MediaKeys can have multiple targets, all keyed off of the same
+    // accelerator.
+    return;
+  }
+
+  // If this is the first media key registered, start the event tap.
+  if (CommandService::IsMediaKey(accelerator) && !IsAnyMediaKeyRegistered()) {
+    DVLOG(0) << "Registered the first media key, so starting event tap.";
+    StartWatchingMediaKeys();
+  }
+
+  // Register hot_key if they are non-media keyboard shortcuts.
+  if (!CommandService::IsMediaKey(accelerator))
+    RegisterHotKey(accelerator, hot_key_id_);
+
+  // Store the hotkey-ID mappings we will need for lookup later.
+  id_hot_keys_[hot_key_id_] = accelerator;
+  hot_key_ids_[accelerator] = hot_key_id_;
+  ++hot_key_id_;
+  GlobalShortcutListener::RegisterAccelerator(accelerator, observer);
+}
+
+void GlobalShortcutListenerMac::UnregisterAccelerator(
+    const ui::Accelerator& accelerator,
+    GlobalShortcutListener::Observer* observer) {
+  // Unregister the hot_key if it's a keyboard shortcut.
+  if (!CommandService::IsMediaKey(accelerator))
+    UnregisterHotKey(accelerator);
+
+  // Remove hot_key from the mappings.
+  int id = hot_key_ids_[accelerator];
+  id_hot_keys_.erase(id);
+  hot_key_ids_.erase(accelerator);
+  GlobalShortcutListener::UnregisterAccelerator(accelerator, observer);
+
+  // If we unregistered a media key, and now if no media keys are registered,
+  // stop the media key tap.
+  if (CommandService::IsMediaKey(accelerator) && !IsAnyMediaKeyRegistered()) {
+    DVLOG(0) << "Unregistered the last media key, stopping event tap.";
+    StopWatchingMediaKeys();
+  }
+}
+
+void GlobalShortcutListenerMac::RegisterHotKey(
+    const ui::Accelerator& accelerator, int hot_key_id) {
+  DVLOG(0) << "Registering hot_key. Keycode: " << accelerator.key_code();
+  EventHotKeyRef hot_key_ref;
+  EventHotKeyID event_hot_key_id;
+  EventHandlerUPP hot_key_function = NewEventHandlerUPP(HotKeyHandler);
+
+  EventTypeSpec event_type;
+  event_type.eventClass = kEventClassKeyboard;
+  event_type.eventKind = kEventHotKeyPressed;
+  InstallApplicationEventHandler(hot_key_function, 1, &event_type, this, NULL);
+
+  // Signature uniquely identifies the application that owns this hot_key.
+  event_hot_key_id.signature = 'rimZ';

[Mark Mentovai, 2013/12/09 19:31:54]

Don’t hard-code the creator code. You can use CFBundleGetPackageInfo to get the
real creator code. You should have a helper function in the unnamed namespace do
this, and cache the result in a static.

[smus, 2013/12/09 23:37:06]

This is apparently implemented in base/mac/foundation_util.h

+  event_hot_key_id.id = hot_key_id;
+
+  // Translate ui::Accelerator modifiers to cmdKey, altKey, etc.
+  int modifiers = 0;
+  modifiers |= (accelerator.IsShiftDown() ? shiftKey : 0);
+  modifiers |= (accelerator.IsCtrlDown() ? controlKey : 0);
+  modifiers |= (accelerator.IsAltDown() ? optionKey : 0);
+  modifiers |= (accelerator.IsCmdDown() ? cmdKey : 0);
+
+  unichar character;
+  unichar character_nomods;
+  int key_code = ui::MacKeyCodeForWindowsKeyCode(accelerator.key_code(), 0,
+      &character, &character_nomods);
+  DVLOG(0) << "RegisterHotKey. Code: " << key_code
+           << " modifier: " << modifiers;
+
+  // Register the event hot key.
+  RegisterEventHotKey(key_code, modifiers, event_hot_key_id,
+      GetApplicationEventTarget(), 0, &hot_key_ref);
+
+  id_hot_key_refs_[hot_key_id] = hot_key_ref;
+}
+
+void GlobalShortcutListenerMac::UnregisterHotKey(
+    const ui::Accelerator& accelerator) {
+  // Get the ref corresponding to this accelerator.
+  int id = hot_key_ids_[accelerator];
+  EventHotKeyRef ref = id_hot_key_refs_[id];
+  // Unregister the event hot key.
+  UnregisterEventHotKey(ref);
+
+  // Remove the event from the mapping.
+  id_hot_key_refs_.erase(id);
+}
+
+void GlobalShortcutListenerMac::StartWatchingMediaKeys() {
+  DVLOG(0) << "StartWatchingMediaKeys";
+  // Make sure there's no existing event tap.
+  DCHECK(event_tap_ == NULL);
+
+  // Add an event tap to intercept the system defined media key events.
+  event_tap_ = CGEventTapCreate(kCGSessionEventTap,
+      kCGHeadInsertEventTap,
+      kCGEventTapOptionDefault,
+      CGEventMaskBit(NX_SYSDEFINED),
+      EventTapCallback,
+      this);
+  if (event_tap_ == NULL) {
+    LOG(ERROR) << "Error: failed to create event tap.";
+    return;
+  }
+
+  event_tap_source_ = CFMachPortCreateRunLoopSource(kCFAllocatorSystemDefault,
+      event_tap_, 0);
+  if (event_tap_source_ == NULL) {
+    LOG(ERROR) << "Error: failed to create new run loop source.";
+    return;
+  }
+
+  CFRunLoopAddSource(CFRunLoopGetCurrent(), event_tap_source_,
+      kCFRunLoopCommonModes);
+}
+
+void GlobalShortcutListenerMac::StopWatchingMediaKeys() {
+  DVLOG(0) << "StopWatchingMediaKeys";
+  CFRunLoopRemoveSource(CFRunLoopGetCurrent(), event_tap_source_,
+      kCFRunLoopCommonModes);
+
+  // Invalidate the event tap.
+  DCHECK(event_tap_ != NULL);
+  CFMachPortInvalidate(event_tap_);
+  CFRelease(event_tap_);
+  event_tap_ = NULL;
+
+  // Release the event tap source.
+  DCHECK(event_tap_source_ != NULL);
+  CFRelease(event_tap_source_);
+  event_tap_source_ = NULL;
+}
+
+bool GlobalShortcutListenerMac::IsAnyMediaKeyRegistered() {
+  // Iterate through registered accelerators, looking for media keys.
+  HotKeyIdMap::iterator iter;
+  for (iter = hot_key_ids_.begin(); iter != hot_key_ids_.end(); ++iter) {
+    if (CommandService::IsMediaKey(iter->first))
+      return true;
+  }
+  return false;
+}
+
+// Processed events should propagate if they aren't handled by any listeners.
+// For events that don't matter, this handler should return as quickly as
+// possible.
+// Returning event causes the event to propagate to other applications.
+// Returning NULL prevents the event from propagating.
+// static
+CGEventRef GlobalShortcutListenerMac::EventTapCallback(
+    CGEventTapProxy proxy, CGEventType type, CGEventRef event, void* refcon) {
+  GlobalShortcutListenerMac* shortcut_listener =
+      static_cast<GlobalShortcutListenerMac*>(refcon);
+
+  // Handle the timeout case by re-enabling the tap.
+  if (type == kCGEventTapDisabledByTimeout) {
+    CGEventTapEnable(shortcut_listener->event_tap_, TRUE);
+    return event;
+  }
+
+  // Convert the CGEvent to an NSEvent for access to the data1 field.
+  NSEvent* ns_event = [NSEvent eventWithCGEvent:event];
+  if (ns_event == nil) {
+    return event;
+  }
+
+  // Ignore events that are not system defined media keys.
+  if (type != NX_SYSDEFINED ||
+      [ns_event type] != NSSystemDefined ||
+      [ns_event subtype] != kSystemDefinedEventMediaKeys) {
+    return event;
+  }
+
+  NSInteger data1 = [ns_event data1];
+  // Ignore media keys that aren't previous, next and play/pause.
+  // Magical constants are from http://weblog.rogueamoeba.com/2007/09/29/
+  int key_code = ((data1 & 0xFFFF0000) >> 16);
+  if (key_code != NX_KEYTYPE_PLAY && key_code != NX_KEYTYPE_NEXT &&
+      key_code != NX_KEYTYPE_PREVIOUS && key_code != NX_KEYTYPE_FAST &&
+      key_code != NX_KEYTYPE_REWIND) {
+    return event;
+  }
+
+  int key_flags = (data1 & 0x0000FFFF);
+  bool is_key_pressed = (((key_flags & 0xFF00) >> 8)) == 0xA;
+
+  // If the key wasn't pressed (eg. was released), ignore this event.
+  if (!is_key_pressed)
+    return event;
+
+  // Now we have a media key that we care about. Send it to the caller.
+  bool was_handled = shortcut_listener->OnMediaKeyEvent(key_code);
+
+  // Prevent event from proagating to other apps if handled by Chrome.
+  if (was_handled)
+    return NULL;
+
+  // By default, pass the event through.
+  return event;
+}
+
+}  // namespace extensions