chrome/browser/extensions/extension_commands_global_registry_apitest.cc

   1 // Copyright (c) 2013 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 #include "chrome/browser/extensions/extension_apitest.h"
   6 #include "chrome/browser/extensions/window_controller.h"
   7 #include "chrome/browser/ui/browser_window.h"
   8 #include "chrome/browser/ui/tabs/tab_strip_model.h"
   9 #include "chrome/test/base/interactive_test_utils.h"
  10 #include "content/public/test/browser_test_utils.h"
  11 #include "ui/base/base_window.h"
  12 #include "ui/base/test/ui_controls.h"
  13
  14 #if defined(OS_LINUX)
  15 #include <X11/Xlib.h>
  16 #include <X11/extensions/XTest.h>
  17 #include <X11/keysym.h>
  18
  19 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
  20 #include "ui/gfx/x/x11_types.h"
  21 #endif
  22
  23 #if defined(OS_MACOSX)
  24 #include <Carbon/Carbon.h>
  25
  26 #include "base/mac/scoped_cftyperef.h"
  27 #endif
  28
  29 namespace extensions {
  30
  31 typedef ExtensionApiTest GlobalCommandsApiTest;
  32
  33 #if defined(OS_LINUX)
  34 // Send a simulated key press and release event, where |control|, |shift| or
  35 // |alt| indicates whether the key is struck with corresponding modifier.
  36 void SendNativeKeyEventToXDisplay(ui::KeyboardCode key,
  37                                   bool control,
  38                                   bool shift,
  39                                   bool alt) {
  40   Display* display = gfx::GetXDisplay();
  41   KeyCode ctrl_key_code = XKeysymToKeycode(display, XK_Control_L);
  42   KeyCode shift_key_code = XKeysymToKeycode(display, XK_Shift_L);
  43   KeyCode alt_key_code = XKeysymToKeycode(display, XK_Alt_L);
  44
  45   // Release modifiers first of all to make sure this function can work as
  46   // expected. For example, when |control| is false, but the status of Ctrl key
  47   // is down, we will generate a keyboard event with unwanted Ctrl key.
  48   XTestFakeKeyEvent(display, ctrl_key_code, False, CurrentTime);
  49   XTestFakeKeyEvent(display, shift_key_code, False, CurrentTime);
  50   XTestFakeKeyEvent(display, alt_key_code, False, CurrentTime);
  51
  52   typedef std::vector<KeyCode> KeyCodes;
  53   KeyCodes key_codes;
  54   if (control)
  55     key_codes.push_back(ctrl_key_code);
  56   if (shift)
  57     key_codes.push_back(shift_key_code);
  58   if (alt)
  59     key_codes.push_back(alt_key_code);
  60
  61   key_codes.push_back(XKeysymToKeycode(display,
  62                                        XKeysymForWindowsKeyCode(key, false)));
  63
  64   // Simulate the keys being pressed.
  65   for (KeyCodes::iterator it = key_codes.begin(); it != key_codes.end(); it++)
  66     XTestFakeKeyEvent(display, *it, True, CurrentTime);
  67
  68   // Simulate the keys being released.
  69   for (KeyCodes::iterator it = key_codes.begin(); it != key_codes.end(); it++)
  70     XTestFakeKeyEvent(display, *it, False, CurrentTime);
  71
  72   XFlush(display);
  73 }
  74 #endif  // OS_LINUX
  75
  76 #if defined(OS_MACOSX)
  77 using base::ScopedCFTypeRef;
  78
  79 void SendNativeCommandShift(int key_code) {
  80   CGEventSourceRef event_source =
  81       CGEventSourceCreate(kCGEventSourceStateHIDSystemState);
  82   CGEventTapLocation event_tap_location = kCGHIDEventTap;
  83
  84   // Create the keyboard press events.
  85   ScopedCFTypeRef<CGEventRef> command_down(CGEventCreateKeyboardEvent(
  86       event_source, kVK_Command, true));
  87   ScopedCFTypeRef<CGEventRef> shift_down(CGEventCreateKeyboardEvent(
  88       event_source, kVK_Shift, true));
  89   ScopedCFTypeRef<CGEventRef> key_down(CGEventCreateKeyboardEvent(
  90       event_source, key_code, true));
  91   CGEventSetFlags(key_down, kCGEventFlagMaskCommand | kCGEventFlagMaskShift);
  92
  93   // Create the keyboard release events.
  94   ScopedCFTypeRef<CGEventRef> command_up(CGEventCreateKeyboardEvent(
  95       event_source, kVK_Command, false));
  96   ScopedCFTypeRef<CGEventRef> shift_up(CGEventCreateKeyboardEvent(
  97       event_source, kVK_Shift, false));
  98   ScopedCFTypeRef<CGEventRef> key_up(CGEventCreateKeyboardEvent(
  99       event_source, key_code, false));
 100   CGEventSetFlags(key_up, kCGEventFlagMaskCommand | kCGEventFlagMaskShift);
 101
 102   // Post all of the events.
 103   CGEventPost(event_tap_location, command_down);
 104   CGEventPost(event_tap_location, shift_down);
 105   CGEventPost(event_tap_location, key_down);
 106   CGEventPost(event_tap_location, key_up);
 107   CGEventPost(event_tap_location, shift_up);
 108   CGEventPost(event_tap_location, command_up);
 109
 110   CFRelease(event_source);
 111 }
 112 #endif
 113
 114 #if defined(OS_CHROMEOS)
 115 // Fully implemented everywhere except Chrome OS.
 116 #define MAYBE_GlobalCommand DISABLED_GlobalCommand
 117 #else
 118 #define MAYBE_GlobalCommand GlobalCommand
 119 #endif
 120
 121 // Test the basics of global commands and make sure they work when Chrome
 122 // doesn't have focus. Also test that non-global commands are not treated as
 123 // global and that keys beyond Ctrl+Shift+[0..9] cannot be auto-assigned by an
 124 // extension.
 125 IN_PROC_BROWSER_TEST_F(GlobalCommandsApiTest, MAYBE_GlobalCommand) {
 126   FeatureSwitch::ScopedOverride enable_global_commands(
 127       FeatureSwitch::global_commands(), true);
 128
 129   // Load the extension in the non-incognito browser.
 130   ResultCatcher catcher;
 131   ASSERT_TRUE(RunExtensionTest("keybinding/global")) << message_;
 132   ASSERT_TRUE(catcher.GetNextResult());
 133
 134 #if defined(OS_WIN)
 135   // Our infrastructure for sending keys expects a browser to send them to, but
 136   // to properly test global shortcuts you need to send them to another target.
 137   // So, create an incognito browser to use as a target to send the shortcuts
 138   // to. It will ignore all of them and allow us test whether the global
 139   // shortcut really is global in nature and also that the non-global shortcut
 140   // is non-global.
 141   Browser* incognito_browser = CreateIncognitoBrowser();
 142
 143   // Try to activate the non-global shortcut (Ctrl+Shift+1) and the
 144   // non-assignable shortcut (Ctrl+Shift+A) by sending the keystrokes to the
 145   // incognito browser. Both shortcuts should have no effect (extension is not
 146   // loaded there).
 147   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 148       incognito_browser, ui::VKEY_1, true, true, false, false));
 149   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 150       incognito_browser, ui::VKEY_A, true, true, false, false));
 151
 152   // Activate the shortcut (Ctrl+Shift+9). This should have an effect.
 153   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 154       incognito_browser, ui::VKEY_9, true, true, false, false));
 155 #elif defined(OS_LINUX)
 156   // Create an incognito browser to capture the focus.
 157   CreateIncognitoBrowser();
 158
 159   // On Linux, our infrastructure for sending keys just synthesize keyboard
 160   // event and send them directly to the specified window, without notifying the
 161   // X root window. It didn't work while testing global shortcut because the
 162   // stuff of global shortcut on Linux need to be notified when KeyPress event
 163   // is happening on X root window. So we simulate the keyboard input here.
 164   SendNativeKeyEventToXDisplay(ui::VKEY_1, true, true, false);
 165   SendNativeKeyEventToXDisplay(ui::VKEY_A, true, true, false);
 166   SendNativeKeyEventToXDisplay(ui::VKEY_9, true, true, false);
 167 #elif defined(OS_MACOSX)
 168   // Create an incognito browser to capture the focus.
 169   CreateIncognitoBrowser();
 170
 171   // Send some native mac key events.
 172   SendNativeCommandShift(kVK_ANSI_1);
 173   SendNativeCommandShift(kVK_ANSI_A);
 174   SendNativeCommandShift(kVK_ANSI_9);
 175 #endif
 176
 177   // If this fails, it might be because the global shortcut failed to work,
 178   // but it might also be because the non-global shortcuts unexpectedly
 179   // worked.
 180   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 181 }
 182
 183 #if defined(OS_WIN)
 184 // The feature is only fully implemented on Windows, other platforms coming.
 185 // TODO(smus): On mac, SendKeyPress must first support media keys.
 186 #define MAYBE_GlobalDuplicatedMediaKey GlobalDuplicatedMediaKey
 187 #else
 188 #define MAYBE_GlobalDuplicatedMediaKey DISABLED_GlobalDuplicatedMediaKey
 189 #endif
 190
 191 IN_PROC_BROWSER_TEST_F(GlobalCommandsApiTest, MAYBE_GlobalDuplicatedMediaKey) {
 192   FeatureSwitch::ScopedOverride enable_global_commands(
 193       FeatureSwitch::global_commands(), true);
 194
 195   ResultCatcher catcher;
 196   ASSERT_TRUE(RunExtensionTest("keybinding/global_media_keys_0")) << message_;
 197   ASSERT_TRUE(catcher.GetNextResult());
 198   ASSERT_TRUE(RunExtensionTest("keybinding/global_media_keys_1")) << message_;
 199   ASSERT_TRUE(catcher.GetNextResult());
 200
 201   Browser* incognito_browser = CreateIncognitoBrowser();  // Ditto.
 202   WindowController* controller =
 203       incognito_browser->extension_window_controller();
 204
 205   ui_controls::SendKeyPress(controller->window()->GetNativeWindow(),
 206                             ui::VKEY_MEDIA_NEXT_TRACK,
 207                             false,
 208                             false,
 209                             false,
 210                             false);
 211
 212   // We should get two success result.
 213   ASSERT_TRUE(catcher.GetNextResult());
 214   ASSERT_TRUE(catcher.GetNextResult());
 215 }
 216
 217 }  // namespace extensions