| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 "base/callback.h" | |
| 6 #include "base/logging.h" | |
| 7 #include "base/macros.h" | |
| 8 #include "base/strings/stringprintf.h" | |
| 9 #include "chrome/browser/apps/app_browsertest_util.h" | |
| 10 #include "chrome/test/base/interactive_test_utils.h" | |
| 11 #include "components/version_info/version_info.h" | |
| 12 #include "extensions/browser/app_window/native_app_window.h" | |
| 13 #include "extensions/test/extension_test_message_listener.h" | |
| 14 #include "testing/gtest/include/gtest/gtest-spi.h" | |
| 15 | |
| 16 using extensions::NativeAppWindow; | |
| 17 | |
| 18 class AppWindowInterceptAllKeysTest | |
| 19 : public extensions::PlatformAppBrowserTest { | |
| 20 public: | |
| 21 // Send key to window but does not wait till the key is actually in the input | |
| 22 // queue (like ui_test_utils::SendKeyPressToWindowSync()) as key will not be | |
| 23 // sent to hook when keyboard is intercepted. | |
| 24 bool SimulateKeyPress(ui::KeyboardCode key, | |
| 25 bool control, | |
| 26 bool shift, | |
| 27 bool alt, | |
| 28 bool command) { | |
| 29 DVLOG(1) << "Sending: " << key << " control = " << control | |
| 30 << " shift = " << shift << " alt = " << alt | |
| 31 << " command = " << command; | |
| 32 if (!ui_controls::SendKeyPressNotifyWhenDone( | |
| 33 GetFirstAppWindow()->GetNativeWindow(), key, control, shift, alt, | |
| 34 command, null_callback_)) { | |
| 35 LOG(WARNING) << "Failed to send key to app"; | |
| 36 failure_message_ = "Failed to send key to app."; | |
| 37 return false; | |
| 38 } | |
| 39 | |
| 40 base::RunLoop().RunUntilIdle(); | |
| 41 return !testing::Test::HasFatalFailure(); | |
| 42 } | |
| 43 | |
| 44 bool SimulateKeyPress(ui::KeyboardCode key) { | |
| 45 return SimulateKeyPress(key, false, false, false, false); | |
| 46 } | |
| 47 | |
| 48 bool WaitForKeyEvent(ui::KeyboardCode code) { | |
| 49 std::string key_event = base::StringPrintf("KeyReceived: %d", code); | |
| 50 ExtensionTestMessageListener key_listener(key_event, false); | |
| 51 | |
| 52 if (!SimulateKeyPress(code)) { | |
| 53 failure_message_ = "Failed to send key to app"; | |
| 54 return false; | |
| 55 } | |
| 56 | |
| 57 key_listener.WaitUntilSatisfied(); | |
| 58 | |
| 59 DVLOG(1) << "Application ACK-ed keypress"; | |
| 60 return true; | |
| 61 } | |
| 62 | |
| 63 bool LoadApplication(const char* app_path) { | |
| 64 DVLOG(1) << "Launching app = " << app_path; | |
| 65 LoadAndLaunchPlatformApp(app_path, "Launched"); | |
| 66 | |
| 67 DVLOG(1) << "Validating that application is in focus"; | |
| 68 // We start by making sure the window is actually focused. | |
| 69 if (!ui_test_utils::ShowAndFocusNativeWindow( | |
| 70 GetFirstAppWindow()->GetNativeWindow())) { | |
| 71 failure_message_ = "App did not get focus."; | |
| 72 return false; | |
| 73 } | |
| 74 | |
| 75 DVLOG(1) << "Launched application"; | |
| 76 return true; | |
| 77 } | |
| 78 | |
| 79 void SendTaskSwitchKeys() { | |
| 80 // Send switch sequence (currently just for windows - will have to update as | |
| 81 // more platform support is added). | |
| 82 SimulateKeyPress(ui::VKEY_TAB, false, false, true, false); | |
| 83 } | |
| 84 | |
| 85 void ValidateCannotInterceptKeys(const char* app_path, | |
| 86 bool change_intercept, | |
| 87 bool enable_intercept) { | |
| 88 ExtensionTestMessageListener command_listener("readyForCommand", true); | |
| 89 ASSERT_TRUE(LoadApplication(app_path)) << failure_message_; | |
| 90 | |
| 91 const char* message = ""; | |
| 92 if (change_intercept) { | |
| 93 message = enable_intercept ? "enable" : "disable"; | |
| 94 } | |
| 95 ASSERT_TRUE(command_listener.WaitUntilSatisfied()); | |
| 96 command_listener.Reply(message); | |
| 97 command_listener.Reset(); | |
| 98 | |
| 99 ASSERT_TRUE(WaitForKeyEvent(ui::VKEY_Z)) << failure_message_; | |
| 100 | |
| 101 SendTaskSwitchKeys(); | |
| 102 | |
| 103 // Send key and check if it is received. | |
| 104 ASSERT_FALSE(SimulateKeyPress(ui::VKEY_Z)) << failure_message_; | |
| 105 } | |
| 106 | |
| 107 void ValidateInterceptKeys(bool disable_after_enabling) { | |
| 108 ExtensionTestMessageListener command_listener("readyForCommand", true); | |
| 109 ASSERT_TRUE(LoadApplication(app_with_permission_)) << failure_message_; | |
| 110 | |
| 111 // setInterceptAllKeys() is asynchronous so wait for response and receiving | |
| 112 // a key back. | |
| 113 ASSERT_TRUE(command_listener.WaitUntilSatisfied()); | |
| 114 command_listener.Reply("enable"); | |
| 115 command_listener.Reset(); | |
| 116 | |
| 117 ASSERT_TRUE(WaitForKeyEvent(ui::VKEY_Z)) << failure_message_; | |
| 118 | |
| 119 SendTaskSwitchKeys(); | |
| 120 | |
| 121 // Send key and check if it is received. | |
| 122 ASSERT_TRUE(SimulateKeyPress(ui::VKEY_Z)) << failure_message_; | |
| 123 | |
| 124 ASSERT_TRUE(WaitForKeyEvent(ui::VKEY_Z)) << failure_message_; | |
| 125 | |
| 126 if (disable_after_enabling) { | |
| 127 ASSERT_TRUE(command_listener.WaitUntilSatisfied()); | |
| 128 command_listener.Reply("disable"); | |
| 129 command_listener.Reset(); | |
| 130 ASSERT_TRUE(command_listener.WaitUntilSatisfied()); | |
| 131 } | |
| 132 } | |
| 133 | |
| 134 protected: | |
| 135 std::string failure_message_; | |
| 136 base::Callback<void(void)> null_callback_; | |
| 137 const char* app_with_permission_ = | |
| 138 "window_api_intercept_all_keys/has_permission"; | |
| 139 const char* app_without_permission_ = | |
| 140 "window_api_intercept_all_keys/no_permission"; | |
| 141 }; | |
| 142 | |
| 143 // Currently this is implemented only for Windows. | |
| 144 // Disabled test http://crbug.com/438209 | |
| 145 #if defined(OS_WIN) | |
| 146 #define MAYBE_GetKeysAfterSwitchSequence DISABLED_GetKeysAfterSwitchSequence | |
| 147 #else | |
| 148 #define MAYBE_GetKeysAfterSwitchSequence DISABLED_GetKeysAfterSwitchSequence | |
| 149 #endif | |
| 150 | |
| 151 // Tests a window continues to keep focus even after application switch key | |
| 152 // sequence is sent when setInterceptAllKeys() is enabled. | |
| 153 IN_PROC_BROWSER_TEST_F(AppWindowInterceptAllKeysTest, | |
| 154 MAYBE_GetKeysAfterSwitchSequence) { | |
| 155 ValidateInterceptKeys(false); | |
| 156 } | |
| 157 | |
| 158 // Test to make sure that keys not received after disable. | |
| 159 // Disabled test http://crbug.com/438209 | |
| 160 #if defined(OS_WIN) | |
| 161 #define MAYBE_NoKeysAfterDisableIsCalled DISABLED_NoKeysAfterDisableIsCalled | |
| 162 #else | |
| 163 #define MAYBE_NoKeysAfterDisableIsCalled DISABLED_NoKeysAfterDisableIsCalled | |
| 164 #endif | |
| 165 | |
| 166 IN_PROC_BROWSER_TEST_F(AppWindowInterceptAllKeysTest, | |
| 167 MAYBE_NoKeysAfterDisableIsCalled) { | |
| 168 ValidateInterceptKeys(true); | |
| 169 | |
| 170 ASSERT_TRUE(WaitForKeyEvent(ui::VKEY_Z)) << failure_message_; | |
| 171 | |
| 172 SendTaskSwitchKeys(); | |
| 173 | |
| 174 // Send key and check if it is received. | |
| 175 ASSERT_FALSE(SimulateKeyPress(ui::VKEY_Z)) << failure_message_; | |
| 176 } | |
| 177 | |
| 178 // Test that calling just disable has no effect in retaining keyboard intercept. | |
| 179 // Currently this is implemented only for Windows. | |
| 180 // Disabled test http://crbug.com/438209 | |
| 181 #if defined(OS_WIN) | |
| 182 #define MAYBE_NoopCallingDisableInterceptAllKeys \ | |
| 183 DISABLED_NoopCallingDisableInterceptAllKeys | |
| 184 #else | |
| 185 #define MAYBE_NoopCallingDisableInterceptAllKeys \ | |
| 186 DISABLED_NoopCallingDisableInterceptAllKeys | |
| 187 #endif | |
| 188 | |
| 189 IN_PROC_BROWSER_TEST_F(AppWindowInterceptAllKeysTest, | |
| 190 MAYBE_NoopCallingDisableInterceptAllKeys) { | |
| 191 ValidateCannotInterceptKeys(app_with_permission_, true, false); | |
| 192 } | |
| 193 | |
| 194 // Test no effect when called without permissions | |
| 195 // Currently this is implemented only for Windows. | |
| 196 #if defined(OS_WIN) | |
| 197 #define MAYBE_NoopCallingEnableWithoutPermission \ | |
| 198 DISABLED_NoopCallingEnableWithoutPermission | |
| 199 #else | |
| 200 #define MAYBE_NoopCallingEnableWithoutPermission \ | |
| 201 DISABLED_NoopCallingEnableWithoutPermission | |
| 202 #endif | |
| 203 | |
| 204 IN_PROC_BROWSER_TEST_F(AppWindowInterceptAllKeysTest, | |
| 205 MAYBE_NoopCallingEnableWithoutPermission) { | |
| 206 ValidateCannotInterceptKeys(app_without_permission_, true, true); | |
| 207 } | |
| 208 | |
| 209 // Test that intercept is disabled by default | |
| 210 #if defined(OS_WIN) | |
| 211 // Disabled test http://crbug.com/438209 | |
| 212 #define MAYBE_InterceptDisabledByDefault DISABLED_InterceptDisabledByDefault | |
| 213 #else | |
| 214 #define MAYBE_InterceptDisabledByDefault DISABLED_InterceptDisabledByDefault | |
| 215 #endif | |
| 216 | |
| 217 IN_PROC_BROWSER_TEST_F(AppWindowInterceptAllKeysTest, | |
| 218 MAYBE_InterceptDisabledByDefault) { | |
| 219 ValidateCannotInterceptKeys(app_with_permission_, false, false); | |
| 220 } | |
| 221 | |
| 222 // Tests that the application cannot be loaded in stable. | |
| 223 IN_PROC_BROWSER_TEST_F(AppWindowInterceptAllKeysTest, CannotLoadOtherThanDev) { | |
| 224 version_info::Channel version_info[] = { | |
| 225 version_info::Channel::BETA, version_info::Channel::STABLE}; | |
| 226 for (unsigned int index = 0; index < arraysize(version_info); index++) { | |
| 227 extensions::ScopedCurrentChannel channel(version_info[index]); | |
| 228 const extensions::Extension* extension = nullptr; | |
| 229 EXPECT_NONFATAL_FAILURE( | |
| 230 extension = LoadExtension(test_data_dir_.AppendASCII("platform_apps") | |
| 231 .AppendASCII(app_with_permission_)), | |
| 232 ""); | |
| 233 | |
| 234 DVLOG(1) << "Finished loading extension"; | |
| 235 | |
| 236 ASSERT_TRUE(extension == nullptr) << "Application loaded in" | |
| 237 << static_cast<int>(version_info[index]) | |
| 238 << " while permission does not exist"; | |
| 239 } | |
| 240 } | |
| 241 | |
| 242 // Inject different keyboard combos and make sure that the app get them all. | |
| 243 // Disabled test http://crbug.com/438209 | |
| 244 #if defined(OS_WIN) | |
| 245 #define MAYBE_ValidateKeyEvent DISABLED_ValidateKeyEvent | |
| 246 #else | |
| 247 #define MAYBE_ValidateKeyEvent DISABLED_ValidateKeyEvent | |
| 248 #endif | |
| 249 | |
| 250 namespace { | |
| 251 // Maximum lenght of the result array in KeyEventTestData structure. | |
| 252 const size_t kMaxResultLength = 10; | |
| 253 | |
| 254 // A structure holding test data of a keyboard event. | |
| 255 // Each keyboard event may generate multiple result strings representing | |
| 256 // the result of keydown, keypress, keyup and textInput events. | |
| 257 // For keydown, keypress and keyup events, the format of the result string is: | |
| 258 // <type> <keyCode> <charCode> <ctrlKey> <shiftKey> <altKey> <commandKey> | |
| 259 // where <type> may be 'D' (keydown), 'P' (keypress) or 'U' (keyup). | |
| 260 // <ctrlKey>, <shiftKey> <altKey> and <commandKey> are boolean value indicating | |
| 261 // the state of corresponding modifier key. | |
| 262 struct KeyEventTestData { | |
| 263 ui::KeyboardCode key; | |
| 264 bool control; | |
| 265 bool shift; | |
| 266 bool alt; | |
| 267 bool command; | |
| 268 | |
| 269 int result_length; | |
| 270 const char* const result[kMaxResultLength]; | |
| 271 }; | |
| 272 } // namespace | |
| 273 | |
| 274 IN_PROC_BROWSER_TEST_F(AppWindowInterceptAllKeysTest, MAYBE_ValidateKeyEvent) { | |
| 275 // Launch the app | |
| 276 ValidateInterceptKeys(false); | |
| 277 | |
| 278 static const KeyEventTestData kValidateKeyEvents[] = { | |
| 279 // a | |
| 280 {ui::VKEY_A, | |
| 281 false, | |
| 282 false, | |
| 283 false, | |
| 284 false, | |
| 285 3, | |
| 286 {"D 65 0 false false false false", | |
| 287 "P 97 97 false false false false", | |
| 288 "U 65 0 false false false false"}}, | |
| 289 // shift+a | |
| 290 {ui::VKEY_A, | |
| 291 false, | |
| 292 true, | |
| 293 false, | |
| 294 false, | |
| 295 5, | |
| 296 {"D 16 0 false true false false", | |
| 297 "D 65 0 false true false false", | |
| 298 "P 65 65 false true false false", | |
| 299 "U 65 0 false true false false", | |
| 300 "U 16 0 false true false false"}}, | |
| 301 // ctrl+f which has accelerator binding should also result in all keys | |
| 302 // being | |
| 303 // sent. | |
| 304 {ui::VKEY_F, | |
| 305 true, | |
| 306 false, | |
| 307 false, | |
| 308 false, | |
| 309 5, | |
| 310 {"D 17 0 true false false false", | |
| 311 "D 70 0 true false false false", | |
| 312 "P 6 6 true false false false", | |
| 313 "U 70 0 true false false false", | |
| 314 "U 17 0 true false false false"}}, | |
| 315 // ctrl+z | |
| 316 {ui::VKEY_Z, | |
| 317 true, | |
| 318 false, | |
| 319 false, | |
| 320 false, | |
| 321 5, | |
| 322 {"D 17 0 true false false false", | |
| 323 "D 90 0 true false false false", | |
| 324 "P 26 26 true false false false", | |
| 325 "U 90 0 true false false false", | |
| 326 "U 17 0 true false false false"}}, | |
| 327 // alt+f | |
| 328 {ui::VKEY_F, | |
| 329 false, | |
| 330 false, | |
| 331 true, | |
| 332 false, | |
| 333 4, | |
| 334 {"D 18 0 false false true false", | |
| 335 "D 70 0 false false true false", | |
| 336 "U 70 0 false false true false", | |
| 337 "U 18 0 false false true false"}}, | |
| 338 // make sure both left and right shift makes it across | |
| 339 {ui::VKEY_RSHIFT, | |
| 340 false, | |
| 341 false, | |
| 342 false, | |
| 343 false, | |
| 344 2, | |
| 345 {"D 16 0 false true false false", "U 16 0 false true false false"}}, | |
| 346 }; | |
| 347 | |
| 348 DVLOG(1) << "Starting keyboard input test"; | |
| 349 | |
| 350 for (unsigned int index = 0; index < arraysize(kValidateKeyEvents); index++) { | |
| 351 // create all the event listeners needed | |
| 352 const KeyEventTestData* current_event = &kValidateKeyEvents[index]; | |
| 353 scoped_ptr<ExtensionTestMessageListener> listeners[kMaxResultLength]; | |
| 354 for (int i = 0; i < current_event->result_length; i++) { | |
| 355 listeners[i].reset( | |
| 356 new ExtensionTestMessageListener(current_event->result[i], false)); | |
| 357 } | |
| 358 ASSERT_TRUE(SimulateKeyPress(current_event->key, current_event->control, | |
| 359 current_event->shift, current_event->alt, | |
| 360 current_event->command)); | |
| 361 for (int i = 0; i < current_event->result_length; i++) { | |
| 362 EXPECT_TRUE(listeners[i]->WaitUntilSatisfied()); | |
| 363 } | |
| 364 } | |
| 365 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1316013004:
Remove "API proposal for chrome.app.window to intercept all keys." (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master