blob: fffdf33b2230e3462d60fd7132358efbf1513b89 [file] [log] [blame]
// 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.
#ifndef EXTENSIONS_BROWSER_EXTENSION_UTIL_H_
#define EXTENSIONS_BROWSER_EXTENSION_UTIL_H_
#include <string>
#include <vector>
#include "base/functional/callback.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "extensions/buildflags/buildflags.h"
#include "extensions/common/extension_id.h"
#include "extensions/common/manifest.h"
#include "url/gurl.h"
namespace base {
class FilePath;
} // namespace base
namespace gfx {
class ImageSkia;
} // namespace gfx
namespace content {
class BrowserContext;
class ServiceWorkerContext;
class SiteInstance;
class StoragePartition;
class StoragePartitionConfig;
class RenderFrameHost;
} // namespace content
namespace extensions {
class Extension;
class ExtensionSet;
namespace util {
// TODO(crbug.com/40893821): Move functions from
// chrome/browser/extensions/extension_util.h/cc that are only dependent on
// extensions/ here.
// Returns true if the extension can be enabled in incognito mode.
bool CanBeIncognitoEnabled(const Extension* extension);
// Returns true if `extension_id` can run in an incognito window.
bool IsIncognitoEnabled(const ExtensionId& extension_id,
content::BrowserContext* context);
// Returns true if `extension` can see events and data from another sub-profile
// (incognito to original profile, or vice versa).
bool CanCrossIncognito(const Extension* extension,
content::BrowserContext* context);
// Returns true if the extension associated with `extension_id` is idle and it
// is safe to perform actions such as updating.
bool IsExtensionIdle(const ExtensionId& extension_id,
content::BrowserContext* browser_context);
// Returns true if prompting for external extensions is enabled.
bool IsPromptingEnabled();
#if BUILDFLAG(IS_ANDROID)
// This is a workaround to ensure ExtensionSystem is initialized properly for
// incognito profile in split mode on Android.
// Since DesktopAndroidExtensionSystem does not use `shared_` instance (keyed
// service) to share the states and services between regular and incognito
// profiles, as a workaround, when an extension runs in split incognito
// mode, we need to call `InitForRegularProfile` to instantiated these objects
// (eg quota_service, etc) for incognito DesktopAndroidExtensionSystem
// instance. Otherwise, it will lead to crash when the objects are accessed.
// TODO(crbug.com/356905053): Remove this workaround when the proper
// extension runtime is implemented on Android.
void InitExtensionSystemForIncognitoSplit(content::BrowserContext* context);
#endif
// Returns true if this extension can inject scripts into pages with file URLs.
bool AllowFileAccess(const ExtensionId& extension_id,
content::BrowserContext* context);
// Returns the StoragePartition domain for `extension`.
// Note: The reference returned has the same lifetime as `extension`.
const std::string& GetPartitionDomainForExtension(const Extension* extension);
// Returns an extension specific StoragePartitionConfig if the extension
// associated with `extension_id` has isolated storage.
// Otherwise, return the default StoragePartitionConfig.
content::StoragePartitionConfig GetStoragePartitionConfigForExtensionId(
const ExtensionId& extension_id,
content::BrowserContext* browser_context);
content::StoragePartition* GetStoragePartitionForExtensionId(
const ExtensionId& extension_id,
content::BrowserContext* browser_context,
bool can_create = true);
// Returns the ServiceWorkerContext associated with the given `extension_id`.
content::ServiceWorkerContext* GetServiceWorkerContextForExtensionId(
const ExtensionId& extension_id,
content::BrowserContext* browser_context);
// Maps a `file_url` to a `file_path` on the local filesystem, including
// resources in extensions. Returns true on success. See NaClBrowserDelegate for
// full details. If `use_blocking_api` is false, only a subset of URLs will be
// handled. If `use_blocking_api` is true, blocking file operations may be used,
// and this must be called on threads that allow blocking. Otherwise this can be
// called on any thread.
bool MapUrlToLocalFilePath(const ExtensionSet* extensions,
const GURL& file_url,
bool use_blocking_api,
base::FilePath* file_path);
// Returns true if the browser can potentially withhold permissions from the
// extension.
bool CanWithholdPermissionsFromExtension(const Extension& extension);
bool CanWithholdPermissionsFromExtension(
const ExtensionId& extension_id,
const Manifest::Type type,
const mojom::ManifestLocation location);
// Returns a unique int id for each context. Prefer using
// `BrowserContext::UniqueId()` directly.
// TODO(crbug.com/40267637): Migrate callers to use the `context` unique id
// directly. For that we need to update all data keyed by integer context ids to
// be keyed by strings instead.
int GetBrowserContextId(content::BrowserContext* context);
// Returns whether the `extension` should be loaded in the given
// `browser_context`.
bool IsExtensionVisibleToContext(const Extension& extension,
content::BrowserContext* browser_context);
// Initializes file scheme access if the extension has such permission.
void InitializeFileSchemeAccessForExtension(
int render_process_id,
const ExtensionId& extension_id,
content::BrowserContext* browser_context);
// Returns the default extension/app icon (for extensions or apps that don't
// have one).
const gfx::ImageSkia& GetDefaultExtensionIcon();
const gfx::ImageSkia& GetDefaultAppIcon();
// Gets the ExtensionId associated with the given `site_instance`. An empty
// string is returned when `site_instance` is not associated with an extension.
ExtensionId GetExtensionIdForSiteInstance(content::SiteInstance& site_instance);
// Returns the extension id associated with the given `render_frame_host`, or
// the empty string if there is none.
std::string GetExtensionIdFromFrame(
content::RenderFrameHost* render_frame_host);
// Returns true if the process corresponding to `render_process_id` can host an
// extension with `extension_id`. (It doesn't necessarily mean that the process
// *does* host this specific extension at this point in time.) `is_sandboxed`
// specifies whether this is asking about a sandboxed extension document and is
// needed to accurately compute the expected extension origin for that case.
bool CanRendererHostExtensionOrigin(int render_process_id,
const ExtensionId& extension_id,
bool is_sandboxed);
// Returns `true` if `render_process_host` can legitimately claim to send IPC
// messages on behalf of `extension_id`. `render_frame_host` parameter is
// needed to account for scenarios involving a Chrome Web Store frame.
bool CanRendererActOnBehalfOfExtension(
const ExtensionId& extension_id,
content::RenderFrameHost* render_frame_host,
content::RenderProcessHost& render_process_host,
bool include_user_scripts);
// Returns true if the extension associated with `extension_id` is a Chrome App.
bool IsChromeApp(const ExtensionId& extension_id,
content::BrowserContext* context);
// Returns true if `extension_id` can be launched (possibly only after being
// enabled).
bool IsAppLaunchable(const ExtensionId& extension_id,
content::BrowserContext* context);
// Returns true if `extension_id` can be launched without being enabled first.
bool IsAppLaunchableWithoutEnabling(const ExtensionId& extension_id,
content::BrowserContext* context);
} // namespace util
} // namespace extensions
#endif // EXTENSIONS_BROWSER_EXTENSION_UTIL_H_