chrome/browser/extensions/api/commands/command_service_browsertest.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 "base/prefs/scoped_user_pref_update.h"
   6 #include "chrome/browser/extensions/api/commands/command_service.h"
   7 #include "chrome/browser/extensions/extension_apitest.h"
   8 #include "chrome/browser/extensions/extension_service.h"
   9 #include "chrome/common/pref_names.h"
  10 #include "content/public/test/browser_test.h"
  11 #include "content/public/test/test_utils.h"
  12 #include "extensions/common/manifest_constants.h"
  13
  14 namespace {
  15 const char kBasicBrowserActionKeybinding[] = "Ctrl+Shift+F";
  16 const char kBasicNamedKeybinding[] = "Ctrl+Shift+Y";
  17 const char kBasicAlternateKeybinding[] = "Ctrl+Shift+G";
  18 const char kBasicNamedCommand[] = "toggle-feature";
  19
  20 // Get another command platform, whcih is used for simulating a command has been
  21 // assigned with a shortcut on another platform.
  22 std::string GetAnotherCommandPlatform() {
  23 #if defined(OS_WIN)
  24   return extensions::manifest_values::kKeybindingPlatformMac;
  25 #elif defined(OS_MACOSX)
  26   return extensions::manifest_values::kKeybindingPlatformChromeOs;
  27 #elif defined(OS_CHROMEOS)
  28   return extensions::manifest_values::kKeybindingPlatformLinux;
  29 #elif defined(OS_LINUX)
  30   return extensions::manifest_values::kKeybindingPlatformWin;
  31 #else
  32   return "";
  33 #endif
  34 }
  35
  36 }  // namespace
  37
  38 namespace extensions {
  39
  40 typedef ExtensionApiTest CommandServiceTest;
  41
  42 IN_PROC_BROWSER_TEST_F(CommandServiceTest, RemoveShortcutSurvivesUpdate) {
  43   base::ScopedTempDir scoped_temp_dir;
  44   EXPECT_TRUE(scoped_temp_dir.CreateUniqueTempDir());
  45   base::FilePath pem_path = test_data_dir_.
  46       AppendASCII("keybinding").AppendASCII("keybinding.pem");
  47   base::FilePath path_v1 = PackExtensionWithOptions(
  48       test_data_dir_.AppendASCII("keybinding").AppendASCII("update")
  49                     .AppendASCII("v1"),
  50       scoped_temp_dir.path().AppendASCII("v1.crx"),
  51       pem_path,
  52       base::FilePath());
  53   base::FilePath path_v2 = PackExtensionWithOptions(
  54       test_data_dir_.AppendASCII("keybinding").AppendASCII("update")
  55                     .AppendASCII("v2"),
  56       scoped_temp_dir.path().AppendASCII("v2.crx"),
  57       pem_path,
  58       base::FilePath());
  59
  60   ExtensionService* service = ExtensionSystem::Get(browser()->profile())->
  61       extension_service();
  62   CommandService* command_service = CommandService::Get(browser()->profile());
  63
  64   const char kId[] = "pgoakhfeplldmjheffidklpoklkppipp";
  65
  66   // Install v1 of the extension.
  67   ASSERT_TRUE(InstallExtension(path_v1, 1));
  68   EXPECT_TRUE(service->GetExtensionById(kId, false) != NULL);
  69
  70   // Verify it has a command of Alt+Shift+F.
  71   ui::Accelerator accelerator = command_service->FindCommandByName(
  72       kId, manifest_values::kBrowserActionCommandEvent).accelerator();
  73   EXPECT_EQ(ui::VKEY_F, accelerator.key_code());
  74   EXPECT_FALSE(accelerator.IsCtrlDown());
  75   EXPECT_TRUE(accelerator.IsShiftDown());
  76   EXPECT_TRUE(accelerator.IsAltDown());
  77
  78   // Remove the keybinding.
  79   command_service->RemoveKeybindingPrefs(
  80       kId, manifest_values::kBrowserActionCommandEvent);
  81
  82   // Verify it got removed.
  83   accelerator = command_service->FindCommandByName(
  84       kId, manifest_values::kBrowserActionCommandEvent).accelerator();
  85   EXPECT_EQ(ui::VKEY_UNKNOWN, accelerator.key_code());
  86
  87   // Update to version 2.
  88   EXPECT_TRUE(UpdateExtension(kId, path_v2, 0));
  89   EXPECT_TRUE(service->GetExtensionById(kId, false) != NULL);
  90
  91   // Verify it is still set to nothing.
  92   accelerator = command_service->FindCommandByName(
  93       kId, manifest_values::kBrowserActionCommandEvent).accelerator();
  94   EXPECT_EQ(ui::VKEY_UNKNOWN, accelerator.key_code());
  95 }
  96
  97 IN_PROC_BROWSER_TEST_F(CommandServiceTest,
  98                        RemoveKeybindingPrefsShouldBePlatformSpecific) {
  99   base::FilePath extension_dir =
 100       test_data_dir_.AppendASCII("keybinding").AppendASCII("basics");
 101   const Extension* extension = InstallExtension(extension_dir, 1);
 102   ASSERT_TRUE(extension);
 103
 104   DictionaryPrefUpdate updater(browser()->profile()->GetPrefs(),
 105                                prefs::kExtensionCommands);
 106   base::DictionaryValue* bindings = updater.Get();
 107
 108   // Simulate command |toggle-feature| has been assigned with a shortcut on
 109   // another platform.
 110   std::string anotherPlatformKey = GetAnotherCommandPlatform() + ":Alt+G";
 111   const char kNamedCommandName[] = "toggle-feature";
 112   base::DictionaryValue* keybinding = new base::DictionaryValue();
 113   keybinding->SetString("extension", extension->id());
 114   keybinding->SetString("command_name", kNamedCommandName);
 115   keybinding->SetBoolean("global", false);
 116   bindings->Set(anotherPlatformKey, keybinding);
 117
 118   CommandService* command_service = CommandService::Get(browser()->profile());
 119   command_service->RemoveKeybindingPrefs(extension->id(), kNamedCommandName);
 120
 121   // Removal of keybinding preference should be platform-specific, so the key on
 122   // another platform should always remained.
 123   EXPECT_TRUE(bindings->HasKey(anotherPlatformKey));
 124 }
 125
 126 IN_PROC_BROWSER_TEST_F(CommandServiceTest,
 127                        GetExtensionActionCommandQueryAll) {
 128   base::FilePath extension_dir =
 129       test_data_dir_.AppendASCII("keybinding").AppendASCII("basics");
 130   const Extension* extension = InstallExtension(extension_dir, 1);
 131   ASSERT_TRUE(extension);
 132
 133   CommandService* command_service = CommandService::Get(browser()->profile());
 134
 135   {
 136     Command command;
 137     bool active = false;
 138     EXPECT_TRUE(command_service->GetBrowserActionCommand(
 139         extension->id(), CommandService::ALL, &command, &active));
 140
 141     EXPECT_EQ(kBasicBrowserActionKeybinding,
 142               Command::AcceleratorToString(command.accelerator()));
 143     EXPECT_TRUE(active);
 144   }
 145
 146   command_service->UpdateKeybindingPrefs(
 147       extension->id(), manifest_values::kBrowserActionCommandEvent,
 148       kBasicAlternateKeybinding);
 149
 150   {
 151     Command command;
 152     bool active = false;
 153     EXPECT_TRUE(command_service->GetBrowserActionCommand(
 154         extension->id(), CommandService::ALL, &command, &active));
 155
 156     EXPECT_EQ(kBasicAlternateKeybinding,
 157               Command::AcceleratorToString(command.accelerator()));
 158     EXPECT_TRUE(active);
 159   }
 160
 161   command_service->RemoveKeybindingPrefs(
 162       extension->id(), manifest_values::kBrowserActionCommandEvent);
 163
 164   {
 165     Command command;
 166     bool active = true;
 167     EXPECT_TRUE(command_service->GetBrowserActionCommand(
 168         extension->id(), CommandService::ALL, &command, &active));
 169
 170     EXPECT_EQ(kBasicBrowserActionKeybinding,
 171               Command::AcceleratorToString(command.accelerator()));
 172     EXPECT_FALSE(active);
 173   }
 174 }
 175
 176 IN_PROC_BROWSER_TEST_F(CommandServiceTest,
 177                        GetExtensionActionCommandQueryActive) {
 178   base::FilePath extension_dir =
 179       test_data_dir_.AppendASCII("keybinding").AppendASCII("basics");
 180   const Extension* extension = InstallExtension(extension_dir, 1);
 181   ASSERT_TRUE(extension);
 182
 183   CommandService* command_service = CommandService::Get(browser()->profile());
 184
 185   {
 186     Command command;
 187     bool active = false;
 188     EXPECT_TRUE(command_service->GetBrowserActionCommand(
 189         extension->id(), CommandService::ACTIVE, &command, &active));
 190
 191     EXPECT_EQ(kBasicBrowserActionKeybinding,
 192               Command::AcceleratorToString(command.accelerator()));
 193     EXPECT_TRUE(active);
 194   }
 195
 196   command_service->UpdateKeybindingPrefs(
 197       extension->id(), manifest_values::kBrowserActionCommandEvent,
 198       kBasicAlternateKeybinding);
 199
 200   {
 201     Command command;
 202     bool active = false;
 203     EXPECT_TRUE(command_service->GetBrowserActionCommand(
 204         extension->id(), CommandService::ACTIVE, &command, &active));
 205
 206     EXPECT_EQ(kBasicAlternateKeybinding,
 207               Command::AcceleratorToString(command.accelerator()));
 208     EXPECT_TRUE(active);
 209   }
 210
 211   command_service->RemoveKeybindingPrefs(
 212       extension->id(), manifest_values::kBrowserActionCommandEvent);
 213
 214   {
 215     Command command;
 216     bool active = false;
 217     EXPECT_FALSE(command_service->GetBrowserActionCommand(
 218         extension->id(), CommandService::ACTIVE, &command, &active));
 219   }
 220 }
 221
 222 IN_PROC_BROWSER_TEST_F(CommandServiceTest,
 223                        GetExtensionActionCommandQuerySuggested) {
 224   base::FilePath extension_dir =
 225       test_data_dir_.AppendASCII("keybinding").AppendASCII("basics");
 226   const Extension* extension = InstallExtension(extension_dir, 1);
 227   ASSERT_TRUE(extension);
 228
 229   CommandService* command_service = CommandService::Get(browser()->profile());
 230
 231   {
 232     Command command;
 233     bool active = false;
 234     EXPECT_TRUE(command_service->GetBrowserActionCommand(
 235         extension->id(), CommandService::SUGGESTED, &command, &active));
 236
 237     EXPECT_EQ(kBasicBrowserActionKeybinding,
 238               Command::AcceleratorToString(command.accelerator()));
 239     EXPECT_TRUE(active);
 240   }
 241
 242   command_service->UpdateKeybindingPrefs(
 243       extension->id(), manifest_values::kBrowserActionCommandEvent,
 244       kBasicAlternateKeybinding);
 245
 246   {
 247     Command command;
 248     bool active = true;
 249     EXPECT_TRUE(command_service->GetBrowserActionCommand(
 250         extension->id(), CommandService::SUGGESTED, &command, &active));
 251
 252     EXPECT_EQ(kBasicBrowserActionKeybinding,
 253               Command::AcceleratorToString(command.accelerator()));
 254     EXPECT_FALSE(active);
 255   }
 256
 257   command_service->RemoveKeybindingPrefs(
 258       extension->id(), manifest_values::kBrowserActionCommandEvent);
 259
 260   {
 261     Command command;
 262     bool active = true;
 263     EXPECT_TRUE(command_service->GetBrowserActionCommand(
 264         extension->id(), CommandService::SUGGESTED, &command, &active));
 265
 266     EXPECT_EQ(kBasicBrowserActionKeybinding,
 267               Command::AcceleratorToString(command.accelerator()));
 268     EXPECT_FALSE(active);
 269   }
 270 }
 271
 272 IN_PROC_BROWSER_TEST_F(CommandServiceTest,
 273                        GetNamedCommandsQueryAll) {
 274   base::FilePath extension_dir =
 275       test_data_dir_.AppendASCII("keybinding").AppendASCII("basics");
 276   const Extension* extension = InstallExtension(extension_dir, 1);
 277   ASSERT_TRUE(extension);
 278
 279   CommandService* command_service = CommandService::Get(browser()->profile());
 280
 281   {
 282     CommandMap command_map;
 283     EXPECT_TRUE(command_service->GetNamedCommands(
 284         extension->id(), CommandService::ALL, CommandService::ANY_SCOPE,
 285         &command_map));
 286
 287     ASSERT_EQ(1u, command_map.count(kBasicNamedCommand));
 288     Command command = command_map[kBasicNamedCommand];
 289     EXPECT_EQ(kBasicNamedKeybinding,
 290               Command::AcceleratorToString(command.accelerator()));
 291   }
 292
 293   command_service->UpdateKeybindingPrefs(
 294       extension->id(), kBasicNamedCommand, kBasicAlternateKeybinding);
 295
 296   {
 297     CommandMap command_map;
 298     EXPECT_TRUE(command_service->GetNamedCommands(
 299         extension->id(), CommandService::ALL, CommandService::ANY_SCOPE,
 300         &command_map));
 301
 302     ASSERT_EQ(1u, command_map.count(kBasicNamedCommand));
 303     Command command = command_map[kBasicNamedCommand];
 304     EXPECT_EQ(kBasicAlternateKeybinding,
 305               Command::AcceleratorToString(command.accelerator()));
 306   }
 307
 308   command_service->RemoveKeybindingPrefs(extension->id(), kBasicNamedCommand);
 309
 310   {
 311     CommandMap command_map;
 312     EXPECT_TRUE(command_service->GetNamedCommands(
 313         extension->id(), CommandService::ALL, CommandService::ANY_SCOPE,
 314         &command_map));
 315
 316     ASSERT_EQ(1u, command_map.count(kBasicNamedCommand));
 317     Command command = command_map[kBasicNamedCommand];
 318     EXPECT_EQ(kBasicNamedKeybinding,
 319               Command::AcceleratorToString(command.accelerator()));
 320   }
 321 }
 322
 323 IN_PROC_BROWSER_TEST_F(CommandServiceTest, GetNamedCommandsQueryActive) {
 324   base::FilePath extension_dir =
 325       test_data_dir_.AppendASCII("keybinding").AppendASCII("basics");
 326   const Extension* extension = InstallExtension(extension_dir, 1);
 327   ASSERT_TRUE(extension);
 328
 329   CommandService* command_service = CommandService::Get(browser()->profile());
 330
 331   {
 332     CommandMap command_map;
 333     EXPECT_TRUE(command_service->GetNamedCommands(
 334         extension->id(), CommandService::ACTIVE, CommandService::ANY_SCOPE,
 335         &command_map));
 336
 337     ASSERT_EQ(1u, command_map.count(kBasicNamedCommand));
 338     Command command = command_map[kBasicNamedCommand];
 339     EXPECT_EQ(kBasicNamedKeybinding,
 340               Command::AcceleratorToString(command.accelerator()));
 341   }
 342
 343   command_service->UpdateKeybindingPrefs(
 344       extension->id(), kBasicNamedCommand, kBasicAlternateKeybinding);
 345
 346   {
 347     CommandMap command_map;
 348     EXPECT_TRUE(command_service->GetNamedCommands(
 349         extension->id(), CommandService::ACTIVE, CommandService::ANY_SCOPE,
 350         &command_map));
 351
 352     ASSERT_EQ(1u, command_map.count(kBasicNamedCommand));
 353     Command command = command_map[kBasicNamedCommand];
 354     EXPECT_EQ(kBasicAlternateKeybinding,
 355               Command::AcceleratorToString(command.accelerator()));
 356   }
 357
 358   command_service->RemoveKeybindingPrefs(extension->id(), kBasicNamedCommand);
 359
 360   {
 361     CommandMap command_map;
 362     command_service->GetNamedCommands(
 363         extension->id(), CommandService::ACTIVE, CommandService::ANY_SCOPE,
 364         &command_map);
 365     EXPECT_EQ(0u, command_map.count(kBasicNamedCommand));
 366   }
 367 }
 368
 369 IN_PROC_BROWSER_TEST_F(CommandServiceTest,
 370                        GetNamedCommandsQuerySuggested) {
 371   base::FilePath extension_dir =
 372       test_data_dir_.AppendASCII("keybinding").AppendASCII("basics");
 373   const Extension* extension = InstallExtension(extension_dir, 1);
 374   ASSERT_TRUE(extension);
 375
 376   CommandService* command_service = CommandService::Get(browser()->profile());
 377
 378   {
 379     CommandMap command_map;
 380     EXPECT_TRUE(command_service->GetNamedCommands(
 381         extension->id(), CommandService::SUGGESTED, CommandService::ANY_SCOPE,
 382         &command_map));
 383
 384     ASSERT_EQ(1u, command_map.count(kBasicNamedCommand));
 385     Command command = command_map[kBasicNamedCommand];
 386     EXPECT_EQ(kBasicNamedKeybinding,
 387               Command::AcceleratorToString(command.accelerator()));
 388   }
 389
 390   command_service->UpdateKeybindingPrefs(
 391       extension->id(), kBasicNamedCommand, kBasicAlternateKeybinding);
 392
 393   {
 394     CommandMap command_map;
 395     EXPECT_TRUE(command_service->GetNamedCommands(
 396         extension->id(), CommandService::SUGGESTED, CommandService::ANY_SCOPE,
 397         &command_map));
 398
 399     ASSERT_EQ(1u, command_map.count(kBasicNamedCommand));
 400     Command command = command_map[kBasicNamedCommand];
 401     EXPECT_EQ(kBasicNamedKeybinding,
 402               Command::AcceleratorToString(command.accelerator()));
 403   }
 404
 405   command_service->RemoveKeybindingPrefs(extension->id(), kBasicNamedCommand);
 406
 407   {
 408     CommandMap command_map;
 409     EXPECT_TRUE(command_service->GetNamedCommands(
 410         extension->id(), CommandService::SUGGESTED, CommandService::ANY_SCOPE,
 411         &command_map));
 412
 413     ASSERT_EQ(1u, command_map.count(kBasicNamedCommand));
 414     Command command = command_map[kBasicNamedCommand];
 415     EXPECT_EQ(kBasicNamedKeybinding,
 416               Command::AcceleratorToString(command.accelerator()));
 417   }
 418 }
 419
 420 }  // namespace extensions