Mac global keybindings

chrome/browser/extensions/extension_commands_global_registry_apitest.cc

 // 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/extension_apitest.h"
 #include "chrome/browser/extensions/window_controller.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/interactive_test_utils.h"
 #include "content/public/test/browser_test_utils.h"
 #include "ui/base/base_window.h"
 #include "ui/base/test/ui_controls.h"
 
 #if defined(OS_LINUX)
 #include <X11/Xlib.h>
 #include <X11/extensions/XTest.h>
 #include <X11/keysym.h>
 
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/gfx/x/x11_types.h"
 #endif
 
+#if defined(OS_MACOSX)
+#include <Carbon/Carbon.h>
+#endif
+
 namespace extensions {
 
 typedef ExtensionApiTest GlobalCommandsApiTest;
 
 #if defined(OS_LINUX)
 // Send a simulated key press and release event, where |control|, |shift| or
 // |alt| indicates whether the key is struck with corresponding modifier.
 void SendNativeKeyEventToXDisplay(ui::KeyboardCode key,
                                   bool control,
                                   bool shift,
@@ skipping 27 matching lines @@
     XTestFakeKeyEvent(display, *it, True, CurrentTime);
 
   // Simulate the keys being released.
   for (KeyCodes::iterator it = key_codes.begin(); it != key_codes.end(); it++)
     XTestFakeKeyEvent(display, *it, False, CurrentTime);
 
   XFlush(display);
 }
 #endif  // OS_LINUX
 
-#if defined(OS_WIN) || (defined(OS_LINUX) && !defined(OS_CHROMEOS))
+#if defined(OS_MACOSX)
+void SendNativeCommandShift(int key_code) {
+  CGEventSourceRef src =
+    CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
+
+  CGEventRef cmd_d = CGEventCreateKeyboardEvent(src, kVK_Command, true);

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

You should place these in a ScopedCFTypeRef so that you don't have to manually
call CFRelease().

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

This sounds like the key event is for command-D, command-U, etc. Don’t
abbreviate.
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Genera...

You can rename src and loc too.

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

Done.

+  CGEventRef cmd_u = CGEventCreateKeyboardEvent(src, kVK_Command, false);

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

Why don’t you create these in the order that they will be posted?

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

Done.

+  CGEventRef shift_d = CGEventCreateKeyboardEvent(src, kVK_Shift, true);
+  CGEventRef shift_u = CGEventCreateKeyboardEvent(src, kVK_Shift, false);
+  CGEventRef key_d = CGEventCreateKeyboardEvent(src, key_code, true);
+  CGEventRef key_u = CGEventCreateKeyboardEvent(src, key_code, false);
+
+  CGEventSetFlags(key_d, kCGEventFlagMaskCommand | kCGEventFlagMaskShift);

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

This should immediately follow the creation of key_d.

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

Done.

+  CGEventSetFlags(key_u, kCGEventFlagMaskCommand | kCGEventFlagMaskShift);

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

Ditto, key_u.

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

Done.

+
+  CGEventTapLocation loc = kCGHIDEventTap; // kCGSessionEventTap also works

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

http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Implem...

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

Done.

+  CGEventPost(loc, cmd_d);
+  CGEventPost(loc, shift_d);
+  CGEventPost(loc, key_d);
+  CGEventPost(loc, key_u);
+  CGEventPost(loc, shift_u);
+  CGEventPost(loc, cmd_u);
+
+  CFRelease(cmd_d);

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

Use a base::ScopedCFTypeRef (base/mac/scoped_cftyperef.h) for all of these.

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

Done.

+  CFRelease(cmd_u);
+  CFRelease(shift_d);
+  CFRelease(shift_u);
+  CFRelease(key_d);
+  CFRelease(key_u);
+  CFRelease(src);
+}
+#endif
+
+#if defined(OS_WIN) || (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_MACOSX)
 // The feature is only fully implemented on Windows and Linux, other platforms
 // coming.
 #define MAYBE_GlobalCommand GlobalCommand
 #else
 #define MAYBE_GlobalCommand DISABLED_GlobalCommand
 #endif
 
 // Test the basics of global commands and make sure they work when Chrome
 // doesn't have focus. Also test that non-global commands are not treated as
 // global and that keys beyond Ctrl+Shift+[0..9] cannot be auto-assigned by an
 // extension.
 IN_PROC_BROWSER_TEST_F(GlobalCommandsApiTest, MAYBE_GlobalCommand) {
   FeatureSwitch::ScopedOverride enable_global_commands(
       FeatureSwitch::global_commands(), true);
 
   // Load the extension in the non-incognito browser.
   ResultCatcher catcher;
   ASSERT_TRUE(RunExtensionTest("keybinding/global")) << message_;
   ASSERT_TRUE(catcher.GetNextResult());
 
-#if !defined(OS_LINUX)
+#if defined(OS_WIN)
   // Our infrastructure for sending keys expects a browser to send them to, but
   // to properly test global shortcuts you need to send them to another target.
   // So, create an incognito browser to use as a target to send the shortcuts
   // to. It will ignore all of them and allow us test whether the global
   // shortcut really is global in nature and also that the non-global shortcut
   // is non-global.
   Browser* incognito_browser = CreateIncognitoBrowser();
 
   // Try to activate the non-global shortcut (Ctrl+Shift+1) and the
   // non-assignable shortcut (Ctrl+Shift+A) by sending the keystrokes to the
   // incognito browser. Both shortcuts should have no effect (extension is not
   // loaded there).
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
       incognito_browser, ui::VKEY_1, true, true, false, false));
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
       incognito_browser, ui::VKEY_A, true, true, false, false));
 
   // Activate the shortcut (Ctrl+Shift+9). This should have an effect.
   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
       incognito_browser, ui::VKEY_9, true, true, false, false));
-#else
+#elif defined(OS_LINUX)
   // Create an incognito browser to capture the focus.
   CreateIncognitoBrowser();
 
   // On Linux, our infrastructure for sending keys just synthesize keyboard
   // event and send them directly to the specified window, without notifying the
   // X root window. It didn't work while testing global shortcut because the
   // stuff of global shortcut on Linux need to be notified when KeyPress event
   // is happening on X root window. So we simulate the keyboard input here.
   SendNativeKeyEventToXDisplay(ui::VKEY_1, true, true, false);
   SendNativeKeyEventToXDisplay(ui::VKEY_A, true, true, false);
   SendNativeKeyEventToXDisplay(ui::VKEY_9, true, true, false);
+#elif defined(OS_MACOSX)
+  // Create an incognito browser to capture the focus.
+  CreateIncognitoBrowser();
+
+  // Send some native mac key events.
+  SendNativeCommandShift(kVK_ANSI_1);
+  SendNativeCommandShift(kVK_ANSI_A);
+  SendNativeCommandShift(kVK_ANSI_9);
 #endif
 
   // If this fails, it might be because the global shortcut failed to work,
   // but it might also be because the non-global shortcuts unexpectedly
   // worked.
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 }
 
 #if defined(OS_WIN)
 // The feature is only fully implemented on Windows, other platforms coming.
+// TODO(smus): On mac, SendKeyPress must first support media keys.
 #define MAYBE_GlobalDuplicatedMediaKey GlobalDuplicatedMediaKey
 #else
 #define MAYBE_GlobalDuplicatedMediaKey DISABLED_GlobalDuplicatedMediaKey
 #endif
 
 IN_PROC_BROWSER_TEST_F(GlobalCommandsApiTest, MAYBE_GlobalDuplicatedMediaKey) {
   FeatureSwitch::ScopedOverride enable_global_commands(
       FeatureSwitch::global_commands(), true);
 
   ResultCatcher catcher;
@@ skipping 12 matching lines @@
                             false,
                             false,
                             false);
 
   // We should get two success result.
   ASSERT_TRUE(catcher.GetNextResult());
   ASSERT_TRUE(catcher.GetNextResult());
 }
 
 }  // namespace extensions