extension_prefs.cc | Explore in Territory

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

#include "extensions/browser/extension_prefs.h"

#include <stddef.h>
#include <stdint.h>

#include <iterator>
#include <string_view>
#include <utility>
#include <vector>

#include "base/check_op.h"
#include "base/containers/contains.h"
#include "base/json/values_util.h"
#include "base/observer_list.h"
#include "base/ranges/algorithm.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/time/clock.h"
#include "base/time/default_clock.h"
#include "base/trace_event/trace_event.h"
#include "build/build_config.h"
#include "components/content_settings/core/common/content_settings.h"
#include "components/crx_file/id_util.h"
#include "components/pref_registry/pref_registry_syncable.h"
#include "components/prefs/pref_service.h"
#include "components/supervised_user/core/common/buildflags.h"
#include "components/supervised_user/core/common/pref_names.h"
#include "extensions/browser/api/declarative_net_request/utils.h"
#include "extensions/browser/app_sorting.h"
#include "extensions/browser/blocklist_extension_prefs.h"
#include "extensions/browser/blocklist_state.h"
#include "extensions/browser/disable_reason.h"
#include "extensions/browser/event_router.h"
#include "extensions/browser/extension_pref_store.h"
#include "extensions/browser/extension_prefs_factory.h"
#include "extensions/browser/extension_prefs_observer.h"
#include "extensions/browser/extension_system.h"
#include "extensions/browser/extension_util.h"
#include "extensions/browser/install_flag.h"
#include "extensions/browser/pref_names.h"
#include "extensions/common/api/types.h"
#include "extensions/common/constants.h"
#include "extensions/common/extension.h"
#include "extensions/common/extension_features.h"
#include "extensions/common/extension_id.h"
#include "extensions/common/manifest.h"
#include "extensions/common/manifest_handlers/app_display_info.h"
#include "extensions/common/mojom/manifest.mojom-shared.h"
#include "extensions/common/permissions/permission_set.h"
#include "extensions/common/permissions/permissions_info.h"
#include "extensions/common/url_pattern.h"
#include "extensions/common/user_script.h"

ManifestLocation;

namespace extensions {

namespace {

// Additional preferences keys, which are not needed by external clients.

// True if this extension is running. Note this preference stops getting updated
// during Chrome shutdown (and won't be updated on a browser crash) and so can
// be used at startup to determine whether the extension was running when Chrome
// was last terminated.
constexpr const char kPrefRunning[] = …;

// Whether this extension had windows when it was last running.
constexpr const char kIsActive[] = …;

// Where an extension was installed from. (see mojom::ManifestLocation)
constexpr const char kPrefLocation[] = …;

// Enabled, disabled, killed, etc. (see Extension::State)
constexpr const char kPrefState[] = …;

// The path to the current version's manifest file.
constexpr const char kPrefPath[] = …;

// The dictionary containing the extension's manifest.
constexpr const char kPrefManifest[] = …;

// The version number.
constexpr const char kPrefManifestVersion[] = …;

// The count of how many times we prompted the user to acknowledge an
// extension.
constexpr const char kPrefAcknowledgePromptCount[] = …;

// Indicates whether the user has acknowledged various types of extensions.
constexpr const char kPrefExternalAcknowledged[] = …;

// Indicates whether the external extension was installed during the first
// run of this profile.
constexpr const char kPrefExternalInstallFirstRun[] = …;

// A bitmask of all the reasons an extension is disabled.
constexpr const char kPrefDisableReasons[] = …;

// The key for a serialized Time value indicating the start of the day (from the
// server's perspective) an extension last included a "ping" parameter during
// its update check.
constexpr const char kLastPingDay[] = …;

// Similar to kLastPingDay, but for "active" instead of "rollcall" pings.
constexpr const char kLastActivePingDay[] = …;

// A bit we use to keep track of whether we need to do an "active" ping.
constexpr const char kActiveBit[] = …;

// Path for settings specific to blocklist update.
constexpr const char kExtensionsBlocklistUpdate[] = …;

// Path for the delayed install info dictionary preference. The actual string
// value is a legacy artifact for when delayed installs only pertained to
// updates that were waiting for idle.
constexpr const char kDelayedInstallInfo[] = …;

// Path for pref keys marked for deletion in extension prefs while populating
// the delayed install info. These keys are deleted from extension prefs when
// the prefs inside delayed install info are applied to the extension.
constexpr const char kDelayedInstallInfoDeletedPrefKeys[] = …;

// Reason why the extension's install was delayed.
constexpr const char kDelayedInstallReason[] = …;

// Path for the suggested page ordinal of a delayed extension install.
constexpr const char kPrefSuggestedPageOrdinal[] = …;

// A preference that, if true, will allow this extension to run in incognito
// mode.
constexpr const char kPrefIncognitoEnabled[] = …;

// A preference to control whether an extension is allowed to inject script in
// pages with file URLs.
constexpr const char kPrefAllowFileAccess[] = …;
// TODO(jstritar): As part of fixing http://crbug.com/91577, we revoked all
// extension file access by renaming the pref. We should eventually clean up
// the old flag and possibly go back to that name.
// constexpr const char kPrefAllowFileAccessOld[] = "allowFileAccess";

// The set of permissions the extension desires to have active. This may include
// more than the required permissions from the manifest if the extension has
// optional permissions.
constexpr const char kPrefDesiredActivePermissions[] = …;

// The set of permissions that the user has approved for the extension either at
// install time or through an optional permissions request. We track this in
// order to alert the user of permissions escalation.
// This also works with not-yet-recognized permissions (such as if an extension
// installed on stable channel uses a new permission that's only available in
// canary): the recorded granted permissions are determined from the recognized
// set of permissions, so when the new requested permission is later recognized
// (when it's available on stable), the requested set of permissions will
// differ from the stored granted set, and Chrome will notify the user of a
// permissions increase.
constexpr const char kPrefGrantedPermissions[] = …;

// Pref that was previously used to indicate if host permissions should be
// withheld. Due to the confusing name and the need to logically invert it when
// being used, we transitioned to use kPrefWithholdingPermissions
// instead.
const char kGrantExtensionAllHostPermissions[] = …;

// A preference indicating if requested host permissions are being withheld from
// the extension, requiring them to be granted through the permissions API or
// runtime host permissions.
const char kPrefWithholdingPermissions[] = …;

// The set of permissions that were granted at runtime, rather than at install
// time. This includes permissions granted through the permissions API and
// runtime host permissions.
constexpr const char kPrefRuntimeGrantedPermissions[] = …;

// The preference names for PermissionSet values.
constexpr const char kPrefAPIs[] = …;
constexpr const char kPrefManifestPermissions[] = …;
constexpr const char kPrefExplicitHosts[] = …;
constexpr const char kPrefScriptableHosts[] = …;

// A preference that indicates when an extension was first installed.
// This preference is created when an extension is installed and deleted when
// it is removed. It is NOT updated when the extension is updated.
constexpr const char kPrefFirstInstallTime[] = …;
// A preference that indicates when an extension was last installed/updated.
constexpr const char kPrefLastUpdateTime[] = …;
// A preference that indicates when an extension was installed/updated.
// TODO(anunoy): DEPRECATED! Remove after M113.
// Use kPrefLastUpdateTime instead.
constexpr const char kPrefDeprecatedInstallTime[] = …;

// A preference which saves the creation flags for extensions.
constexpr const char kPrefCreationFlags[] = …;

// A preference that indicates whether the extension was installed from the
// Chrome Web Store.
constexpr const char kPrefFromWebStore[] = …;

// A preference that indicates whether the extension was installed as a
// default app.
constexpr const char kPrefWasInstalledByDefault[] = …;

// A preference that indicates whether the extension was installed as an
// OEM app.
constexpr const char kPrefWasInstalledByOem[] = …;

// Key for Geometry Cache preference.
constexpr const char kPrefGeometryCache[] = …;

// A preference that indicates when an extension is last launched.
constexpr const char kPrefLastLaunchTime[] = …;

// An installation parameter bundled with an extension.
constexpr const char kPrefInstallParam[] = …;

// A list of installed ids and a signature.
constexpr const char kInstallSignature[] = …;

// A list of IDs of external extensions that the user has chosen to uninstall;
// saved as an indication to not re-install that extension.
constexpr const char kExternalUninstalls[] = …;

// A boolean preference that indicates whether the extension should not be
// synced. Default value is false.
constexpr const char kPrefDoNotSync[] = …;

// A boolean preference that indicates whether the extension has local changes
// that need to be synced. Default value is false.
constexpr const char kPrefNeedsSync[] = …;

// Key corresponding to the list of enabled static ruleset IDs for an extension.
// Used for the Declarative Net Request API.
constexpr const char kDNREnabledStaticRulesetIDs[] = …;

// The default value to use for permission withholding when setting the pref on
// installation or for extensions where the pref has not been set.
constexpr bool kDefaultWithholdingBehavior = …;

// Checks whether the value passed in is consistent with the expected PrefType.
bool CheckPrefType(PrefType pref_type, const base::Value* value) { … }

// Serializes |time| as a string value mapped to |key| in |dictionary|.
void SaveTime(prefs::DictionaryValueUpdate* dictionary,
              const char* key,
              const base::Time& time) { … }

// The opposite of SaveTime. If |key| is not found, this returns an empty Time
// (is_null() will return true).
base::Time ReadTime(const base::Value::Dict* dictionary, const char* key) { … }

// Provider of write access to a dictionary storing extension prefs.
class ScopedExtensionPrefUpdate : public prefs::ScopedDictionaryPrefUpdate { … };

// Whether SetAlertSystemFirstRun() should always return true, so that alerts
// are triggered, even in first run.
bool g_run_alerts_in_first_run_for_testing = …;

}  // namespace

//
// ScopedDictionaryUpdate
//
ExtensionPrefs::ScopedDictionaryUpdate::ScopedDictionaryUpdate(
    ExtensionPrefs* prefs,
    const ExtensionId& extension_id,
    const std::string& key)
    : … { … }

ExtensionPrefs::ScopedDictionaryUpdate::~ScopedDictionaryUpdate() = default;

std::unique_ptr<prefs::DictionaryValueUpdate>
ExtensionPrefs::ScopedDictionaryUpdate::Get() { … }

std::unique_ptr<prefs::DictionaryValueUpdate>
ExtensionPrefs::ScopedDictionaryUpdate::Create() { … }

ExtensionPrefs::ScopedListUpdate::ScopedListUpdate(
    ExtensionPrefs* prefs,
    const ExtensionId& extension_id,
    const std::string& key)
    : … { … }

ExtensionPrefs::ScopedListUpdate::~ScopedListUpdate() = default;

base::Value::List* ExtensionPrefs::ScopedListUpdate::Get() { … }

base::Value::List* ExtensionPrefs::ScopedListUpdate::Ensure() { … }

//
// ExtensionPrefs
//

// static
std::unique_ptr<ExtensionPrefs> ExtensionPrefs::Create(
    content::BrowserContext* browser_context,
    PrefService* prefs,
    const base::FilePath& root_dir,
    ExtensionPrefValueMap* extension_pref_value_map,
    bool extensions_disabled,
    const std::vector<EarlyExtensionPrefsObserver*>& early_observers) { … }

// static
std::unique_ptr<ExtensionPrefs> ExtensionPrefs::Create(
    content::BrowserContext* browser_context,
    PrefService* pref_service,
    const base::FilePath& root_dir,
    ExtensionPrefValueMap* extension_pref_value_map,
    bool extensions_disabled,
    const std::vector<EarlyExtensionPrefsObserver*>& early_observers,
    base::Clock* clock) { … }

ExtensionPrefs::~ExtensionPrefs() { … }

// static
ExtensionPrefs* ExtensionPrefs::Get(content::BrowserContext* context) { … }

static std::string MakePathRelative(const base::FilePath& parent,
                                    const base::FilePath& child) { … }

void ExtensionPrefs::MakePathsRelative() { … }

const base::Value::Dict* ExtensionPrefs::GetExtensionPref(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetIntegerPref(const ExtensionId& id,
                                    const PrefMap& pref,
                                    int value) { … }

void ExtensionPrefs::SetBooleanPref(const ExtensionId& id,
                                    const PrefMap& pref,
                                    bool value) { … }

void ExtensionPrefs::SetStringPref(const ExtensionId& id,
                                   const PrefMap& pref,
                                   std::string value) { … }

void ExtensionPrefs::SetListPref(const ExtensionId& id,
                                 const PrefMap& pref,
                                 base::Value::List value) { … }

void ExtensionPrefs::SetDictionaryPref(const ExtensionId& id,
                                       const PrefMap& pref,
                                       base::Value::Dict value) { … }

void ExtensionPrefs::SetTimePref(const ExtensionId& id,
                                 const PrefMap& pref,
                                 base::Time value) { … }

void ExtensionPrefs::UpdateExtensionPrefInternal(
    const ExtensionId& extension_id,
    const PrefMap& pref,
    base::Value data_value) { … }

void ExtensionPrefs::UpdateExtensionPref(
    const ExtensionId& extension_id,
    std::string_view key,
    std::optional<base::Value> data_value) { … }

void ExtensionPrefs::DeleteExtensionPrefs(const ExtensionId& extension_id) { … }

void ExtensionPrefs::DeleteExtensionPrefsIfPrefEmpty(
    const ExtensionId& extension_id) { … }

bool ExtensionPrefs::ReadPrefAsBoolean(const ExtensionId& extension_id,
                                       const PrefMap& pref,
                                       bool* out_value) const { … }

bool ExtensionPrefs::ReadPrefAsInteger(const ExtensionId& extension_id,
                                       const PrefMap& pref,
                                       int* out_value) const { … }

bool ExtensionPrefs::ReadPrefAsString(const ExtensionId& extension_id,
                                      const PrefMap& pref,
                                      std::string* out_value) const { … }

const base::Value::List* ExtensionPrefs::ReadPrefAsList(
    const ExtensionId& extension_id,
    const PrefMap& pref) const { … }

const base::Value::Dict* ExtensionPrefs::ReadPrefAsDictionary(
    const ExtensionId& extension_id,
    const PrefMap& pref) const { … }

base::Time ExtensionPrefs::ReadPrefAsTime(const ExtensionId& extension_id,
                                          const PrefMap& pref) const { … }

bool ExtensionPrefs::ReadPrefAsBoolean(const ExtensionId& extension_id,
                                       std::string_view pref_key,
                                       bool* out_value) const { … }

bool ExtensionPrefs::ReadPrefAsInteger(const ExtensionId& extension_id,
                                       std::string_view pref_key,
                                       int* out_value) const { … }

bool ExtensionPrefs::ReadPrefAsString(const ExtensionId& extension_id,
                                      std::string_view pref_key,
                                      std::string* out_value) const { … }

const base::Value::List* ExtensionPrefs::ReadPrefAsList(
    const ExtensionId& extension_id,
    std::string_view pref_key) const { … }

const base::Value* ExtensionPrefs::GetPrefAsValue(
    const ExtensionId& extension_id,
    std::string_view pref_key) const { … }

const base::Value::Dict* ExtensionPrefs::ReadPrefAsDict(
    const ExtensionId& extension_id,
    std::string_view pref_key) const { … }

bool ExtensionPrefs::HasPrefForExtension(
    const ExtensionId& extension_id) const { … }

bool ExtensionPrefs::ReadPrefAsURLPatternSet(const ExtensionId& extension_id,
                                             std::string_view pref_key,
                                             URLPatternSet* result,
                                             int valid_schemes) const { … }

void ExtensionPrefs::SetExtensionPrefURLPatternSet(
    const ExtensionId& extension_id,
    std::string_view pref_key,
    const URLPatternSet& set) { … }

bool ExtensionPrefs::ReadPrefAsBooleanAndReturn(
    const ExtensionId& extension_id,
    std::string_view pref_key) const { … }

std::unique_ptr<PermissionSet> ExtensionPrefs::ReadPrefAsPermissionSet(
    const ExtensionId& extension_id,
    std::string_view pref_key) const { … }

namespace {

// Set the API or Manifest permissions.
// The format of api_values is:
// [ "permission_name1",   // permissions do not support detail.
//   "permission_name2",
//   {"permission_name3": value },
//   // permission supports detail, permission detail will be stored in value.
//   ...
// ]
template <typename T>
base::Value CreatePermissionList(const T& permissions) { … }

}  // anonymous namespace

void ExtensionPrefs::SetExtensionPrefPermissionSet(
    const ExtensionId& extension_id,
    std::string_view pref_key,
    const PermissionSet& new_value) { … }

void ExtensionPrefs::AddToPrefPermissionSet(const ExtensionId& extension_id,
                                            const PermissionSet& permissions,
                                            const char* pref_name) { … }

void ExtensionPrefs::RemoveFromPrefPermissionSet(
    const ExtensionId& extension_id,
    const PermissionSet& permissions,
    const char* pref_name) { … }

int ExtensionPrefs::IncrementAcknowledgePromptCount(
    const ExtensionId& extension_id) { … }

bool ExtensionPrefs::IsExternalExtensionAcknowledged(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::AcknowledgeExternalExtension(
    const ExtensionId& extension_id) { … }

bool ExtensionPrefs::IsBlocklistedExtensionAcknowledged(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::AcknowledgeBlocklistedExtension(
    const ExtensionId& extension_id) { … }

bool ExtensionPrefs::IsExternalInstallFirstRun(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetExternalInstallFirstRun(
    const ExtensionId& extension_id) { … }

bool ExtensionPrefs::SetAlertSystemFirstRun() { … }

bool ExtensionPrefs::DidExtensionEscalatePermissions(
    const ExtensionId& extension_id) const { … }

int ExtensionPrefs::GetDisableReasons(const ExtensionId& extension_id) const { … }

int ExtensionPrefs::GetBitMapPrefBits(const ExtensionId& extension_id,
                                      std::string_view pref_key,
                                      int default_bit) const { … }

bool ExtensionPrefs::HasDisableReason(
    const ExtensionId& extension_id,
    disable_reason::DisableReason disable_reason) const { … }

void ExtensionPrefs::AddDisableReason(
    const ExtensionId& extension_id,
    disable_reason::DisableReason disable_reason) { … }

void ExtensionPrefs::AddDisableReasons(const ExtensionId& extension_id,
                                       int disable_reasons) { … }

void ExtensionPrefs::RemoveDisableReason(
    const ExtensionId& extension_id,
    disable_reason::DisableReason disable_reason) { … }

void ExtensionPrefs::ReplaceDisableReasons(const ExtensionId& extension_id,
                                           int disable_reasons) { … }

void ExtensionPrefs::ClearDisableReasons(const ExtensionId& extension_id) { … }

void ExtensionPrefs::ClearInapplicableDisableReasonsForComponentExtension(
    const ExtensionId& component_extension_id) { … }

void ExtensionPrefs::ModifyDisableReasons(const ExtensionId& extension_id,
                                          int reasons,
                                          BitMapPrefOperation operation) { … }

void ExtensionPrefs::ModifyBitMapPrefBits(const ExtensionId& extension_id,
                                          int pending_bits,
                                          BitMapPrefOperation operation,
                                          std::string_view pref_key,
                                          int default_bit) { … }

base::Time ExtensionPrefs::LastPingDay(const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetLastPingDay(const ExtensionId& extension_id,
                                    const base::Time& time) { … }

base::Time ExtensionPrefs::BlocklistLastPingDay() const { … }

void ExtensionPrefs::SetBlocklistLastPingDay(const base::Time& time) { … }

base::Time ExtensionPrefs::LastActivePingDay(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetLastActivePingDay(const ExtensionId& extension_id,
                                          const base::Time& time) { … }

bool ExtensionPrefs::GetActiveBit(const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetActiveBit(const ExtensionId& extension_id,
                                  bool active) { … }

std::unique_ptr<PermissionSet> ExtensionPrefs::GetGrantedPermissions(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::AddGrantedPermissions(const ExtensionId& extension_id,
                                           const PermissionSet& permissions) { … }

void ExtensionPrefs::RemoveGrantedPermissions(
    const ExtensionId& extension_id,
    const PermissionSet& permissions) { … }

std::unique_ptr<PermissionSet> ExtensionPrefs::GetDesiredActivePermissions(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetDesiredActivePermissions(
    const ExtensionId& extension_id,
    const PermissionSet& permissions) { … }

void ExtensionPrefs::AddDesiredActivePermissions(
    const ExtensionId& extension_id,
    const PermissionSet& permissions) { … }

void ExtensionPrefs::RemoveDesiredActivePermissions(
    const ExtensionId& extension_id,
    const PermissionSet& permissions) { … }

void ExtensionPrefs::SetWithholdingPermissions(const ExtensionId& extension_id,
                                               bool should_withhold) { … }

bool ExtensionPrefs::GetWithholdingPermissions(
    const ExtensionId& extension_id) const { … }

bool ExtensionPrefs::HasWithholdingPermissionsSetting(
    const ExtensionId& extension_id) const { … }

std::unique_ptr<PermissionSet> ExtensionPrefs::GetRuntimeGrantedPermissions(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::AddRuntimeGrantedPermissions(
    const ExtensionId& extension_id,
    const PermissionSet& permissions) { … }

void ExtensionPrefs::RemoveRuntimeGrantedPermissions(
    const ExtensionId& extension_id,
    const PermissionSet& permissions) { … }

void ExtensionPrefs::SetExtensionRunning(const ExtensionId& extension_id,
                                         bool is_running) { … }

bool ExtensionPrefs::IsExtensionRunning(const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetIsActive(const ExtensionId& extension_id,
                                 bool is_active) { … }

bool ExtensionPrefs::IsActive(const ExtensionId& extension_id) const { … }

bool ExtensionPrefs::IsIncognitoEnabled(const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetIsIncognitoEnabled(const ExtensionId& extension_id,
                                           bool enabled) { … }

bool ExtensionPrefs::AllowFileAccess(const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetAllowFileAccess(const ExtensionId& extension_id,
                                        bool allow) { … }

bool ExtensionPrefs::HasAllowFileAccessSetting(
    const ExtensionId& extension_id) const { … }

bool ExtensionPrefs::DoesExtensionHaveState(
    const ExtensionId& id,
    Extension::State check_state) const { … }

bool ExtensionPrefs::IsExternalExtensionUninstalled(
    const ExtensionId& id) const { … }

bool ExtensionPrefs::ClearExternalExtensionUninstalled(const ExtensionId& id) { … }

bool ExtensionPrefs::IsExtensionDisabled(const ExtensionId& id) const { … }

ExtensionIdList ExtensionPrefs::GetPinnedExtensions() const { … }

void ExtensionPrefs::SetPinnedExtensions(const ExtensionIdList& extension_ids) { … }

void ExtensionPrefs::OnExtensionInstalled(
    const Extension* extension,
    Extension::State initial_state,
    const syncer::StringOrdinal& page_ordinal,
    int install_flags,
    const std::string& install_parameter,
    base::Value::Dict ruleset_install_prefs) { … }

void ExtensionPrefs::OnExtensionUninstalled(const ExtensionId& extension_id,
                                            const ManifestLocation location,
                                            bool external_uninstall) { … }

void ExtensionPrefs::SetExtensionEnabled(const ExtensionId& extension_id) { … }

void ExtensionPrefs::SetExtensionDisabled(const ExtensionId& extension_id,
                                          int disable_reasons) { … }

std::string ExtensionPrefs::GetVersionString(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::UpdateManifest(const Extension* extension) { … }

void ExtensionPrefs::SetInstallLocation(const ExtensionId& extension_id,
                                        ManifestLocation location) { … }

std::optional<ExtensionInfo> ExtensionPrefs::GetInstalledInfoHelper(
    const ExtensionId& extension_id,
    const base::Value::Dict& extension,
    bool include_component_extensions) const { … }

std::optional<ExtensionInfo> ExtensionPrefs::GetInstalledExtensionInfo(
    const ExtensionId& extension_id,
    bool include_component_extensions) const { … }

ExtensionPrefs::ExtensionsInfo ExtensionPrefs::GetInstalledExtensionsInfo(
    bool include_component_extensions) const { … }

void ExtensionPrefs::SetDelayedInstallInfo(
    const Extension* extension,
    Extension::State initial_state,
    int install_flags,
    DelayReason delay_reason,
    const syncer::StringOrdinal& page_ordinal,
    const std::string& install_parameter,
    base::Value::Dict ruleset_install_prefs) { … }

bool ExtensionPrefs::RemoveDelayedInstallInfo(const ExtensionId& extension_id) { … }

bool ExtensionPrefs::FinishDelayedInstallInfo(const ExtensionId& extension_id) { … }

std::optional<ExtensionInfo> ExtensionPrefs::GetDelayedInstallInfo(
    const ExtensionId& extension_id) const { … }

ExtensionPrefs::DelayReason ExtensionPrefs::GetDelayedInstallReason(
    const ExtensionId& extension_id) const { … }

ExtensionPrefs::ExtensionsInfo ExtensionPrefs::GetAllDelayedInstallInfo()
    const { … }

bool ExtensionPrefs::IsFromWebStore(const ExtensionId& extension_id) const { … }

int ExtensionPrefs::GetCreationFlags(const ExtensionId& extension_id) const { … }

int ExtensionPrefs::GetDelayedInstallCreationFlags(
    const ExtensionId& extension_id) const { … }

bool ExtensionPrefs::WasInstalledByDefault(
    const ExtensionId& extension_id) const { … }

bool ExtensionPrefs::WasInstalledByOem(const ExtensionId& extension_id) const { … }

base::Time ExtensionPrefs::GetFirstInstallTime(
    const ExtensionId& extension_id) const { … }

base::Time ExtensionPrefs::GetLastUpdateTime(
    const ExtensionId& extension_id) const { … }

bool ExtensionPrefs::DoNotSync(const ExtensionId& extension_id) const { … }

base::Time ExtensionPrefs::GetLastLaunchTime(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetLastLaunchTime(const ExtensionId& extension_id,
                                       const base::Time& time) { … }

void ExtensionPrefs::ClearLastLaunchTimes() { … }

void ExtensionPrefs::SetIntegerPref(const PrefMap& pref, int value) { … }

void ExtensionPrefs::SetBooleanPref(const PrefMap& pref, bool value) { … }

void ExtensionPrefs::SetStringPref(const PrefMap& pref,
                                   const std::string& value) { … }

void ExtensionPrefs::SetTimePref(const PrefMap& pref, base::Time value) { … }

void ExtensionPrefs::SetGURLPref(const PrefMap& pref, const GURL& value) { … }

void ExtensionPrefs::SetDictionaryPref(const PrefMap& pref,
                                       base::Value::Dict value) { … }

int ExtensionPrefs::GetPrefAsInteger(const PrefMap& pref) const { … }

bool ExtensionPrefs::GetPrefAsBoolean(const PrefMap& pref) const { … }

std::string ExtensionPrefs::GetPrefAsString(const PrefMap& pref) const { … }

base::Time ExtensionPrefs::GetPrefAsTime(const PrefMap& pref) const { … }

GURL ExtensionPrefs::GetPrefAsGURL(const PrefMap& pref) const { … }

const base::Value::Dict& ExtensionPrefs::GetPrefAsDictionary(
    const PrefMap& pref) const { … }

std::unique_ptr<prefs::ScopedDictionaryPrefUpdate>
ExtensionPrefs::CreatePrefUpdate(const PrefMap& pref) { … }

void ExtensionPrefs::IncrementPref(const PrefMap& pref) { … }

void ExtensionPrefs::DecrementPref(const PrefMap& pref) { … }

ExtensionIdList ExtensionPrefs::GetExtensions() const { … }

void ExtensionPrefs::AddObserver(ExtensionPrefsObserver* observer) { … }

void ExtensionPrefs::RemoveObserver(ExtensionPrefsObserver* observer) { … }

void ExtensionPrefs::InitPrefStore() { … }

bool ExtensionPrefs::HasIncognitoPrefValue(const std::string& pref_key) const { … }

const base::Value::Dict* ExtensionPrefs::GetGeometryCache(
    const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetGeometryCache(const ExtensionId& extension_id,
                                      base::Value::Dict cache) { … }

const base::Value::Dict& ExtensionPrefs::GetInstallSignature() const { … }

void ExtensionPrefs::SetInstallSignature(base::Value::Dict* signature) { … }

bool ExtensionPrefs::NeedsSync(const ExtensionId& extension_id) const { … }

void ExtensionPrefs::SetNeedsSync(const ExtensionId& extension_id,
                                  bool needs_sync) { … }

// static
void ExtensionPrefs::SetRunAlertsInFirstRunForTest() { … }

const char ExtensionPrefs::kFakeObsoletePrefForTesting[] = …;

// Stores preferences corresponding to static indexed rulesets for the
// Declarative Net Request API.
//
// TODO([email protected]) Need to move all the DNR related codes to the helper.
//                       (DeclarativeNetRequestPrefsHelper)
const char ExtensionPrefs::kDNRStaticRulesetPref[] = …;

// static
std::string ExtensionPrefs::JoinPrefs(
    const std::vector<std::string_view>& parts) { … }

ExtensionPrefs::ExtensionPrefs(
    content::BrowserContext* browser_context,
    PrefService* prefs,
    const base::FilePath& root_dir,
    ExtensionPrefValueMap* extension_pref_value_map,
    base::Clock* clock,
    bool extensions_disabled,
    const std::vector<EarlyExtensionPrefsObserver*>& early_observers)
    : … { … }

AppSorting* ExtensionPrefs::app_sorting() const { … }

bool ExtensionPrefs::NeedsStorageGarbageCollection() const { … }

// static
void ExtensionPrefs::RegisterProfilePrefs(
    user_prefs::PrefRegistrySyncable* registry) { … }

template <class ExtensionIdContainer>
bool ExtensionPrefs::GetUserExtensionPrefIntoContainer(
    const char* pref,
    ExtensionIdContainer* id_container_out) const { … }

template <class ExtensionIdContainer>
void ExtensionPrefs::SetExtensionPrefFromContainer(
    const char* pref,
    const ExtensionIdContainer& strings) { … }

void ExtensionPrefs::PopulateExtensionInfoPrefs(
    const Extension* extension,
    const base::Time install_time,
    Extension::State initial_state,
    int install_flags,
    const std::string& install_parameter,
    base::Value::Dict ruleset_install_prefs,
    prefs::DictionaryValueUpdate* extension_dict,
    base::Value::List& removed_prefs) { … }

void ExtensionPrefs::InitExtensionControlledPrefs(
    const ExtensionsInfo& extensions_info) { … }

void ExtensionPrefs::LoadExtensionControlledPrefs(
    const ExtensionId& extension_id,
    ChromeSettingScope scope) { … }

void ExtensionPrefs::FinishExtensionInfoPrefs(
    const ExtensionId& extension_id,
    const base::Time install_time,
    bool needs_sort_ordinal,
    const syncer::StringOrdinal& suggested_page_ordinal,
    prefs::DictionaryValueUpdate* extension_dict) { … }

void ExtensionPrefs::BackfillAndMigrateInstallTimePrefs() { … }

void ExtensionPrefs::MigrateDeprecatedDisableReasons() { … }

void ExtensionPrefs::MigrateObsoleteExtensionPrefs() { … }

void ExtensionPrefs::MigrateToNewWithholdingPref() { … }

void ExtensionPrefs::MigrateToNewExternalUninstallPref() { … }

bool ExtensionPrefs::ShouldInstallObsoleteComponentExtension(
    const ExtensionId& extension_id) { … }

void ExtensionPrefs::MarkObsoleteComponentExtensionAsRemoved(
    const ExtensionId& extension_id,
    const ManifestLocation location) { … }

}  // namespace extensions
chromium/extensions/browser/extension_prefs.cc
