chrome/browser/extensions/commands/command_service.cc

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/extensions/commands/command_service.h"

#include <memory>
#include <string_view>
#include <utility>
#include <vector>

#include "base/lazy_instance.h"
#include "base/observer_list.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "build/build_config.h"
#include "chrome/browser/extensions/extension_commands_global_registry.h"
#include "chrome/browser/extensions/extension_keybinding_registry.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ui/accelerator_utils.h"
#include "chrome/common/pref_names.h"
#include "components/pref_registry/pref_registry_syncable.h"
#include "components/prefs/scoped_user_pref_update.h"
#include "extensions/browser/extension_function_registry.h"
#include "extensions/browser/extension_prefs.h"
#include "extensions/browser/extension_system.h"
#include "extensions/common/api/commands/commands_handler.h"
#include "extensions/common/command.h"
#include "extensions/common/extension_id.h"
#include "extensions/common/feature_switch.h"
#include "extensions/common/manifest_constants.h"
#include "extensions/common/permissions/permissions_data.h"
#include "ui/base/accelerators/command.h"

namespace extensions {
namespace {

const char kExtension[] = "extension";
const char kCommandName[] = "command_name";
const char kGlobal[] = "global";

// A preference that stores keybinding state associated with extension commands.
const char kCommands[] = "commands";

// Preference key name for saving the extension-suggested key.
const char kSuggestedKey[] = "suggested_key";

// Preference key name for saving whether the extension-suggested key was
// actually assigned.
const char kSuggestedKeyWasAssigned[] = "was_assigned";

std::string GetPlatformKeybindingKeyForAccelerator(
    const ui::Accelerator& accelerator,
    const ExtensionId& extension_id) {
  std::string key = Command::CommandPlatform() + ":" +
                    Command::AcceleratorToString(accelerator);

  // Media keys have a 1-to-many relationship with targets, unlike regular
  // shortcut (1-to-1 relationship). That means two or more extensions can
  // register for the same media key so the extension ID needs to be added to
  // the key to make sure the key is unique.
  if (accelerator.IsMediaKey()) {
    key += ":" + extension_id;
  }

  return key;
}

bool IsForCurrentPlatform(const std::string& key) {
  return base::StartsWith(key, Command::CommandPlatform() + ":",
                          base::CompareCase::SENSITIVE);
}

// Merge |suggested_key_prefs| into the saved preferences for the extension. We
// merge rather than overwrite to preserve existing was_assigned preferences.
void MergeSuggestedKeyPrefs(const ExtensionId& extension_id,
                            ExtensionPrefs* extension_prefs,
                            base::Value::Dict suggested_key_prefs) {
  const base::Value::Dict* current_prefs =
      extension_prefs->ReadPrefAsDict(extension_id, kCommands);
  if (current_prefs) {
    base::Value::Dict new_prefs = current_prefs->Clone();
    new_prefs.Merge(std::move(suggested_key_prefs));
    suggested_key_prefs = std::move(new_prefs);
  }

  extension_prefs->UpdateExtensionPref(
      extension_id, kCommands, base::Value(std::move(suggested_key_prefs)));
}

// Clears the "was_assigned" preference for a list of `removed_commands`. This
// is called when a keybinding is removed to signify that the suggested key is
// no longer assigned, so it can be auto-assigned again in the future.
void ClearSuggestedKeyWasAssignedPrefs(
    const ExtensionId& extension_id,
    ExtensionPrefs& extension_prefs,
    const std::vector<Command>& removed_commands) {
  if (removed_commands.empty()) {
    return;
  }

  ExtensionPrefs::ScopedDictionaryUpdate updater(&extension_prefs, extension_id,
                                                 kCommands);
  std::unique_ptr<prefs::DictionaryValueUpdate> current_prefs = updater.Get();

  for (const Command& removed_command : removed_commands) {
    std::unique_ptr<prefs::DictionaryValueUpdate> command_prefs;
    if (current_prefs->GetDictionary(removed_command.command_name(),
                                     &command_prefs)) {
      command_prefs->Remove(kSuggestedKeyWasAssigned);
    }
  }
}

// Returns true if a command is relevant for the given `query_type`.
bool IsCommandRelevant(CommandService::QueryType query_type,
                       bool is_active,
                       bool user_modified) {
  switch (query_type) {
    case CommandService::ALL:
      return true;
    case CommandService::ACTIVE:
      return is_active;
    case CommandService::ACTIVE_OR_USER_MODIFIED:
      // We want to be able to include commands that were explicitly unset by
      // the user (via ACTIVE_OR_USER_MODIFIED) so that we don't override
      // their preference with the default binding. See crbug.com/436279086.
      return is_active || user_modified;
  }
}

}  // namespace

// static
void CommandService::RegisterProfilePrefs(
    user_prefs::PrefRegistrySyncable* registry) {
  registry->RegisterDictionaryPref(
      prefs::kExtensionCommands,
      user_prefs::PrefRegistrySyncable::SYNCABLE_PREF);
}

CommandService::CommandService(content::BrowserContext* context)
    : profile_(Profile::FromBrowserContext(context)) {
  extension_registry_observation_.Observe(ExtensionRegistry::Get(profile_));
}

CommandService::~CommandService() {
  for (auto& observer : observers_)
    observer.OnCommandServiceDestroying();
}

static base::LazyInstance<BrowserContextKeyedAPIFactory<CommandService>>::
    DestructorAtExit g_command_service_factory = LAZY_INSTANCE_INITIALIZER;

// static
BrowserContextKeyedAPIFactory<CommandService>*
CommandService::GetFactoryInstance() {
  return g_command_service_factory.Pointer();
}

// static
CommandService* CommandService::Get(content::BrowserContext* context) {
  return BrowserContextKeyedAPIFactory<CommandService>::Get(context);
}

bool CommandService::GetNamedCommands(const ExtensionId& extension_id,
                                      QueryType type,
                                      CommandScope scope,
                                      ui::CommandMap* command_map) const {
  const Extension* extension =
      GetExtensionInEnabledOrDisabledExtensions(extension_id);
  if (!extension) {
    return false;
  }

  command_map->clear();
  const ui::CommandMap* commands = CommandsInfo::GetNamedCommands(extension);
  if (!commands)
    return false;

  for (const auto& named_command : *commands) {
    // Look up to see if the user has overridden how the command should work.
    Command saved_command =
        FindCommandByName(extension_id, named_command.second.command_name());
    ui::Accelerator shortcut_assigned = saved_command.accelerator();

    bool user_modified = IsCommandShortcutUserModified(
        extension, named_command.second.command_name());
    bool is_active = shortcut_assigned.key_code() != ui::VKEY_UNKNOWN;
    if (!IsCommandRelevant(type, is_active, user_modified)) {
      continue;
    }

    ui::Command command = named_command.second;
    if (scope != ANY_SCOPE && ((scope == GLOBAL) != saved_command.global()))
      continue;

    if (is_active || user_modified) {
      command.set_accelerator(shortcut_assigned);
    }
    command.set_global(saved_command.global());

    (*command_map)[named_command.second.command_name()] = command;
  }

  return !command_map->empty();
}

bool CommandService::AddKeybindingPref(const ui::Accelerator& accelerator,
                                       const ExtensionId& extension_id,
                                       const std::string& command_name,
                                       bool allow_overrides,
                                       bool global) {
  // Nothing needs to be done if the existing command is the same as the desired
  // new one.
  Command existing_command = FindCommandByName(extension_id, command_name);
  if (existing_command.command_name() == command_name &&
      existing_command.accelerator() == accelerator &&
      existing_command.global() == global) {
    return true;
  }

  // Media Keys are allowed to be used by named command only.
  DCHECK(!accelerator.IsMediaKey() ||
         !Command::IsActionRelatedCommand(command_name));

  ScopedDictPrefUpdate updater(profile_->GetPrefs(), prefs::kExtensionCommands);
  base::Value::Dict& bindings = updater.Get();

  std::string key = GetPlatformKeybindingKeyForAccelerator(accelerator,
                                                           extension_id);

  if (bindings.Find(key)) {
    if (!allow_overrides)
      return false;  // Already taken.

    // If the shortcut has been assigned to another command, it should be
    // removed before overriding, so that |ExtensionKeybindingRegistry| can get
    // a chance to do clean-up.
    const base::Value::Dict* item = bindings.FindDict(key);
    const ExtensionId* old_extension_id = item->FindString(kExtension);
    const std::string* old_command_name = item->FindString(kCommandName);
    RemoveKeybindingPrefs(old_extension_id ? *old_extension_id : std::string(),
                          old_command_name ? *old_command_name : std::string());
  }

  // If the command that is taking a new shortcut already has a shortcut, remove
  // it before assigning the new one.
  if (existing_command.accelerator().key_code() != ui::VKEY_UNKNOWN)
    RemoveKeybindingPrefs(extension_id, command_name);

  if (accelerator.key_code() != ui::VKEY_UNKNOWN) {
    // Set the keybinding pref.
    base::Value::Dict keybinding;
    keybinding.Set(kExtension, extension_id);
    keybinding.Set(kCommandName, command_name);
    keybinding.Set(kGlobal, global);
    bindings.Set(key, std::move(keybinding));
  }

  // Set the was_assigned pref for the suggested key.
  base::Value::Dict command_keys;
  command_keys.Set(kSuggestedKeyWasAssigned, true);
  base::Value::Dict suggested_key_prefs;
  suggested_key_prefs.Set(command_name, base::Value(std::move(command_keys)));
  MergeSuggestedKeyPrefs(extension_id, ExtensionPrefs::Get(profile_),
                         std::move(suggested_key_prefs));

  // Fetch the newly-updated command, and notify the observers.
  Command command = FindCommandByName(extension_id, command_name);
  for (auto& observer : observers_) {
    if (accelerator.key_code() != ui::VKEY_UNKNOWN) {
      observer.OnExtensionCommandAdded(extension_id, command);
    } else {
      observer.OnExtensionCommandRemoved(extension_id, command);
    }
  }

  return true;
}

void CommandService::OnExtensionWillBeInstalled(
    content::BrowserContext* browser_context,
    const Extension* extension,
    bool is_update,
    const std::string& old_name) {
  UpdateKeybindings(extension);
}

void CommandService::OnExtensionUninstalled(
    content::BrowserContext* browser_context,
    const Extension* extension,
    extensions::UninstallReason reason) {
  // Adding a component extensions will only trigger install the first time on a
  // clean profile or on a version increase (see
  // ComponentLoader::AddComponentExtension). It will, however, always trigger
  // an uninstall on removal. See http://crbug.com/458612. Isolate this case and
  // ignore it.
  if (reason == extensions::UNINSTALL_REASON_COMPONENT_REMOVED)
    return;

  RemoveKeybindingPrefs(extension->id(), std::string());
}

void CommandService::UpdateKeybindingPrefs(const ExtensionId& extension_id,
                                           const std::string& command_name,
                                           const std::string& keystroke) {
  Command command = FindCommandByName(extension_id, command_name);

  // The extension command might be assigned another shortcut. Remove that
  // shortcut before proceeding.
  RemoveKeybindingPrefs(extension_id, command_name);

  ui::Accelerator accelerator =
      Command::StringToAccelerator(keystroke, command_name);
  AddKeybindingPref(accelerator, extension_id, command_name,
                    true, command.global());
}

bool CommandService::SetScope(const ExtensionId& extension_id,
                              const std::string& command_name,
                              bool global) {
  Command command = FindCommandByName(extension_id, command_name);
  if (global == command.global())
    return false;

  // Pre-existing shortcuts must be removed before proceeding because the
  // handlers for global and non-global extensions are not one and the same.
  RemoveKeybindingPrefs(extension_id, command_name);
  AddKeybindingPref(command.accelerator(), extension_id,
                    command_name, true, global);
  return true;
}

Command CommandService::FindCommandByName(const ExtensionId& extension_id,
                                          const std::string& command) const {
  const base::Value::Dict& bindings =
      profile_->GetPrefs()->GetDict(prefs::kExtensionCommands);
  for (const auto it : bindings) {
    const ExtensionId* extension = it.second.GetDict().FindString(kExtension);
    if (!extension || *extension != extension_id)
      continue;
    const std::string* command_name =
        it.second.GetDict().FindString(kCommandName);
    if (!command_name || *command_name != command)
      continue;
    // Format stored in Preferences is: "Platform:Shortcut[:ExtensionId]".
    std::string shortcut = it.first;
    if (!IsForCurrentPlatform(shortcut))
      continue;
    std::optional<bool> global = it.second.GetDict().FindBool(kGlobal);

    std::vector<std::string_view> tokens = base::SplitStringPiece(
        shortcut, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
    CHECK(tokens.size() >= 2);

    return Command(*command_name, std::u16string(), std::string(tokens[1]),
                   global.value_or(false));
  }

  return Command();
}

void CommandService::AddObserver(Observer* observer) {
  observers_.AddObserver(observer);
}

void CommandService::RemoveObserver(Observer* observer) {
  observers_.RemoveObserver(observer);
}

const Extension* CommandService::GetExtensionInEnabledOrDisabledExtensions(
    const ExtensionId& extension_id) const {
  const ExtensionSet& enabled_extensions =
      ExtensionRegistry::Get(profile_)->enabled_extensions();
  const Extension* enabled_extension = enabled_extensions.GetByID(extension_id);
  if (enabled_extension) {
    return enabled_extension;
  }
  const ExtensionSet& disabled_extensions =
      ExtensionRegistry::Get(profile_)->disabled_extensions();
  return disabled_extensions.GetByID(extension_id);
}

bool CommandService::IsUpgradeFromMV2ToMV3(
    const Extension* extension,
    const std::string& existing_command_name) const {
  bool browser_or_page_action_command_in_bindings =
      existing_command_name == manifest_values::kBrowserActionCommandEvent ||
      existing_command_name == manifest_values::kPageActionCommandEvent;
  return browser_or_page_action_command_in_bindings &&
         CommandsInfo::GetActionCommand(extension);
}

void CommandService::UpdateKeybindings(const Extension* extension) {
  if (GetExtensionInEnabledOrDisabledExtensions(extension->id())) {
    RemoveRelinquishedKeybindings(extension);
  }
  AssignKeybindings(extension);
  UpdateExtensionSuggestedCommandPrefs(extension);
  RemoveDefunctExtensionSuggestedCommandPrefs(extension);
}

void CommandService::RemoveRelinquishedKeybindings(const Extension* extension) {
  // Remove keybindings if they have been removed by the extension and the user
  // has not modified them.
  ui::CommandMap existing_command_map;
  if (GetNamedCommands(extension->id(), CommandService::ACTIVE_OR_USER_MODIFIED,
                       CommandService::REGULAR, &existing_command_map)) {
    const ui::CommandMap* new_command_map =
        CommandsInfo::GetNamedCommands(extension);
    for (ui::CommandMap::const_iterator it = existing_command_map.begin();
         it != existing_command_map.end(); ++it) {
      std::string command_name = it->first;
      if (new_command_map->find(command_name) == new_command_map->end() &&
          !IsCommandShortcutUserModified(extension, command_name)) {
        RemoveKeybindingPrefs(extension->id(), command_name);
      }
    }
  }

  auto remove_overrides_if_unused = [this, extension](ActionInfo::Type type) {
    Command existing_command;
    if (!GetExtensionActionCommand(extension->id(), type,
                                   CommandService::ACTIVE_OR_USER_MODIFIED,
                                   &existing_command, nullptr)) {
      // No keybindings to remove.
      return;
    }

    const std::string& existing_command_name = existing_command.command_name();
    bool is_shortcut_user_modified =
        IsCommandShortcutUserModified(extension, existing_command_name);
    bool is_upgrade_from_mv2_to_mv3 =
        IsUpgradeFromMV2ToMV3(extension, existing_command_name);
    if (is_shortcut_user_modified && is_upgrade_from_mv2_to_mv3) {
      // TODO(jlulejian): Could this be an out param to IsUpgradeFromMV2ToMV3?
      const Command* action_command = CommandsInfo::GetActionCommand(extension);
      AddKeybindingPref(existing_command.accelerator(), extension->id(),
                        action_command->command_name(), true,
                        action_command->global());
    } else if (is_shortcut_user_modified) {
      // Don't relinquish user-modified shortcuts otherwise.
      return;
    }

    const Command* new_command = nullptr;
    switch (type) {
      case ActionInfo::Type::kAction:
        new_command = CommandsInfo::GetActionCommand(extension);
        break;
      case ActionInfo::Type::kBrowser:
        new_command = CommandsInfo::GetBrowserActionCommand(extension);
        break;
      case ActionInfo::Type::kPage:
        new_command = CommandsInfo::GetPageActionCommand(extension);
        break;
    }

    // The shortcuts should be removed if there is no command specified in the
    // new extension, or the only command specified is synthesized (i.e.,
    // assigned to ui::VKEY_UNKNOWN), which happens for browser action commands.
    // See CommandsHandler::MaybeSetActionDefault().
    // TODO(devlin): Should this logic apply to ActionInfo::Type::kAction?
    // See https://crbug.com/893373.
    const bool should_relinquish =
        !new_command ||
        (type == ActionInfo::Type::kBrowser &&
         new_command->accelerator().key_code() == ui::VKEY_UNKNOWN);

    if (!should_relinquish)
      return;

    RemoveKeybindingPrefs(extension->id(), existing_command_name);
  };

  // TODO(crbug.com/40124879): Extensions shouldn't be able to specify
  // commands for actions they don't have, so we should just be able to query
  // for a single action type.
  for (ActionInfo::Type type :
       {ActionInfo::Type::kAction, ActionInfo::Type::kBrowser,
        ActionInfo::Type::kPage}) {
    remove_overrides_if_unused(type);
  }
}

void CommandService::AssignKeybindings(const Extension* extension) {
  const ui::CommandMap* commands = CommandsInfo::GetNamedCommands(extension);
  if (!commands)
    return;

  for (const auto& named_command : *commands) {
    const ui::Command command = named_command.second;
    if (CanAutoAssign(command, extension)) {
      AddKeybindingPref(command.accelerator(),
                        extension->id(),
                        command.command_name(),
                        false,  // Overwriting not allowed.
                        command.global());
    }
  }

  const Command* browser_action_command =
      CommandsInfo::GetBrowserActionCommand(extension);
  if (browser_action_command &&
      CanAutoAssign(*browser_action_command, extension)) {
    AddKeybindingPref(browser_action_command->accelerator(),
                      extension->id(),
                      browser_action_command->command_name(),
                      false,   // Overwriting not allowed.
                      false);  // Not global.
  }

  const Command* page_action_command =
      CommandsInfo::GetPageActionCommand(extension);
  if (page_action_command && CanAutoAssign(*page_action_command, extension)) {
    AddKeybindingPref(page_action_command->accelerator(),
                      extension->id(),
                      page_action_command->command_name(),
                      false,   // Overwriting not allowed.
                      false);  // Not global.
  }

  const Command* action_command = CommandsInfo::GetActionCommand(extension);
  if (action_command && CanAutoAssign(*action_command, extension)) {
    AddKeybindingPref(action_command->accelerator(), extension->id(),
                      action_command->command_name(),
                      false,   // Overwriting not allowed.
                      false);  // Not global.
  }
}

bool CommandService::CanAutoAssign(const ui::Command& command,
                                   const Extension* extension) {
  // Extensions are allowed to auto-assign updated keys if the user has not
  // changed from the previous value.
  if (IsCommandShortcutUserModified(extension, command.command_name()))
    return false;

  // Media Keys are non-exclusive, so allow auto-assigning them.
  if (command.accelerator().IsMediaKey()) {
    return true;
  }

  if (command.global()) {
    if (Command::IsActionRelatedCommand(command.command_name()))
      return false;  // Browser and page actions are not global in nature.

    if (extension->permissions_data()->HasAPIPermission(
            mojom::APIPermissionID::kCommandsAccessibility))
      return true;

    // Global shortcuts are restricted to (Ctrl|Command)+Shift+[0-9].
#if BUILDFLAG(IS_MAC)
    if (!command.accelerator().IsCmdDown())
      return false;
#else
    if (!command.accelerator().IsCtrlDown())
      return false;
#endif
    if (!command.accelerator().IsShiftDown())
      return false;
    return (command.accelerator().key_code() >= ui::VKEY_0 &&
            command.accelerator().key_code() <= ui::VKEY_9);
  }

  // Not a global command, check if the command is a Chrome shortcut.
  return !chrome::IsChromeAccelerator(command.accelerator());
}

void CommandService::UpdateExtensionSuggestedCommandPrefs(
    const Extension* extension) {
  base::Value::Dict suggested_key_prefs;

  const ui::CommandMap* commands = CommandsInfo::GetNamedCommands(extension);
  if (commands) {
    for (const auto& named_command : *commands) {
      const ui::Command command = named_command.second;
      base::Value::Dict command_keys;
      command_keys.Set(kSuggestedKey,
                       Command::AcceleratorToString(command.accelerator()));
      suggested_key_prefs.Set(command.command_name(), std::move(command_keys));
    }
  }

  const Command* browser_action_command =
      CommandsInfo::GetBrowserActionCommand(extension);
  // The browser action command may be defaulted to an unassigned accelerator if
  // a browser action is specified by the extension but a keybinding is not
  // declared. See CommandsHandler::MaybeSetActionDefault.
  if (browser_action_command &&
      browser_action_command->accelerator().key_code() != ui::VKEY_UNKNOWN) {
    base::Value::Dict command_keys;
    command_keys.Set(kSuggestedKey, Command::AcceleratorToString(
                                        browser_action_command->accelerator()));
    suggested_key_prefs.Set(browser_action_command->command_name(),
                            std::move(command_keys));
  }

  const Command* action_command = CommandsInfo::GetActionCommand(extension);
  if (action_command &&
      action_command->accelerator().key_code() != ui::VKEY_UNKNOWN) {
    base::Value::Dict command_keys;
    command_keys.Set(kSuggestedKey, Command::AcceleratorToString(
                                        action_command->accelerator()));
    suggested_key_prefs.Set(action_command->command_name(),
                            std::move(command_keys));
  }

  const Command* page_action_command =
      CommandsInfo::GetPageActionCommand(extension);
  if (page_action_command) {
    base::Value::Dict command_keys;
    command_keys.Set(kSuggestedKey, Command::AcceleratorToString(
                                        page_action_command->accelerator()));
    suggested_key_prefs.Set(page_action_command->command_name(),
                            std::move(command_keys));
  }

  // Merge into current prefs, if present.
  MergeSuggestedKeyPrefs(extension->id(), ExtensionPrefs::Get(profile_),
                         std::move(suggested_key_prefs));
}

void CommandService::RemoveDefunctExtensionSuggestedCommandPrefs(
    const Extension* extension) {
  ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile_);
  const base::Value::Dict* current_prefs =
      extension_prefs->ReadPrefAsDict(extension->id(), kCommands);

  if (current_prefs) {
    base::Value::Dict suggested_key_prefs = current_prefs->Clone();

    const ui::CommandMap* named_commands =
        CommandsInfo::GetNamedCommands(extension);

    const Command* browser_action_command =
        CommandsInfo::GetBrowserActionCommand(extension);
    for (const auto [key, _] : *current_prefs) {
      if (key == manifest_values::kBrowserActionCommandEvent) {
        // The browser action command may be defaulted to an unassigned
        // accelerator if a browser action is specified by the extension but a
        // keybinding is not declared. See
        // CommandsHandler::MaybeSetActionDefault.
        if (!browser_action_command ||
            browser_action_command->accelerator().key_code() ==
                ui::VKEY_UNKNOWN) {
          suggested_key_prefs.Remove(key);
        }
      } else if (key == manifest_values::kPageActionCommandEvent) {
        if (!CommandsInfo::GetPageActionCommand(extension))
          suggested_key_prefs.Remove(key);
      } else if (key == manifest_values::kActionCommandEvent) {
        if (!CommandsInfo::GetActionCommand(extension))
          suggested_key_prefs.Remove(key);
      } else if (named_commands) {
        if (named_commands->find(key) == named_commands->end())
          suggested_key_prefs.Remove(key);
      }
    }

    extension_prefs->UpdateExtensionPref(
        extension->id(), kCommands,
        base::Value(std::move(suggested_key_prefs)));
  }
}

bool CommandService::IsCommandShortcutUserModified(
    const Extension* extension,
    const std::string& command_name) const {
  // Get the previous suggested key, if any.
  ui::Accelerator suggested_key;
  std::optional<bool> suggested_key_was_assigned;
  ExtensionPrefs* extension_prefs = ExtensionPrefs::Get(profile_);
  const base::Value::Dict* commands_prefs =
      extension_prefs->ReadPrefAsDict(extension->id(), kCommands);
  if (commands_prefs) {
    const base::Value::Dict* suggested_key_prefs =
        commands_prefs->FindDict(command_name);
    if (suggested_key_prefs) {
      const std::string* suggested_key_string =
          suggested_key_prefs->FindString(kSuggestedKey);
      if (suggested_key_string) {
        suggested_key =
            Command::StringToAccelerator(*suggested_key_string, command_name);
      }
      suggested_key_was_assigned =
          suggested_key_prefs->FindBool(kSuggestedKeyWasAssigned);
    }
  }

  // Get the active shortcut from the prefs, if any.
  Command active_command = FindCommandByName(extension->id(), command_name);

  return suggested_key_was_assigned.value_or(false)
             ? active_command.accelerator() != suggested_key
             : active_command.accelerator().key_code() != ui::VKEY_UNKNOWN;
}

void CommandService::RemoveKeybindingPrefs(const ExtensionId& extension_id,
                                           const std::string& command_name) {
  ScopedDictPrefUpdate updater(profile_->GetPrefs(), prefs::kExtensionCommands);
  base::Value::Dict& bindings = updater.Get();

  typedef std::vector<std::string> KeysToRemove;
  KeysToRemove keys_to_remove;
  std::vector<Command> removed_commands;
  for (const auto it : bindings) {
    // Removal of keybinding preference should be limited to current platform.
    if (!IsForCurrentPlatform(it.first))
      continue;

    const base::Value::Dict& dict = it.second.GetDict();
    const ExtensionId* extension = dict.FindString(kExtension);

    if (extension && *extension == extension_id) {
      // If |command_name| is specified, delete only that command. Otherwise,
      // delete all commands.
      const std::string* command = dict.FindString(kCommandName);
      if (command && !command_name.empty() && command_name != *command)
        continue;

      removed_commands.push_back(FindCommandByName(extension_id, *command));
      keys_to_remove.push_back(it.first);
    }
  }

  for (KeysToRemove::const_iterator it = keys_to_remove.begin();
       it != keys_to_remove.end(); ++it) {
    std::string key = *it;
    bindings.Remove(key);
  }

  // When a keybinding is removed, we also clear the "was_assigned" bit in the
  // extension prefs.
  ClearSuggestedKeyWasAssignedPrefs(
      extension_id, *ExtensionPrefs::Get(profile_), removed_commands);

  for (const Command& removed_command : removed_commands) {
    for (auto& observer : observers_)
      observer.OnExtensionCommandRemoved(extension_id, removed_command);
  }
}

bool CommandService::GetExtensionActionCommand(const ExtensionId& extension_id,
                                               ActionInfo::Type action_type,
                                               QueryType query_type,
                                               Command* command,
                                               bool* active) const {
  const Extension* extension =
      GetExtensionInEnabledOrDisabledExtensions(extension_id);
  if (!extension) {
    return false;
  }

  if (active)
    *active = false;

  const Command* requested_command = nullptr;
  switch (action_type) {
    case ActionInfo::Type::kBrowser:
      requested_command = CommandsInfo::GetBrowserActionCommand(extension);
      break;
    case ActionInfo::Type::kPage:
      requested_command = CommandsInfo::GetPageActionCommand(extension);
      break;
    case ActionInfo::Type::kAction:
      requested_command = CommandsInfo::GetActionCommand(extension);
      break;
  }
  if (!requested_command)
    return false;

  // Look up to see if the user has overridden how the command should work.
  Command saved_command =
      FindCommandByName(extension_id, requested_command->command_name());
  ui::Accelerator shortcut_assigned = saved_command.accelerator();

  bool is_active = shortcut_assigned.key_code() != ui::VKEY_UNKNOWN;
  if (active)
    *active = is_active;

  bool user_modified = IsCommandShortcutUserModified(
      extension, requested_command->command_name());
  if (!IsCommandRelevant(query_type, is_active, user_modified)) {
    return false;
  }

  *command = *requested_command;
  if (is_active || user_modified) {
    command->set_accelerator(shortcut_assigned);
  }

  return true;
}

template <>
void BrowserContextKeyedAPIFactory<
    CommandService>::DeclareFactoryDependencies() {
  DependsOn(ExtensionCommandsGlobalRegistry::GetFactoryInstance());
}

}  // namespace extensions