chromium/content/browser/renderer_host/render_process_host_impl.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.

// Represents the browser side of the browser <--> renderer communication
// channel. There will be one RenderProcessHost per renderer process.

#include "content/browser/renderer_host/render_process_host_impl.h"

#include <algorithm>
#include <atomic>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <set>
#include <utility>
#include <vector>

#include "base/base_switches.h"
#include "base/clang_profiling_buildflags.h"
#include "base/command_line.h"
#include "base/containers/adapters.h"
#include "base/containers/contains.h"
#include "base/containers/flat_map.h"
#include "base/containers/map_util.h"
#include "base/debug/alias.h"
#include "base/debug/crash_logging.h"
#include "base/debug/dump_without_crashing.h"
#include "base/feature_list.h"
#include "base/files/file.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/read_only_shared_memory_region.h"
#include "base/memory/structured_shared_memory.h"
#include "base/memory/unsafe_shared_memory_region.h"
#include "base/message_loop/message_pump_type.h"
#include "base/metrics/histogram_base.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/metrics/histogram_shared_memory.h"
#include "base/metrics/persistent_histogram_allocator.h"
#include "base/metrics/persistent_memory_allocator.h"
#include "base/metrics/statistics_recorder.h"
#include "base/metrics/user_metrics.h"
#include "base/no_destructor.h"
#include "base/not_fatal_until.h"
#include "base/numerics/safe_conversions.h"
#include "base/observer_list.h"
#include "base/process/process_handle.h"
#include "base/rand_util.h"
#include "base/ranges/algorithm.h"
#include "base/strings/string_number_conversions.h"
#include "base/supports_user_data.h"
#include "base/system/sys_info.h"
#include "base/task/single_thread_task_runner.h"
#include "base/task/thread_pool.h"
#include "base/threading/thread.h"
#include "base/threading/thread_restrictions.h"
#include "base/time/time.h"
#include "base/trace_event/memory_dump_manager.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "base/tracing/protos/chrome_track_event.pbzero.h"
#include "build/build_config.h"
#include "build/chromeos_buildflags.h"
#include "cc/base/switches.h"
#include "components/metrics/histogram_controller.h"
#include "components/metrics/single_sample_metrics.h"
#include "components/services/storage/privileged/mojom/indexed_db_control.mojom.h"
#include "components/services/storage/public/cpp/buckets/bucket_id.h"
#include "components/services/storage/public/cpp/buckets/bucket_info.h"
#include "components/services/storage/public/cpp/buckets/constants.h"
#include "components/services/storage/public/cpp/quota_error_or.h"
#include "components/services/storage/public/mojom/cache_storage_control.mojom.h"
#include "components/tracing/common/tracing_switches.h"
#include "components/viz/common/switches.h"
#include "components/viz/host/gpu_client.h"
#include "content/browser/bad_message.h"
#include "content/browser/blob_storage/blob_registry_wrapper.h"
#include "content/browser/blob_storage/file_backed_blob_factory_worker_impl.h"
#include "content/browser/browser_child_process_host_impl.h"
#include "content/browser/browser_context_impl.h"
#include "content/browser/browser_main_loop.h"
#include "content/browser/buckets/bucket_manager.h"
#include "content/browser/child_process_host_impl.h"
#include "content/browser/child_process_security_policy_impl.h"
#include "content/browser/code_cache/generated_code_cache_context.h"
#include "content/browser/compositor/surface_utils.h"
#include "content/browser/field_trial_recorder.h"
#include "content/browser/field_trial_synchronizer.h"
#include "content/browser/file_system/file_system_manager_impl.h"
#include "content/browser/file_system_access/file_system_access_manager_impl.h"
#include "content/browser/gpu/browser_gpu_client_delegate.h"
#include "content/browser/gpu/compositor_util.h"
#include "content/browser/gpu/gpu_data_manager_impl.h"
#include "content/browser/gpu/gpu_disk_cache_factory.h"
#include "content/browser/gpu/gpu_process_host.h"
#include "content/browser/locks/lock_manager.h"
#include "content/browser/media/frameless_media_interface_proxy.h"
#include "content/browser/media/media_internals.h"
#include "content/browser/metrics/histogram_shared_memory_config.h"
#include "content/browser/network_service_instance_impl.h"
#include "content/browser/notifications/platform_notification_context_impl.h"
#include "content/browser/payments/payment_app_context_impl.h"
#include "content/browser/permissions/permission_service_context.h"
#include "content/browser/process_lock.h"
#include "content/browser/push_messaging/push_messaging_manager.h"
#include "content/browser/quota/quota_context.h"
#include "content/browser/renderer_host/embedded_frame_sink_provider_impl.h"
#include "content/browser/renderer_host/indexed_db_client_state_checker_factory.h"
#include "content/browser/renderer_host/media/media_stream_track_metrics_host.h"
#include "content/browser/renderer_host/p2p/socket_dispatcher_host.h"
#include "content/browser/renderer_host/recently_destroyed_hosts.h"
#include "content/browser/renderer_host/render_frame_host_delegate.h"
#include "content/browser/renderer_host/render_frame_host_impl.h"
#include "content/browser/renderer_host/render_message_filter.h"
#include "content/browser/renderer_host/render_widget_helper.h"
#include "content/browser/renderer_host/renderer_sandboxed_process_launcher_delegate.h"
#include "content/browser/renderer_host/spare_render_process_host_manager.h"
#include "content/browser/service_worker/service_worker_context_wrapper.h"
#include "content/browser/site_info.h"
#include "content/browser/site_instance_impl.h"
#include "content/browser/theme_helper.h"
#include "content/browser/tracing/background_tracing_manager_impl.h"
#include "content/browser/websockets/websocket_connector_impl.h"
#include "content/browser/webui/web_ui_controller_factory_registry.h"
#include "content/common/child_process.mojom.h"
#include "content/common/content_constants_internal.h"
#include "content/common/content_switches_internal.h"
#include "content/common/in_process_child_thread_params.h"
#include "content/common/pseudonymization_salt.h"
#include "content/public/browser/browser_child_process_host.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/browser_or_resource_context.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/child_process_host.h"
#include "content/public/browser/devtools_agent_host.h"
#include "content/public/browser/global_routing_id.h"
#include "content/public/browser/isolated_context_util.h"
#include "content/public/browser/network_service_instance.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host_creation_observer.h"
#include "content/public/browser/render_process_host_factory.h"
#include "content/public/browser/render_process_host_observer.h"
#include "content/public/browser/render_process_host_priority_client.h"
#include "content/public/browser/render_widget_host.h"
#include "content/public/browser/render_widget_host_iterator.h"
#include "content/public/browser/resource_coordinator_service.h"
#include "content/public/browser/site_isolation_policy.h"
#include "content/public/browser/weak_document_ptr.h"
#include "content/public/browser/webrtc_log.h"
#include "content/public/common/content_client.h"
#include "content/public/common/content_features.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/process_type.h"
#include "content/public/common/result_codes.h"
#include "content/public/common/url_constants.h"
#include "content/public/common/zygote/zygote_buildflags.h"
#include "google_apis/gaia/gaia_config.h"
#include "google_apis/gaia/gaia_switches.h"
#include "gpu/command_buffer/client/gpu_switches.h"
#include "gpu/command_buffer/service/gpu_switches.h"
#include "gpu/config/gpu_switches.h"
#include "ipc/ipc_channel_mojo.h"
#include "ipc/ipc_channel_proxy.h"
#include "ipc/trace_ipc_message.h"
#include "media/base/media_switches.h"
#include "media/capture/capture_switches.h"
#include "media/media_buildflags.h"
#include "media/mojo/services/mojo_video_encoder_metrics_provider_service.h"
#include "media/mojo/services/video_decode_perf_history.h"
#include "media/mojo/services/webrtc_video_perf_history.h"
#include "media/webrtc/webrtc_features.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/scoped_message_error_crash_key.h"
#include "net/cookies/cookie_setting_override.h"
#include "sandbox/policy/switches.h"
#include "services/device/public/mojom/power_monitor.mojom.h"
#include "services/device/public/mojom/screen_orientation.mojom.h"
#include "services/device/public/mojom/time_zone_monitor.mojom.h"
#include "services/network/public/mojom/network_service.mojom.h"
#include "services/resource_coordinator/public/mojom/memory_instrumentation/memory_instrumentation.mojom.h"
#include "services/service_manager/public/cpp/interface_provider.h"
#include "services/tracing/public/cpp/trace_startup.h"
#include "skia/ext/switches.h"
#include "storage/browser/database/database_tracker.h"
#include "storage/browser/quota/quota_manager.h"
#include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
#include "third_party/blink/public/common/features.h"
#include "third_party/blink/public/common/page/launching_process_state.h"
#include "third_party/blink/public/common/storage_key/storage_key.h"
#include "third_party/blink/public/common/switches.h"
#include "third_party/blink/public/mojom/blob/file_backed_blob_factory.mojom.h"
#include "third_party/blink/public/mojom/disk_allocator.mojom.h"
#include "third_party/blink/public/mojom/origin_trials/origin_trials_settings.mojom.h"
#include "third_party/blink/public/mojom/plugins/plugin_registry.mojom.h"
#include "third_party/blink/public/public_buildflags.h"
#include "ui/accessibility/accessibility_switches.h"
#include "ui/base/ui_base_features.h"
#include "ui/base/ui_base_switches.h"
#include "ui/display/display_switches.h"
#include "ui/gfx/switches.h"
#include "ui/gl/gl_switches.h"
#include "url/gurl.h"
#include "url/origin.h"

#if BUILDFLAG(IS_ANDROID)
#include "base/android/child_process_binding_types.h"
#include "content/browser/font_unique_name_lookup/font_unique_name_lookup_service.h"
#include "content/browser/web_database/web_database_host_impl.h"
#include "media/audio/android/audio_manager_android.h"
#include "third_party/blink/public/mojom/android_font_lookup/android_font_lookup.mojom.h"
#endif

#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
#include <sys/resource.h>

#include "components/services/font/public/mojom/font_service.mojom.h"  // nogncheck
#include "content/browser/font_service.h"  // nogncheck
#include "third_party/blink/public/mojom/memory_usage_monitor_linux.mojom.h"  // nogncheck

#include "content/browser/child_thread_type_switcher_linux.h"
#include "content/common/thread_type_switcher.mojom.h"
#endif

#if BUILDFLAG(ALLOW_OOP_VIDEO_DECODER)
#include "content/public/browser/stable_video_decoder_factory.h"
#endif

#if BUILDFLAG(IS_APPLE)
#include "content/browser/child_process_task_port_provider_mac.h"
#endif

#if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_ANDROID)
#include "services/tracing/public/cpp/system_tracing_service.h"
#endif

#if !BUILDFLAG(IS_ANDROID)
#include "services/resource_coordinator/public/cpp/memory_instrumentation/os_metrics.h"
#endif

#if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_MAC)
#include "content/browser/v8_snapshot_files.h"
#endif

#if BUILDFLAG(IS_WIN)
#include "base/win/scoped_com_initializer.h"
#include "base/win/windows_version.h"
#include "components/app_launch_prefetch/app_launch_prefetch.h"
#include "content/browser/renderer_host/dwrite_font_proxy_impl_win.h"
#include "content/public/common/font_cache_dispatcher_win.h"
#include "content/public/common/font_cache_win.mojom.h"
#include "ui/display/win/dpi.h"
#endif

#if BUILDFLAG(ENABLE_LIBRARY_CDMS) || BUILDFLAG(IS_WIN) || BUILDFLAG(IS_ANDROID)
#include "content/browser/media/key_system_support_impl.h"
#endif

#if BUILDFLAG(ENABLE_PLUGINS)
#include "content/browser/renderer_host/plugin_registry_impl.h"
#endif

#if BUILDFLAG(ENABLE_PPAPI)
#include "content/browser/plugin_service_impl.h"
#include "content/browser/renderer_host/pepper/pepper_renderer_connection.h"
#include "ppapi/shared_impl/ppapi_switches.h"  // nogncheck
#endif

#if BUILDFLAG(IPC_MESSAGE_LOG_ENABLED)
#include "ipc/ipc_logging.h"
#endif

#if BUILDFLAG(IS_OZONE)
#include "ui/ozone/public/ozone_switches.h"
#endif

#if BUILDFLAG(CLANG_PROFILING_INSIDE_SANDBOX)
#include "content/public/common/profiling_utils.h"
#endif

#if BUILDFLAG(CONTENT_ENABLE_LEGACY_IPC)
#include "content/public/browser/browser_message_filter.h"
#endif

// VLOG additional statements in Fuchsia release builds.
#if BUILDFLAG(IS_FUCHSIA)
#define MAYBEVLOG
#else
#define MAYBEVLOG
#endif

namespace content {

namespace {

ChromeTrackEvent;

// Stores the maximum number of renderer processes the content module can
// create. Only applies if it is set to a non-zero value.
size_t g_max_renderer_count_override =;

bool g_run_renderer_in_process =;

RendererMainThreadFactoryFunction g_renderer_main_thread_factory =;

base::Thread* g_in_process_thread =;

RenderProcessHostFactory* g_render_process_host_factory_ =;
const char kSiteProcessMapKeyName[] =;

const void* const kProcessPerSiteUmaLoggedKey =;

RenderProcessHost::AnalyzeHungRendererFunction g_analyze_hung_renderer =;

#if BUILDFLAG(IS_WIN)
// This is from extensions/common/switches.cc
// Marks a renderer as extension process.
// TODO([email protected]): Replace this with a layer-respecting alternative.
const char kExtensionProcess[] = "extension-process";
#endif

// the global list of all renderer processes
base::IDMap<RenderProcessHost*>& GetAllHosts() {}

// Returns the global list of RenderProcessHostCreationObserver objects. Uses
// std::list to ensure iterators remain valid if observers are created or
// removed during iteration.
std::list<RenderProcessHostCreationObserver*>& GetAllCreationObservers() {}

// Returns |host|'s PID if the process is valid and "no-process" otherwise.
std::string GetRendererPidAsString(RenderProcessHost* host) {}

std::ostream& operator<<(std::ostream& o,
                         const SiteInstanceProcessAssignment& assignment) {}

// Map of site to process, to ensure we only have one RenderProcessHost per
// site in process-per-site mode.  Each map is specific to a BrowserContext.
class SiteProcessMap : public base::SupportsUserData::Data {};

// Find the SiteProcessMap specific to the given context.
SiteProcessMap* GetSiteProcessMapForBrowserContext(BrowserContext* context) {}

class RenderProcessHostIsReadyObserver : public RenderProcessHostObserver {};

bool HasEnoughMemoryForAnotherMainFrame(RenderProcessHost* host,
                                        size_t main_frame_count) {}

bool MayReuseAndIsSuitableWithMainFrameThreshold(
    RenderProcessHost* host,
    SiteInstanceImpl* site_instance,
    std::optional<size_t> main_frame_threshold) {}

// The following class is used to track the sites each RenderProcessHost is
// hosting frames for and expecting navigations to. There are two of them per
// BrowserContext: one for frames and one for navigations.
//
// For each site, the SiteProcessCountTracker keeps a map of counts per
// RenderProcessHost, which represents the number of frames/navigations
// for this site that are associated with the RenderProcessHost. This allows to
// quickly lookup a list of RenderProcessHost that can be used by a particular
// SiteInstance. On the other hand, it does not allow to quickly lookup which
// sites are hosted by a RenderProcessHost. This class is meant to help reusing
// RenderProcessHosts among SiteInstances, not to perform security checks for a
// RenderProcessHost.
const void* const kCommittedSiteProcessCountTrackerKey =;
const void* const kPendingSiteProcessCountTrackerKey =;
const void* const kDelayedShutdownSiteProcessCountTrackerKey =;
class SiteProcessCountTracker : public base::SupportsUserData::Data,
                                public RenderProcessHostObserver {};

bool ShouldTrackProcessForSite(const SiteInfo& site_info) {}

bool ShouldFindReusableProcessHostForSite(const SiteInfo& site_info) {}

std::string GetCurrentHostMapDebugString(
    const SiteProcessCountTracker* tracker) {}

const void* const kUnmatchedServiceWorkerProcessTrackerKey =;

// This class tracks 'unmatched' service worker processes. When a service worker
// is started after a navigation to the site, SiteProcessCountTracker that is
// implemented above is used to find the matching renderer process which is used
// for the navigation. But a service worker may be started before a navigation
// (ex: Push notification -> show the page of the notification).
// This class tracks processes with 'unmatched' service workers until the
// processes are reused for a navigation to a matching site. After a single
// matching navigation is put into the process, all service workers for that
// site in that process are considered 'matched.'
class UnmatchedServiceWorkerProcessTracker
    : public base::SupportsUserData::Data,
      public RenderProcessHostObserver {};

void CopyFeatureSwitch(const base::CommandLine& src,
                       base::CommandLine* dest,
                       const char* switch_name) {}

RenderProcessHostImpl::DomStorageBinder& GetDomStorageBinder() {}

#if !BUILDFLAG(IS_ANDROID)
static constexpr size_t kUnknownPlatformProcessLimit =;

// Returns the process limit from the system. Use |kUnknownPlatformProcessLimit|
// to indicate failure and std::numeric_limits<size_t>::max() to indicate
// unlimited.
size_t GetPlatformProcessLimit() {}
#endif  // !BUILDFLAG(IS_ANDROID)

RenderProcessHostImpl::BadMojoMessageCallbackForTesting&
GetBadMojoMessageCallbackForTesting() {}

void InvokeBadMojoMessageCallbackForTesting(int render_process_id,
                                            const std::string& error) {}

void LogDelayReasonForFastShutdown(
    const RenderProcessHostImpl::DelayShutdownReason& reason) {}

void LogDelayReasonForCleanup(
    const RenderProcessHostImpl::DelayShutdownReason& reason) {}

#if BUILDFLAG(ALLOW_OOP_VIDEO_DECODER)
RenderProcessHostImpl::StableVideoDecoderFactoryCreationCB&
GetStableVideoDecoderFactoryCreationCB() {}

RenderProcessHostImpl::StableVideoDecoderEventCB&
GetStableVideoDecoderEventCB() {}

void InvokeStableVideoDecoderEventCB(
    RenderProcessHostImpl::StableVideoDecoderEvent event) {}
#endif  // BUILDFLAG(ALLOW_OOP_VIDEO_DECODER)

// Kill-switch for the new CHECKs from https://crrev.com/c/4134809.
BASE_FEATURE();

// Please keep in sync with "RenderProcessHostBlockedURLReason" in
// tools/metrics/histograms/metadata/browser/enums.xml. These values are
// persisted to logs. Entries should not be renumbered and numeric values should
// never be reused.
enum class BlockedURLReason {};

// Helper to evaluate whether `host` is an unused RenderProcessHost, and whether
// it's allowed to be reused by a WebUI navigation in a BrowsingContextGroup
// represented by `isolation_context`.
bool IsUnusedAndTiedToBrowsingInstance(
    RenderProcessHost* host,
    const IsolationContext& isolation_context) {}

// Returns true if `keep_alive_ref_count_` is allowed to be > 0.
// When both of the features are enabled, fetch keepalive requests are expected
// to be proxied via browser process, without increasing any
// `keep_alive_ref_count_`.
bool IsKeepAliveRefCountAllowed() {}

BASE_FEATURE();

}  // namespace

RenderProcessHostImpl::IOThreadHostImpl::IOThreadHostImpl(
    int render_process_id,
    base::WeakPtr<RenderProcessHostImpl> weak_host,
    std::unique_ptr<service_manager::BinderRegistry> binders,
    mojo::PendingReceiver<mojom::ChildProcessHost> host_receiver)
    :{}

RenderProcessHostImpl::IOThreadHostImpl::~IOThreadHostImpl() = default;

void RenderProcessHostImpl::IOThreadHostImpl::SetPid(
    base::ProcessId child_pid) {}

void RenderProcessHostImpl::IOThreadHostImpl::GetInterfacesForTesting(
    std::vector<std::string>& out) {}

void RenderProcessHostImpl::IOThreadHostImpl::Ping(PingCallback callback) {}

// static
scoped_refptr<base::SingleThreadTaskRunner>
RenderProcessHostImpl::GetInProcessRendererThreadTaskRunnerForTesting() {}

#if !BUILDFLAG(IS_ANDROID)
// static
size_t RenderProcessHostImpl::GetPlatformMaxRendererProcessCount() {}
#endif

// static
size_t RenderProcessHost::GetMaxRendererProcessCount() {}

// static
void RenderProcessHost::SetMaxRendererProcessCount(size_t count) {}

// static
int RenderProcessHost::GetCurrentRenderProcessCountForTesting() {}

// static
RenderProcessHost* RenderProcessHostImpl::CreateRenderProcessHost(
    BrowserContext* browser_context,
    SiteInstanceImpl* site_instance) {}

// static
const unsigned int RenderProcessHostImpl::kMaxFrameDepthForPriority =;

// static
const base::TimeDelta RenderProcessHostImpl::kKeepAliveHandleFactoryTimeout =;

RenderProcessHostImpl::RenderProcessHostImpl(
    BrowserContext* browser_context,
    StoragePartitionImpl* storage_partition_impl,
    int flags)
    :{}

// static
void RenderProcessHostImpl::ShutDownInProcessRenderer() {}

void RenderProcessHostImpl::RegisterRendererMainThreadFactory(
    RendererMainThreadFactoryFunction create) {}

void RenderProcessHostImpl::SetDomStorageBinderForTesting(
    DomStorageBinder binder) {}

bool RenderProcessHostImpl::HasDomStorageBinderForTesting() {}

// static
void RenderProcessHostImpl::SetBadMojoMessageCallbackForTesting(
    BadMojoMessageCallbackForTesting callback) {}

void RenderProcessHostImpl::SetForGuestsOnlyForTesting() {}

RenderProcessHostImpl::~RenderProcessHostImpl() {}

bool RenderProcessHostImpl::Init() {}

void RenderProcessHostImpl::EnableSendQueue() {}

void RenderProcessHostImpl::InitializeChannelProxy() {}

void RenderProcessHostImpl::InitializeSharedMemoryRegionsOnceChannelIsUp() {}

void RenderProcessHostImpl::ResetChannelProxy() {}

void RenderProcessHostImpl::CreateMessageFilters() {}

void RenderProcessHostImpl::BindCacheStorage(
    const network::CrossOriginEmbedderPolicy& cross_origin_embedder_policy,
    mojo::PendingRemote<network::mojom::CrossOriginEmbedderPolicyReporter>
        coep_reporter_remote,
    const network::DocumentIsolationPolicy& document_isolation_policy,
    const storage::BucketLocator& bucket_locator,
    mojo::PendingReceiver<blink::mojom::CacheStorage> receiver) {}

void RenderProcessHostImpl::BindIndexedDB(
    const blink::StorageKey& storage_key,
    BucketContext& bucket_context,
    mojo::PendingReceiver<blink::mojom::IDBFactory> receiver) {}

void RenderProcessHostImpl::BindBucketManagerHost(
    base::WeakPtr<BucketContext> bucket_context,
    mojo::PendingReceiver<blink::mojom::BucketManagerHost> receiver) {}

void RenderProcessHostImpl::ForceCrash() {}

void RenderProcessHostImpl::BindFileSystemManager(
    const blink::StorageKey& storage_key,
    mojo::PendingReceiver<blink::mojom::FileSystemManager> receiver) {}

void RenderProcessHostImpl::BindFileSystemAccessManager(
    const blink::StorageKey& storage_key,
    mojo::PendingReceiver<blink::mojom::FileSystemAccessManager> receiver) {}

void RenderProcessHostImpl::BindFileBackedBlobFactory(
    const url::Origin& origin,
    mojo::PendingReceiver<blink::mojom::FileBackedBlobFactory> receiver) {}

void RenderProcessHostImpl::GetSandboxedFileSystemForBucket(
    const storage::BucketLocator& bucket,
    const std::vector<std::string>& directory_path_components,
    blink::mojom::FileSystemAccessManager::GetSandboxedFileSystemCallback
        callback) {}

void RenderProcessHostImpl::BindRestrictedCookieManagerForServiceWorker(
    const blink::StorageKey& storage_key,
    mojo::PendingReceiver<network::mojom::RestrictedCookieManager> receiver) {}

void RenderProcessHostImpl::BindVideoDecodePerfHistory(
    mojo::PendingReceiver<media::mojom::VideoDecodePerfHistory> receiver) {}

void RenderProcessHostImpl::BindWebrtcVideoPerfHistory(
    mojo::PendingReceiver<media::mojom::WebrtcVideoPerfHistory> receiver) {}

void RenderProcessHostImpl::BindQuotaManagerHost(
    const blink::StorageKey& storage_key,
    mojo::PendingReceiver<blink::mojom::QuotaManagerHost> receiver) {}

void RenderProcessHostImpl::CreateLockManager(
    const blink::StorageKey& storage_key,
    mojo::PendingReceiver<blink::mojom::LockManager> receiver) {}

void RenderProcessHostImpl::CreateLockManagerWithBucketInfo(
    mojo::PendingReceiver<blink::mojom::LockManager> receiver,
    storage::QuotaErrorOr<storage::BucketInfo> bucket) {}

void RenderProcessHostImpl::CreatePermissionService(
    const url::Origin& origin,
    mojo::PendingReceiver<blink::mojom::PermissionService> receiver) {}

void RenderProcessHostImpl::CreatePaymentManagerForOrigin(
    const url::Origin& origin,
    mojo::PendingReceiver<payments::mojom::PaymentManager> receiver) {}

void RenderProcessHostImpl::CreateNotificationService(
    GlobalRenderFrameHostId rfh_id,
    const RenderProcessHost::NotificationServiceCreatorType creator_type,
    const blink::StorageKey& storage_key,
    mojo::PendingReceiver<blink::mojom::NotificationService> receiver) {}

void RenderProcessHostImpl::CreateWebSocketConnector(
    const blink::StorageKey& storage_key,
    mojo::PendingReceiver<blink::mojom::WebSocketConnector> receiver) {}

#if BUILDFLAG(IS_CHROMEOS_ASH)
void RenderProcessHostImpl::ReinitializeLogging(
    uint32_t logging_dest,
    base::ScopedFD log_file_descriptor) {
  auto logging_settings = mojom::LoggingSettings::New();
  logging_settings->logging_dest = logging_dest;
  logging_settings->log_file_descriptor =
      mojo::PlatformHandle(std::move(log_file_descriptor));
  child_process_->ReinitializeLogging(std::move(logging_settings));
}
#endif  // BUILDFLAG(IS_CHROMEOS_ASH)

void RenderProcessHostImpl::SetBatterySaverMode(
    bool battery_saver_mode_enabled) {}

#if BUILDFLAG(ALLOW_OOP_VIDEO_DECODER)
void RenderProcessHostImpl::CreateStableVideoDecoder(
    mojo::PendingReceiver<media::stable::mojom::StableVideoDecoder> receiver) {}

void RenderProcessHostImpl::OnStableVideoDecoderDisconnected() {}

void RenderProcessHostImpl::ResetStableVideoDecoderFactory() {}

void RenderProcessHostImpl::SetStableVideoDecoderFactoryCreationCBForTesting(
    StableVideoDecoderFactoryCreationCB callback) {}

void RenderProcessHostImpl::SetStableVideoDecoderEventCBForTesting(
    StableVideoDecoderEventCB callback) {}
#endif  // BUILDFLAG(ALLOW_OOP_VIDEO_DECODER)

void RenderProcessHostImpl::DelayProcessShutdown(
    const base::TimeDelta& subframe_shutdown_timeout,
    const base::TimeDelta& unload_handler_timeout,
    const SiteInfo& site_info) {}

bool RenderProcessHostImpl::IsProcessShutdownDelayedForTesting() {}

std::string
RenderProcessHostImpl::GetInfoForBrowserContextDestructionCrashReporting() {}

#if BUILDFLAG(CLANG_PROFILING_INSIDE_SANDBOX)
void RenderProcessHostImpl::DumpProfilingData(base::OnceClosure callback) {
  DCHECK_CURRENTLY_ON(BrowserThread::UI);
  GetRendererInterface()->WriteClangProfilingProfile(std::move(callback));
}
#endif

void RenderProcessHostImpl::WriteIntoTrace(
    perfetto::TracedProto<perfetto::protos::pbzero::RenderProcessHost> proto)
    const {}

void RenderProcessHostImpl::CreateEmbeddedFrameSinkProvider(
    mojo::PendingReceiver<blink::mojom::EmbeddedFrameSinkProvider> receiver) {}

void RenderProcessHostImpl::BindCompositingModeReporter(
    mojo::PendingReceiver<viz::mojom::CompositingModeReporter> receiver) {}

void RenderProcessHostImpl::CreateDomStorageProvider(
    mojo::PendingReceiver<blink::mojom::DomStorageProvider> receiver) {}

void RenderProcessHostImpl::BindMediaInterfaceProxy(
    mojo::PendingReceiver<media::mojom::InterfaceFactory> receiver) {}

void RenderProcessHostImpl::BindVideoEncoderMetricsProvider(
    mojo::PendingReceiver<media::mojom::VideoEncoderMetricsProvider> receiver) {}

#if BUILDFLAG(IS_ANDROID)
void RenderProcessHostImpl::BindWebDatabaseHostImpl(
    mojo::PendingReceiver<blink::mojom::WebDatabaseHost> receiver) {
  storage::DatabaseTracker* db_tracker =
      storage_partition_impl_->GetDatabaseTracker();
  DCHECK(db_tracker);
  db_tracker->task_runner()->PostTask(
      FROM_HERE,
      base::BindOnce(&WebDatabaseHostImpl::Create, GetID(),
                     base::WrapRefCounted(db_tracker), std::move(receiver)));
}
#endif  // BULDFLAG(IS_ANDROID)

void RenderProcessHostImpl::BindAecDumpManager(
    mojo::PendingReceiver<blink::mojom::AecDumpManager> receiver) {}

void RenderProcessHostImpl::CreateOneShotSyncService(
    const url::Origin& origin,
    mojo::PendingReceiver<blink::mojom::OneShotBackgroundSyncService>
        receiver) {}

void RenderProcessHostImpl::CreatePeriodicSyncService(
    const url::Origin& origin,
    mojo::PendingReceiver<blink::mojom::PeriodicBackgroundSyncService>
        receiver) {}

void RenderProcessHostImpl::BindPushMessaging(
    mojo::PendingReceiver<blink::mojom::PushMessaging> receiver) {}

void RenderProcessHostImpl::BindP2PSocketManager(
    net::NetworkAnonymizationKey anonymization_key,
    mojo::PendingReceiver<network::mojom::P2PSocketManager> receiver,
    GlobalRenderFrameHostId render_frame_host_id) {}

void RenderProcessHostImpl::CreateMediaLogRecordHost(
    mojo::PendingReceiver<content::mojom::MediaInternalLogRecords> receiver) {}

#if BUILDFLAG(ENABLE_PLUGINS)
void RenderProcessHostImpl::BindPluginRegistry(
    mojo::PendingReceiver<blink::mojom::PluginRegistry> receiver) {}
#endif

#if BUILDFLAG(IS_FUCHSIA)
void RenderProcessHostImpl::BindMediaCodecProvider(
    mojo::PendingReceiver<media::mojom::FuchsiaMediaCodecProvider> receiver) {
  if (!media_codec_provider_) {
    media_codec_provider_ = std::make_unique<FuchsiaMediaCodecProviderImpl>();
  }
  media_codec_provider_->AddReceiver(std::move(receiver));
}
#endif

void RenderProcessHostImpl::BindDomStorage(
    mojo::PendingReceiver<blink::mojom::DomStorage> receiver,
    mojo::PendingRemote<blink::mojom::DomStorageClient> client) {}

void RenderProcessHostImpl::RegisterCoordinatorClient(
    mojo::PendingReceiver<memory_instrumentation::mojom::Coordinator> receiver,
    mojo::PendingRemote<memory_instrumentation::mojom::ClientProcess>
        client_process) {}

void RenderProcessHostImpl::CreateRendererHost(
    mojo::PendingAssociatedReceiver<mojom::RendererHost> receiver) {}

int RenderProcessHostImpl::GetNextRoutingID() {}

void RenderProcessHostImpl::BindReceiver(
    mojo::GenericPendingReceiver receiver) {}

std::unique_ptr<base::PersistentMemoryAllocator>
RenderProcessHostImpl::TakeMetricsAllocator() {}

const base::TimeTicks& RenderProcessHostImpl::GetLastInitTime() {}

base::Process::Priority RenderProcessHostImpl::GetPriority() {}

void RenderProcessHostImpl::IncrementKeepAliveRefCount(uint64_t handle_id) {}

bool RenderProcessHostImpl::AreAllRefCountsZero() {}

void RenderProcessHostImpl::DecrementKeepAliveRefCount(uint64_t handle_id) {}

void RenderProcessHostImpl::IncrementPendingReuseRefCount() {}

void RenderProcessHostImpl::DecrementPendingReuseRefCount() {}

std::string RenderProcessHostImpl::GetKeepAliveDurations() const {}

size_t RenderProcessHostImpl::GetShutdownDelayRefCount() const {}

void RenderProcessHostImpl::IncrementNavigationStateKeepAliveCount() {}

void RenderProcessHostImpl::DecrementNavigationStateKeepAliveCount() {}

int RenderProcessHostImpl::GetRenderFrameHostCount() const {}

void RenderProcessHostImpl::ForEachRenderFrameHost(
    base::FunctionRef<void(RenderFrameHost*)> on_render_frame_host) {}

void RenderProcessHostImpl::RegisterRenderFrameHost(
    const GlobalRenderFrameHostId& render_frame_host_id,
    bool is_outermost_main_frame) {}

void RenderProcessHostImpl::UnregisterRenderFrameHost(
    const GlobalRenderFrameHostId& render_frame_host_id,
    bool is_outermost_main_frame) {}

void RenderProcessHostImpl::IncrementWorkerRefCount() {}

void RenderProcessHostImpl::DecrementWorkerRefCount() {}

void RenderProcessHostImpl::DisableRefCounts() {}

bool RenderProcessHostImpl::AreRefCountsDisabled() {}

mojom::Renderer* RenderProcessHostImpl::GetRendererInterface() {}

blink::mojom::CallStackGenerator*
RenderProcessHostImpl::GetJavaScriptCallStackGeneratorInterface() {}

ProcessLock RenderProcessHostImpl::GetProcessLock() const {}

bool RenderProcessHostImpl::MayReuseHost() {}

bool RenderProcessHostImpl::IsUnused() {}

void RenderProcessHostImpl::SetIsUsed() {}

void RenderProcessHostImpl::AddRoute(int32_t routing_id,
                                     IPC::Listener* listener) {}

void RenderProcessHostImpl::RemoveRoute(int32_t routing_id) {}

bool RenderProcessHostImpl::TakeStoredDataForFrameToken(
    const blink::LocalFrameToken& frame_token,
    int32_t& new_routing_id,
    base::UnguessableToken& devtools_frame_token,
    blink::DocumentToken& document_token) {}

void RenderProcessHostImpl::AddObserver(RenderProcessHostObserver* observer) {}

void RenderProcessHostImpl::RemoveObserver(
    RenderProcessHostObserver* observer) {}

void RenderProcessHostImpl::AddInternalObserver(
    RenderProcessHostInternalObserver* observer) {}

void RenderProcessHostImpl::RemoveInternalObserver(
    RenderProcessHostInternalObserver* observer) {}

void RenderProcessHostImpl::ShutdownForBadMessage(
    CrashReportMode crash_report_mode) {}

void RenderProcessHostImpl::UpdateClientPriority(
    RenderProcessHostPriorityClient* client) {}

int RenderProcessHostImpl::VisibleClientCount() {}

unsigned int RenderProcessHostImpl::GetFrameDepth() {}

bool RenderProcessHostImpl::GetIntersectsViewport() {}

#if BUILDFLAG(IS_ANDROID)
ChildProcessImportance RenderProcessHostImpl::GetEffectiveImportance() {
  return effective_importance_;
}

base::android::ChildBindingState
RenderProcessHostImpl::GetEffectiveChildBindingState() {
  if (child_process_launcher_) {
    return child_process_launcher_->GetEffectiveChildBindingState();
  }

  // If there is no ChildProcessLauncher this is the best default.
  return base::android::ChildBindingState::UNBOUND;
}

void RenderProcessHostImpl::DumpProcessStack() {
  if (child_process_launcher_)
    child_process_launcher_->DumpProcessStack();
}
#endif

void RenderProcessHostImpl::OnMediaStreamAdded() {}

void RenderProcessHostImpl::OnMediaStreamRemoved() {}

void RenderProcessHostImpl::OnForegroundServiceWorkerAdded() {}

void RenderProcessHostImpl::OnForegroundServiceWorkerRemoved() {}

void RenderProcessHostImpl::OnBoostForLoadingAdded() {}

void RenderProcessHostImpl::OnBoostForLoadingRemoved() {}

// static
void RenderProcessHostImpl::set_render_process_host_factory_for_testing(
    RenderProcessHostFactory* rph_factory) {}

// static
RenderProcessHostFactory*
RenderProcessHostImpl::get_render_process_host_factory_for_testing() {}

// static
void RenderProcessHostImpl::AddFrameWithSite(
    BrowserContext* browser_context,
    RenderProcessHost* render_process_host,
    const SiteInfo& site_info) {}

// static
void RenderProcessHostImpl::RemoveFrameWithSite(
    BrowserContext* browser_context,
    RenderProcessHost* render_process_host,
    const SiteInfo& site_info) {}

// static
void RenderProcessHostImpl::AddExpectedNavigationToSite(
    BrowserContext* browser_context,
    RenderProcessHost* render_process_host,
    const SiteInfo& site_info) {}

// static
void RenderProcessHostImpl::RemoveExpectedNavigationToSite(
    BrowserContext* browser_context,
    RenderProcessHost* render_process_host,
    const SiteInfo& site_info) {}

// static
void RenderProcessHostImpl::NotifySpareManagerAboutRecentlyUsedSiteInstance(
    SiteInstance* site_instance) {}

// static
RenderProcessHost* RenderProcessHost::GetSpareRenderProcessHost() {}

// static
RenderProcessHost* RenderProcessHost::GetSpareRenderProcessHostForTesting() {}

// static
base::CallbackListSubscription
RenderProcessHost::RegisterSpareRenderProcessHostChangedCallback(
    const base::RepeatingCallback<void(RenderProcessHost*)>& cb) {}

// static
void RenderProcessHostImpl::DiscardSpareRenderProcessHostForTesting() {}

// static
bool RenderProcessHostImpl::IsSpareProcessKeptAtAllTimes() {}

// static
void RenderProcessHostImpl::ClearAllResourceCaches() {}

bool RenderProcessHostImpl::HostHasNotBeenUsed() {}

bool RenderProcessHostImpl::IsSpare() const {}

void RenderProcessHostImpl::SetProcessLock(
    const IsolationContext& isolation_context,
    const ProcessLock& process_lock) {}

bool RenderProcessHostImpl::IsProcessLockedToSiteForTesting() {}

void RenderProcessHostImpl::NotifyRendererOfLockedStateUpdate() {}

bool RenderProcessHostImpl::IsForGuestsOnly() {}

bool RenderProcessHostImpl::IsJitDisabled() {}

bool RenderProcessHostImpl::AreV8OptimizationsDisabled() {}

bool RenderProcessHostImpl::IsPdf() {}

StoragePartitionImpl* RenderProcessHostImpl::GetStoragePartition() {}

static void AppendCompositorCommandLineFlags(base::CommandLine* command_line) {}

void RenderProcessHostImpl::AppendRendererCommandLine(
    base::CommandLine* command_line) {}

void RenderProcessHostImpl::PropagateBrowserCommandLineToRenderer(
    const base::CommandLine& browser_cmd,
    base::CommandLine* renderer_cmd) {}

const base::Process& RenderProcessHostImpl::GetProcess() {}

bool RenderProcessHostImpl::IsReady() {}

const std::string&
RenderProcessHostImpl::GetUnresponsiveDocumentJavascriptCallStack() const {}

const blink::LocalFrameToken&
RenderProcessHostImpl::GetUnresponsiveDocumentToken() const {}

void RenderProcessHostImpl::SetUnresponsiveDocumentJSCallStackAndToken(
    const std::string& untrusted_javascript_call_stack,
    const std::optional<blink::LocalFrameToken>& frame_token) {}

void RenderProcessHostImpl::InterruptJavaScriptIsolateAndCollectCallStack() {}

bool RenderProcessHostImpl::Shutdown(int exit_code) {}

bool RenderProcessHostImpl::ShutdownRequested() {}

bool RenderProcessHostImpl::FastShutdownIfPossible(size_t page_count,
                                                   bool skip_unload_handlers) {}

bool RenderProcessHostImpl::Send(IPC::Message* msg) {}

bool RenderProcessHostImpl::OnMessageReceived(const IPC::Message& msg) {}

void RenderProcessHostImpl::OnAssociatedInterfaceRequest(
    const std::string& interface_name,
    mojo::ScopedInterfaceEndpointHandle handle) {}

void RenderProcessHostImpl::OnChannelConnected(int32_t peer_pid) {}

void RenderProcessHostImpl::OnChannelError() {}

void RenderProcessHostImpl::OnBadMessageReceived(const IPC::Message& message) {}

BrowserContext* RenderProcessHostImpl::GetBrowserContext() {}

bool RenderProcessHostImpl::InSameStoragePartition(
    StoragePartition* partition) {}

int RenderProcessHostImpl::GetID() const {}

base::SafeRef<RenderProcessHost> RenderProcessHostImpl::GetSafeRef() const {}

bool RenderProcessHostImpl::IsInitializedAndNotDead() {}

bool RenderProcessHostImpl::IsDeletingSoon() {}

void RenderProcessHostImpl::SetBlocked(bool blocked) {}

bool RenderProcessHostImpl::IsBlocked() {}

void RenderProcessHostImpl::PauseSocketManagerForRenderFrameHost(
    const GlobalRenderFrameHostId& render_frame_host_id) {}

void RenderProcessHostImpl::ResumeSocketManagerForRenderFrameHost(
    const GlobalRenderFrameHostId& render_frame_host_id) {}

base::CallbackListSubscription
RenderProcessHostImpl::RegisterBlockStateChangedCallback(
    const BlockStateChangedCallback& cb) {}

bool RenderProcessHostImpl::HasOnlyNonLiveRenderFrameHosts() {}

void RenderProcessHostImpl::Cleanup() {}

#if BUILDFLAG(IS_ANDROID)
void RenderProcessHostImpl::PopulateTerminationInfoRendererFields(
    ChildProcessTerminationInfo* info) {
  info->renderer_has_visible_clients = VisibleClientCount() > 0;
  info->renderer_was_subframe = GetFrameDepth() > 0;
}
#endif  // BUILDFLAG(IS_ANDROID)

void RenderProcessHostImpl::AddPendingView() {}

void RenderProcessHostImpl::RemovePendingView() {}

void RenderProcessHostImpl::AddPriorityClient(
    RenderProcessHostPriorityClient* priority_client) {}

void RenderProcessHostImpl::RemovePriorityClient(
    RenderProcessHostPriorityClient* priority_client) {}

#if !BUILDFLAG(IS_ANDROID)
void RenderProcessHostImpl::SetPriorityOverride(
    base::Process::Priority priority) {}

bool RenderProcessHostImpl::HasPriorityOverride() {}

void RenderProcessHostImpl::ClearPriorityOverride() {}
#endif  // !BUILDFLAG(IS_ANDROID)

void RenderProcessHostImpl::SetSuddenTerminationAllowed(bool enabled) {}

bool RenderProcessHostImpl::SuddenTerminationAllowed() {}

base::TimeDelta RenderProcessHostImpl::GetChildProcessIdleTime() {}

viz::GpuClient* RenderProcessHostImpl::GetGpuClient() {}

RenderProcessHost::FilterURLResult RenderProcessHostImpl::FilterURL(
    bool empty_allowed,
    GURL* url) {}

void RenderProcessHostImpl::EnableAudioDebugRecordings(
    const base::FilePath& file_path) {}

void RenderProcessHostImpl::DisableAudioDebugRecordings() {}

RenderProcessHostImpl::WebRtcStopRtpDumpCallback
RenderProcessHostImpl::StartRtpDump(bool incoming,
                                    bool outgoing,
                                    WebRtcRtpPacketCallback packet_callback) {}

IPC::ChannelProxy* RenderProcessHostImpl::GetChannel() {}

#if BUILDFLAG(CONTENT_ENABLE_LEGACY_IPC)
void RenderProcessHostImpl::AddFilter(BrowserMessageFilter* filter) {
  channel_->AddFilter(filter->GetFilter());
}
#endif

bool RenderProcessHostImpl::FastShutdownStarted() {}

// static
void RenderProcessHostImpl::RegisterHost(int host_id, RenderProcessHost* host) {}

// static
void RenderProcessHostImpl::UnregisterHost(int host_id) {}

// static
void RenderProcessHostImpl::RegisterCreationObserver(
    RenderProcessHostCreationObserver* observer) {}

// static
void RenderProcessHostImpl::UnregisterCreationObserver(
    RenderProcessHostCreationObserver* observer) {}

// static
RenderProcessHost::FilterURLResult RenderProcessHostImpl::FilterURL(
    RenderProcessHost* rph,
    bool empty_allowed,
    GURL* url) {}

// static
bool RenderProcessHostImpl::IsSuitableHost(
    RenderProcessHost* host,
    const IsolationContext& isolation_context,
    const SiteInfo& site_info) {}

// static
bool RenderProcessHostImpl::MayReuseAndIsSuitable(
    RenderProcessHost* host,
    const IsolationContext& isolation_context,
    const SiteInfo& site_info) {}

// static
bool RenderProcessHostImpl::MayReuseAndIsSuitable(
    RenderProcessHost* host,
    SiteInstanceImpl* site_instance) {}

// static
bool RenderProcessHostImpl::ShouldDelayProcessShutdown() {}

// static
void RenderProcessHost::WarmupSpareRenderProcessHost(
    content::BrowserContext* browser_context) {}

// static
bool RenderProcessHost::run_renderer_in_process() {}

// static
void RenderProcessHost::SetRunRendererInProcess(bool value) {}

// static
void RenderProcessHost::ShutDownInProcessRenderer() {}

// static
RenderProcessHost::iterator RenderProcessHost::AllHostsIterator() {}

// static
RenderProcessHost* RenderProcessHost::FromID(int render_process_id) {}

// static
size_t RenderProcessHostImpl::GetProcessCount() {}

// static
size_t RenderProcessHostImpl::GetProcessCountForLimit() {}

// static
bool RenderProcessHost::ShouldTryToUseExistingProcessHost(
    BrowserContext* browser_context,
    const GURL& url) {}

// static
RenderProcessHost* RenderProcessHostImpl::GetExistingProcessHost(
    SiteInstanceImpl* site_instance) {}

// static
RenderProcessHost* RenderProcessHostImpl::GetSoleProcessHostForSite(
    const IsolationContext& isolation_context,
    const SiteInfo& site_info) {}

void RenderProcessHostImpl::RegisterSoleProcessHostForSite(
    RenderProcessHost* process,
    SiteInstanceImpl* site_instance) {}

// static
RenderProcessHost* RenderProcessHostImpl::GetProcessHostForSiteInstance(
    SiteInstanceImpl* site_instance) {}

void RenderProcessHostImpl::CreateMetricsAllocator() {}

void RenderProcessHostImpl::ShareMetricsMemoryRegion() {}

ChildProcessTerminationInfo RenderProcessHostImpl::GetChildTerminationInfo(
    bool already_dead) {}

void RenderProcessHostImpl::ProcessDied(
    const ChildProcessTerminationInfo& termination_info) {}

void RenderProcessHostImpl::FastShutdown() {}

void RenderProcessHostImpl::ResetIPC() {}

size_t RenderProcessHost::GetActiveViewCount() {}

WebExposedIsolationLevel RenderProcessHost::GetWebExposedIsolationLevel() {}

void RenderProcessHost::PostTaskWhenProcessIsReady(base::OnceClosure task) {}

// static
void RenderProcessHost::SetHungRendererAnalysisFunction(
    AnalyzeHungRendererFunction analyze_hung_renderer) {}

void RenderProcessHostImpl::SuddenTerminationChanged(bool enabled) {}

void RenderProcessHostImpl::RecordUserMetricsAction(const std::string& action) {}

#if BUILDFLAG(IS_ANDROID)
void RenderProcessHostImpl::SetPrivateMemoryFootprint(
    uint64_t private_memory_footprint_bytes) {
  private_memory_footprint_bytes_ = private_memory_footprint_bytes;
}
#endif

void RenderProcessHostImpl::SetPrivateMemoryFootprintForTesting(
    uint64_t private_memory_footprint_bytes) {}

uint64_t RenderProcessHostImpl::GetPrivateMemoryFootprint() {}

void RenderProcessHostImpl::HasGpuProcess(HasGpuProcessCallback callback) {}

void RenderProcessHostImpl::UpdateProcessPriorityInputs() {}

void RenderProcessHostImpl::UpdateProcessPriority() {}

void RenderProcessHostImpl::UpdateControllerServiceWorkerProcessPriority() {}

void RenderProcessHostImpl::SendProcessStateToRenderer() {}

void RenderProcessHostImpl::OnProcessLaunched() {}

void RenderProcessHostImpl::OnProcessLaunchFailed(int error_code) {}

void RenderProcessHostImpl::BindChildHistogramFetcherFactory(
    mojo::PendingReceiver<metrics::mojom::ChildHistogramFetcherFactory>
        factory) {}

// static
RenderProcessHost*
RenderProcessHostImpl::FindReusableProcessHostForSiteInstance(
    SiteInstanceImpl* site_instance,
    std::optional<size_t> main_frame_threshold) {}

// static
void RenderProcessHostImpl::OnMojoError(int render_process_id,
                                        const std::string& error) {}

void RenderProcessHostImpl::GetBrowserHistogram(
    const std::string& name,
    BrowserHistogramCallback callback) {}

void RenderProcessHostImpl::CancelProcessShutdownDelay(
    const SiteInfo& site_info) {}

void RenderProcessHostImpl::StopTrackingProcessForShutdownDelay() {}

void RenderProcessHostImpl::BindTracedProcess(
    mojo::PendingReceiver<tracing::mojom::TracedProcess> receiver) {}

#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
void RenderProcessHostImpl::ProvideStatusFileForRenderer() {}
#endif

void RenderProcessHostImpl::ProvideSwapFileForRenderer() {}

#if BUILDFLAG(IS_ANDROID)

void RenderProcessHostImpl::NotifyMemoryPressureToRenderer(
    base::MemoryPressureListener::MemoryPressureLevel level) {
  child_process_->OnMemoryPressure(level);
}

#endif

void RenderProcessHostImpl::GetBoundInterfacesForTesting(
    std::vector<std::string>& out) {}

}  // namespace content