mac: Load the system hotkeys after launch.

content/browser/cocoa/system_hotkey_map.mm

 // Copyright 2014 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.
 
-#import "chrome/browser/ui/cocoa/system_hotkey_map.h"
-
-#import <Cocoa/Cocoa.h>
+#import "content/browser/cocoa/system_hotkey_map.h"
 
 #pragma mark - NSDictionary Helper Functions
 
 namespace {
 
 // All 4 following functions return nil if the object doesn't exist, or isn't of
 // the right class.
 id ObjectForKey(NSDictionary* dict, NSString* key, Class aClass) {
   id object = [dict objectForKey:key];
   if (![object isKindOfClass:aClass])
@@ skipping 10 matching lines @@
 }
 
 NSNumber* NumberForKey(NSDictionary* dict, NSString* key) {
   return ObjectForKey(dict, key, [NSNumber class]);
 }
 
 }  // namespace
 
 #pragma mark - SystemHotkey
 
+namespace content {
+
 struct SystemHotkey {
   int key_code;
   int modifiers;
 };
 
 #pragma mark - SystemHotkeyMap
 
 SystemHotkeyMap::SystemHotkeyMap() {
 }
 SystemHotkeyMap::~SystemHotkeyMap() {
 }
 
-bool SystemHotkeyMap::ParseData(NSData* data) {
-  system_hotkeys_.clear();
+NSDictionary* SystemHotkeyMap::DictionaryFromData(NSData* data) {
+  if (!data)
+    return nil;
 
   NSError* error = nil;
   NSPropertyListFormat format;
   NSDictionary* dictionary =
       [NSPropertyListSerialization propertyListWithData:data
                                                 options:0
                                                  format:&format
                                                   error:&error];
-  if (error)
-    return false;
 
   if (![dictionary isKindOfClass:[NSDictionary class]])
+    return nil;
+
+  return dictionary;
+}
+
+bool SystemHotkeyMap::ParseDictionary(NSDictionary* dictionary) {
+  system_hotkeys_.clear();
+
+  if (!dictionary)
     return false;
 
   NSDictionary* hotkey_dictionaries =
       DictionaryForKey(dictionary, @"AppleSymbolicHotKeys");
   if (!hotkey_dictionaries)
     return false;
 
   for (NSString* hotkey_system_effect in [hotkey_dictionaries allKeys]) {
     if (![hotkey_system_effect isKindOfClass:[NSString class]])
       continue;
@@ skipping 22 matching lines @@
     NSNumber* modifiers = [parameters objectAtIndex:2];
     if (![modifiers isKindOfClass:[NSNumber class]])
       continue;
 
     ReserveHotkey(key_code.intValue, modifiers.intValue, hotkey_system_effect);
   }
 
   return true;
 }
 
-bool SystemHotkeyMap::IsHotkeyReserved(int key_code, int modifiers) {
-  std::vector<SystemHotkey>::iterator it;
+bool SystemHotkeyMap::IsEventReserved(NSEvent* event) const {
+  NSUInteger modifiers =
+      NSShiftKeyMask | NSControlKeyMask | NSCommandKeyMask | NSAlternateKeyMask;
+  return IsHotkeyReserved(event.keyCode, event.modifierFlags & modifiers);
+}
+
+bool SystemHotkeyMap::IsHotkeyReserved(int key_code, int modifiers) const {
+  std::vector<SystemHotkey>::const_iterator it;

[Robert Sesek, 2014/07/14 19:37:56]

It occurs to me that doing a linear scan of this vector on every key event may
not be great. It may make sense to turn this into a std::map. Thoughts?

[erikchen, 2014/07/14 19:54:14]

When I wrote this, I deemed the minor performance hit (a linear scan of ~50
items) to be better than the minor complexity increase of using another
container. *shrug*

[Robert Sesek, 2014/07/14 19:59:45]

What do you mean another container? You could just replace the vector with a
map, right?

[erikchen, 2014/07/14 20:13:33]

Yes, I could replace the vector with a map and a comparator for SystemHotKey. Or
alternatively a multimap. But the performance characteristic for vectors is
better than maps and multimaps for small data sets because of prefetching and
caching, so its unclear if there would be any performance benefit (might even
get worse...).

If you feel strongly about this, let me know and I will write a separate CL and
change the vector to a map.

   for (it = system_hotkeys_.begin(); it != system_hotkeys_.end(); ++it) {
     if (it->key_code == key_code && it->modifiers == modifiers)
       return true;
   }
   return false;
 }
 
 void SystemHotkeyMap::ReserveHotkey(int key_code,
                                     int modifiers,
                                     NSString* system_effect) {
   ReserveHotkey(key_code, modifiers);
 
   // If a hotkey exists for toggling through the windows of an application, then
   // adding shift to that hotkey toggles through the windows backwards.
   if ([system_effect isEqualToString:@"27"])
     ReserveHotkey(key_code, modifiers | NSShiftKeyMask);
 }
 
 void SystemHotkeyMap::ReserveHotkey(int key_code, int modifiers) {
   SystemHotkey hotkey;
   hotkey.key_code = key_code;
   hotkey.modifiers = modifiers;
   system_hotkeys_.push_back(hotkey);
 }
+
+}  // namespace content