chrome/browser/extensions/extension_keybinding_apitest.cc

   1 // Copyright (c) 2012 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/active_tab_permission_granter.h"
   6 #include "chrome/browser/extensions/api/commands/command_service.h"
   7 #include "chrome/browser/extensions/browser_action_test_util.h"
   8 #include "chrome/browser/extensions/extension_action.h"
   9 #include "chrome/browser/extensions/extension_action_manager.h"
  10 #include "chrome/browser/extensions/extension_apitest.h"
  11 #include "chrome/browser/extensions/tab_helper.h"
  12 #include "chrome/browser/sessions/session_tab_helper.h"
  13 #include "chrome/browser/ui/browser.h"
  14 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  15 #include "chrome/test/base/interactive_test_utils.h"
  16 #include "chrome/test/base/ui_test_utils.h"
  17 #include "content/public/browser/notification_service.h"
  18 #include "content/public/browser/web_contents.h"
  19 #include "content/public/test/browser_test_utils.h"
  20 #include "extensions/common/extension.h"
  21 #include "extensions/common/feature_switch.h"
  22 #include "extensions/common/permissions/permissions_data.h"
  23
  24 using content::WebContents;
  25
  26 namespace extensions {
  27
  28 class CommandsApiTest : public ExtensionApiTest {
  29  public:
  30   CommandsApiTest() {}
  31   virtual ~CommandsApiTest() {}
  32
  33  protected:
  34   BrowserActionTestUtil GetBrowserActionsBar() {
  35     return BrowserActionTestUtil(browser());
  36   }
  37
  38   bool IsGrantedForTab(const Extension* extension,
  39                        const content::WebContents* web_contents) {
  40     return PermissionsData::HasAPIPermissionForTab(
  41         extension,
  42         SessionID::IdForTab(web_contents),
  43         APIPermission::kTab);
  44   }
  45 };
  46
  47 class ScriptBadgesCommandsApiTest : public ExtensionApiTest {
  48  public:
  49   ScriptBadgesCommandsApiTest() {
  50     // We cannot add this to CommandsApiTest because then PageActions get
  51     // treated like BrowserActions and the PageAction test starts failing.
  52     FeatureSwitch::script_badges()->SetOverrideValue(
  53         FeatureSwitch::OVERRIDE_ENABLED);
  54   }
  55   virtual ~ScriptBadgesCommandsApiTest() {}
  56 };
  57
  58 // Test the basic functionality of the Keybinding API:
  59 // - That pressing the shortcut keys should perform actions (activate the
  60 //   browser action or send an event).
  61 // - Note: Page action keybindings are tested in PageAction test below.
  62 // - The shortcut keys taken by one extension are not overwritten by the last
  63 //   installed extension.
  64 IN_PROC_BROWSER_TEST_F(CommandsApiTest, Basic) {
  65   ASSERT_TRUE(test_server()->Start());
  66   ASSERT_TRUE(RunExtensionTest("keybinding/basics")) << message_;
  67   const Extension* extension = GetSingleLoadedExtension();
  68   ASSERT_TRUE(extension) << message_;
  69
  70   // Load this extension, which uses the same keybindings but sets the page
  71   // to different colors. This is so we can see that it doesn't interfere. We
  72   // don't test this extension in any other way (it should otherwise be
  73   // immaterial to this test).
  74   ASSERT_TRUE(RunExtensionTest("keybinding/conflicting")) << message_;
  75
  76   // Test that there are two browser actions in the toolbar.
  77   ASSERT_EQ(2, GetBrowserActionsBar().NumberOfBrowserActions());
  78
  79   ui_test_utils::NavigateToURL(browser(),
  80       test_server()->GetURL("files/extensions/test_file.txt"));
  81
  82   // activeTab shouldn't have been granted yet.
  83   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
  84   ASSERT_TRUE(tab);
  85
  86   EXPECT_FALSE(IsGrantedForTab(extension, tab));
  87
  88   // Activate the shortcut (Ctrl+Shift+F).
  89   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
  90       browser(), ui::VKEY_F, true, true, false, false));
  91
  92   // activeTab should now be granted.
  93   EXPECT_TRUE(IsGrantedForTab(extension, tab));
  94
  95   // Verify the command worked.
  96   bool result = false;
  97   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
  98       tab,
  99       "setInterval(function(){"
 100       "  if(document.body.bgColor == 'red'){"
 101       "    window.domAutomationController.send(true)}}, 100)",
 102       &result));
 103   ASSERT_TRUE(result);
 104
 105   // Activate the shortcut (Ctrl+Shift+Y).
 106   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 107       browser(), ui::VKEY_Y, true, true, false, false));
 108
 109   result = false;
 110   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 111       tab,
 112       "setInterval(function(){"
 113       "  if(document.body.bgColor == 'blue'){"
 114       "    window.domAutomationController.send(true)}}, 100)",
 115       &result));
 116   ASSERT_TRUE(result);
 117 }
 118
 119 // Flaky on linux and chromeos, http://crbug.com/165825
 120 #if defined(OS_MACOSX) || defined(OS_WIN)
 121 #define MAYBE_PageAction PageAction
 122 #else
 123 #define MAYBE_PageAction DISABLED_PageAction
 124 #endif
 125 IN_PROC_BROWSER_TEST_F(CommandsApiTest, MAYBE_PageAction) {
 126   ASSERT_TRUE(test_server()->Start());
 127   ASSERT_TRUE(RunExtensionTest("keybinding/page_action")) << message_;
 128   const Extension* extension = GetSingleLoadedExtension();
 129   ASSERT_TRUE(extension) << message_;
 130
 131   {
 132     // Load a page, the extension will detect the navigation and request to show
 133     // the page action icon.
 134     ResultCatcher catcher;
 135     ui_test_utils::NavigateToURL(browser(),
 136         test_server()->GetURL("files/extensions/test_file.txt"));
 137     ASSERT_TRUE(catcher.GetNextResult());
 138   }
 139
 140   // Make sure it appears and is the right one.
 141   ASSERT_TRUE(WaitForPageActionVisibilityChangeTo(1));
 142   int tab_id = SessionTabHelper::FromWebContents(
 143       browser()->tab_strip_model()->GetActiveWebContents())->session_id().id();
 144   ExtensionAction* action =
 145       ExtensionActionManager::Get(browser()->profile())->
 146       GetPageAction(*extension);
 147   ASSERT_TRUE(action);
 148   EXPECT_EQ("Make this page red", action->GetTitle(tab_id));
 149
 150   // Activate the shortcut (Alt+Shift+F).
 151   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 152       browser(), ui::VKEY_F, false, true, true, false));
 153
 154   // Verify the command worked (the page action turns the page red).
 155   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
 156   bool result = false;
 157   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 158       tab,
 159       "setInterval(function(){"
 160       "  if(document.body.bgColor == 'red'){"
 161       "    window.domAutomationController.send(true)}}, 100)",
 162       &result));
 163   ASSERT_TRUE(result);
 164 }
 165
 166 // Checked-in in a disabled state, because the necessary functionality to
 167 // automatically verify that the test works hasn't been implemented for the
 168 // script badges yet (see http://crbug.com/140016). The test results, can be
 169 // verified manually by running the test and verifying that the synthesized
 170 // popup for script badges appear. When bug 140016 has been fixed, the popup
 171 // code can signal to the test that the test passed.
 172 // TODO(finnur): Enable this test once the bug is fixed.
 173 IN_PROC_BROWSER_TEST_F(ScriptBadgesCommandsApiTest, DISABLED_ScriptBadge) {
 174   ASSERT_TRUE(test_server()->Start());
 175   ASSERT_TRUE(RunExtensionTest("keybinding/script_badge")) << message_;
 176   const Extension* extension = GetSingleLoadedExtension();
 177   ASSERT_TRUE(extension) << message_;
 178
 179   {
 180     ResultCatcher catcher;
 181     // Tell the extension to update the script badge state.
 182     ui_test_utils::NavigateToURL(
 183         browser(), GURL(extension->GetResourceURL("show.html")));
 184     ASSERT_TRUE(catcher.GetNextResult());
 185   }
 186
 187   {
 188     ResultCatcher catcher;
 189     // Activate the shortcut (Ctrl+Shift+F).
 190     ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 191         browser(), ui::VKEY_F, true, true, false, false));
 192     ASSERT_TRUE(catcher.GetNextResult());
 193   }
 194 }
 195
 196 // This test validates that the getAll query API function returns registered
 197 // commands as well as synthesized ones and that inactive commands (like the
 198 // synthesized ones are in nature) have no shortcuts.
 199 IN_PROC_BROWSER_TEST_F(CommandsApiTest, SynthesizedCommand) {
 200   ASSERT_TRUE(test_server()->Start());
 201   ASSERT_TRUE(RunExtensionTest("keybinding/synthesized")) << message_;
 202 }
 203
 204 // This test validates that an extension cannot request a shortcut that is
 205 // already in use by Chrome.
 206 IN_PROC_BROWSER_TEST_F(CommandsApiTest, DontOverwriteSystemShortcuts) {
 207   ASSERT_TRUE(test_server()->Start());
 208
 209   ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
 210
 211   ASSERT_TRUE(RunExtensionTest("keybinding/dont_overwrite_system")) << message_;
 212
 213   ui_test_utils::NavigateToURL(browser(),
 214       test_server()->GetURL("files/extensions/test_file.txt"));
 215
 216   WebContents* tab = browser()->tab_strip_model()->GetActiveWebContents();
 217   ASSERT_TRUE(tab);
 218
 219   // Activate the shortcut (Alt+Shift+F) to make page blue.
 220   {
 221     ResultCatcher catcher;
 222     ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 223         browser(), ui::VKEY_F, false, true, true, false));
 224     ASSERT_TRUE(catcher.GetNextResult());
 225   }
 226
 227   bool result = false;
 228   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 229       tab,
 230       "setInterval(function() {"
 231       "  if (document.body.bgColor == 'blue') {"
 232       "    window.domAutomationController.send(true)}}, 100)",
 233       &result));
 234   ASSERT_TRUE(result);
 235
 236   // Activate the shortcut (Ctrl+F) to make page red (should not work).
 237   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 238       browser(), ui::VKEY_F, true, false, false, false));
 239
 240   // The page should still be blue.
 241   result = false;
 242   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
 243       tab,
 244       "setInterval(function() {"
 245       "  if (document.body.bgColor == 'blue') {"
 246       "    window.domAutomationController.send(true)}}, 100)",
 247       &result));
 248   ASSERT_TRUE(result);
 249 }
 250
 251 #if defined(OS_WIN)
 252 // Currently this feature is implemented on Windows only.
 253 #define MAYBE_AllowDuplicatedMediaKeys AllowDuplicatedMediaKeys
 254 #else
 255 #define MAYBE_AllowDuplicatedMediaKeys DISABLED_AllowDuplicatedMediaKeys
 256 #endif
 257
 258 // Test that media keys go to all extensions that register for them.
 259 IN_PROC_BROWSER_TEST_F(CommandsApiTest, MAYBE_AllowDuplicatedMediaKeys) {
 260   ResultCatcher catcher;
 261   ASSERT_TRUE(RunExtensionTest("keybinding/non_global_media_keys_0"))
 262       << message_;
 263   ASSERT_TRUE(catcher.GetNextResult());
 264   ASSERT_TRUE(RunExtensionTest("keybinding/non_global_media_keys_1"))
 265       << message_;
 266   ASSERT_TRUE(catcher.GetNextResult());
 267
 268   // Activate the Media Stop key.
 269   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 270       browser(), ui::VKEY_MEDIA_STOP, false, false, false, false));
 271
 272   // We should get two success result.
 273   ASSERT_TRUE(catcher.GetNextResult());
 274   ASSERT_TRUE(catcher.GetNextResult());
 275 }
 276
 277 // This test validates that update (including removal) of keybinding preferences
 278 // works correctly.
 279 IN_PROC_BROWSER_TEST_F(CommandsApiTest, UpdateKeybindingPrefsTest) {
 280 #if defined(OS_MACOSX)
 281   // Send "Tab" on OS X to move the focus, otherwise the omnibox will intercept
 282   // the key presses we send below.
 283   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 284       browser(), ui::VKEY_TAB, false, false, false, false));
 285 #endif
 286   ResultCatcher catcher;
 287   ASSERT_TRUE(RunExtensionTest("keybinding/command_update"));
 288   ASSERT_TRUE(catcher.GetNextResult());
 289   const Extension* extension = GetSingleLoadedExtension();
 290
 291   CommandService* command_service = CommandService::Get(browser()->profile());
 292   extensions::CommandMap named_commands;
 293   command_service->GetNamedCommands(extension->id(),
 294                                     extensions::CommandService::ACTIVE_ONLY,
 295                                     extensions::CommandService::ANY_SCOPE,
 296                                     &named_commands);
 297   EXPECT_EQ(3u, named_commands.size());
 298
 299   const char kCommandNameC[] = "command_C";
 300   command_service->RemoveKeybindingPrefs(extension->id(), kCommandNameC);
 301   command_service->GetNamedCommands(extension->id(),
 302                                     extensions::CommandService::ACTIVE_ONLY,
 303                                     extensions::CommandService::ANY_SCOPE,
 304                                     &named_commands);
 305   EXPECT_EQ(2u, named_commands.size());
 306
 307   // Send "Alt+C", it shouldn't work because it has been removed.
 308   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 309       browser(), ui::VKEY_C, false, false, true, false));
 310
 311   const char kCommandNameB[] = "command_B";
 312   const char kKeyStroke[] = "Alt+A";
 313   command_service->UpdateKeybindingPrefs(extension->id(),
 314                                          kCommandNameB,
 315                                          kKeyStroke);
 316   command_service->GetNamedCommands(extension->id(),
 317                                     extensions::CommandService::ACTIVE_ONLY,
 318                                     extensions::CommandService::ANY_SCOPE,
 319                                     &named_commands);
 320   EXPECT_EQ(1u, named_commands.size());
 321
 322   // Activate the shortcut (Alt+A).
 323   ASSERT_TRUE(ui_test_utils::SendKeyPressSync(
 324       browser(), ui::VKEY_A, false, false, true, false));
 325   ASSERT_TRUE(catcher.GetNextResult()) << message_;
 326 }
 327
 328 }  // namespace extensions