remote_frame.mojom.cc | Explore in Territory

// third_party/blink/public/mojom/frame/remote_frame.mojom.cc is auto generated by mojom_bindings_generator.py, do not edit

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

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "third_party/blink/public/mojom/frame/remote_frame.mojom.h"

#include <math.h>
#include <stdint.h>
#include <utility>

#include "base/debug/alias.h"
#include "base/hash/md5_constexpr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "mojo/public/cpp/bindings/features.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/proxy_to_responder.h"
#include "mojo/public/cpp/bindings/lib/send_message_helper.h"
#include "mojo/public/cpp/bindings/lib/serialization_util.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "mojo/public/cpp/bindings/urgent_message_scope.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "third_party/blink/public/mojom/frame/remote_frame.mojom-params-data.h"
#include "third_party/blink/public/mojom/frame/remote_frame.mojom-shared-message-ids.h"

#include "third_party/blink/public/mojom/frame/remote_frame.mojom-import-headers.h"
#include "third_party/blink/public/mojom/frame/remote_frame.mojom-test-utils.h"
#include "services/network/public/mojom/cookie_access_observer.mojom.h"
#include "services/network/public/mojom/devtools_observer.mojom.h"
#include "services/network/public/mojom/trust_token_access_observer.mojom.h"
#include "third_party/blink/common/permissions_policy/permissions_policy_mojom_traits.h"
#include "third_party/blink/public/common/messaging/accelerated_static_bitmap_image_mojom_traits.h"
#include "third_party/blink/public/common/messaging/cloneable_message_mojom_traits.h"
#include "third_party/blink/public/common/messaging/task_attribution_id_mojom_traits.h"
#include "third_party/blink/public/common/messaging/transferable_message_mojom_traits.h"


namespace blink::mojom {
RemoteMainFrameInterfaces::RemoteMainFrameInterfaces()
    : … { … }

RemoteMainFrameInterfaces::RemoteMainFrameInterfaces(
    ::mojo::PendingAssociatedRemote<RemoteMainFrameHost> main_frame_host_in,
    ::mojo::PendingAssociatedReceiver<RemoteMainFrame> main_frame_in)
    : … { … }

RemoteMainFrameInterfaces::~RemoteMainFrameInterfaces() = default;

void RemoteMainFrameInterfaces::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool RemoteMainFrameInterfaces::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
RemoteFrameInterfacesFromRenderer::RemoteFrameInterfacesFromRenderer()
    : … { … }

RemoteFrameInterfacesFromRenderer::RemoteFrameInterfacesFromRenderer(
    ::mojo::PendingAssociatedRemote<RemoteFrame> frame_in,
    ::mojo::PendingAssociatedReceiver<RemoteFrameHost> frame_host_receiver_in)
    : … { … }

RemoteFrameInterfacesFromRenderer::~RemoteFrameInterfacesFromRenderer() = default;

void RemoteFrameInterfacesFromRenderer::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool RemoteFrameInterfacesFromRenderer::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
RemoteFrameInterfacesFromBrowser::RemoteFrameInterfacesFromBrowser()
    : … { … }

RemoteFrameInterfacesFromBrowser::RemoteFrameInterfacesFromBrowser(
    ::mojo::PendingAssociatedReceiver<RemoteFrame> frame_receiver_in,
    ::mojo::PendingAssociatedRemote<RemoteFrameHost> frame_host_in)
    : … { … }

RemoteFrameInterfacesFromBrowser::~RemoteFrameInterfacesFromBrowser() = default;

void RemoteFrameInterfacesFromBrowser::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool RemoteFrameInterfacesFromBrowser::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
CreateRemoteChildParams::CreateRemoteChildParams()
    : … { … }

CreateRemoteChildParams::CreateRemoteChildParams(
    const ::blink::RemoteFrameToken& token_in,
    const std::optional<::blink::FrameToken>& opener_frame_token_in,
    ::blink::mojom::TreeScopeType tree_scope_type_in,
    ::blink::mojom::FrameReplicationStatePtr replication_state_in,
    ::blink::mojom::FrameOwnerPropertiesPtr owner_properties_in,
    bool is_loading_in,
    const ::base::UnguessableToken& devtools_frame_token_in,
    RemoteFrameInterfacesFromBrowserPtr frame_interfaces_in,
    std::vector<CreateRemoteChildParamsPtr> child_params_in)
    : … { … }

CreateRemoteChildParams::~CreateRemoteChildParams() = default;

void CreateRemoteChildParams::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool CreateRemoteChildParams::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
OpenURLParams::OpenURLParams()
    : … { … }

OpenURLParams::OpenURLParams(
    const ::GURL& url_in,
    const ::url::Origin& initiator_origin_in,
    const std::optional<::GURL>& initiator_base_url_in,
    const std::optional<::blink::LocalFrameToken>& initiator_frame_token_in,
    ::scoped_refptr<::network::ResourceRequestBody> post_body_in,
    const std::string& extra_headers_in,
    ::blink::mojom::ReferrerPtr referrer_in,
    bool is_form_submission_in,
    ::WindowOpenDisposition disposition_in,
    bool should_replace_current_entry_in,
    bool user_gesture_in,
    bool is_unfenced_top_navigation_in,
    ::blink::mojom::TriggeringEventInfo triggering_event_info_in,
    ::mojo::PendingRemote<::blink::mojom::BlobURLToken> blob_url_token_in,
    const std::string& href_translate_in,
    const std::optional<::blink::Impression>& impression_in,
    const ::blink::NavigationDownloadPolicy& download_policy_in,
    ::network::mojom::SourceLocationPtr source_location_in,
    ::mojo::PendingRemote<NavigationStateKeepAliveHandle> initiator_navigation_state_keep_alive_handle_in,
    ::blink::mojom::NavigationInitiatorActivationAndAdStatus initiator_activation_and_ad_status_in,
    bool is_container_initiated_in,
    bool has_rel_opener_in,
    ::net::StorageAccessApiStatus storage_access_api_status_in)
    : … { … }

OpenURLParams::~OpenURLParams() = default;

void OpenURLParams::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool OpenURLParams::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char NavigationStateKeepAliveHandle::Name_[] = …;

NavigationStateKeepAliveHandle::IPCStableHashFunction NavigationStateKeepAliveHandle::MessageToMethodInfo_(mojo::Message& message) { … }


const char* NavigationStateKeepAliveHandle::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
# endif // !BUILDFLAG(IS_FUCHSIA)

NavigationStateKeepAliveHandleProxy::NavigationStateKeepAliveHandleProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

// static
bool NavigationStateKeepAliveHandleStubDispatch::Accept(
    NavigationStateKeepAliveHandle* impl,
    mojo::Message* message) { … }

// static
bool NavigationStateKeepAliveHandleStubDispatch::AcceptWithResponder(
    NavigationStateKeepAliveHandle* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace

bool NavigationStateKeepAliveHandleRequestValidator::Accept(mojo::Message* message) { … }

const char RemoteFrameHost::Name_[] = …;

RemoteFrameHost::IPCStableHashFunction RemoteFrameHost::MessageToMethodInfo_(mojo::Message& message) { … }


const char* RemoteFrameHost::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t RemoteFrameHost::SetInheritedEffectiveTouchAction_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::UpdateRenderThrottlingStatus_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::VisibilityChanged_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::DidFocusFrame_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::CheckCompleted_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::CapturePaintPreviewOfCrossProcessSubframe_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::SetIsInert_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::DidChangeOpener_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::AdvanceFocus_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::RouteMessageEvent_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::PrintCrossProcessSubframe_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::Detach_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::UpdateViewportIntersection_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::SynchronizeVisualProperties_Sym::IPCStableHash() { … }
uint32_t RemoteFrameHost::OpenURL_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

RemoteFrameHostProxy::RemoteFrameHostProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void RemoteFrameHostProxy::SetInheritedEffectiveTouchAction(
    ::cc::TouchAction in_touch_action) { … }

void RemoteFrameHostProxy::UpdateRenderThrottlingStatus(
    bool in_is_throttled, bool in_subtree_throttled, bool in_display_locked) { … }

void RemoteFrameHostProxy::VisibilityChanged(
    ::blink::mojom::FrameVisibility in_visibility) { … }

void RemoteFrameHostProxy::DidFocusFrame(
    ) { … }

void RemoteFrameHostProxy::CheckCompleted(
    ) { … }

void RemoteFrameHostProxy::CapturePaintPreviewOfCrossProcessSubframe(
    const ::gfx::Rect& in_clip_rect, const ::base::UnguessableToken& in_guid) { … }

void RemoteFrameHostProxy::SetIsInert(
    bool in_inert) { … }

void RemoteFrameHostProxy::DidChangeOpener(
    const std::optional<::blink::LocalFrameToken>& in_opener_frame) { … }

void RemoteFrameHostProxy::AdvanceFocus(
    ::blink::mojom::FocusType in_focus_type, const ::blink::LocalFrameToken& in_source_frame_token) { … }

void RemoteFrameHostProxy::RouteMessageEvent(
    const std::optional<::blink::LocalFrameToken>& in_source_frame_token, const ::url::Origin& in_source_origin, const ::std::u16string& in_target_origin, ::blink::TransferableMessage in_message) { … }

void RemoteFrameHostProxy::PrintCrossProcessSubframe(
    const ::gfx::Rect& in_frame_content_rect, int32_t in_document_cookie) { … }

void RemoteFrameHostProxy::Detach(
    ) { … }

void RemoteFrameHostProxy::UpdateViewportIntersection(
    ::blink::mojom::ViewportIntersectionStatePtr in_intersection_state, const std::optional<::blink::FrameVisualProperties>& in_visual_properties) { … }

void RemoteFrameHostProxy::SynchronizeVisualProperties(
    const ::blink::FrameVisualProperties& in_properties) { … }

void RemoteFrameHostProxy::OpenURL(
    OpenURLParamsPtr in_params) { … }

// static
bool RemoteFrameHostStubDispatch::Accept(
    RemoteFrameHost* impl,
    mojo::Message* message) { … }

// static
bool RemoteFrameHostStubDispatch::AcceptWithResponder(
    RemoteFrameHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kRemoteFrameHostValidationInfo[] = …;

bool RemoteFrameHostRequestValidator::Accept(mojo::Message* message) { … }

const char RemoteFrame::Name_[] = …;

RemoteFrame::IPCStableHashFunction RemoteFrame::MessageToMethodInfo_(mojo::Message& message) { … }


const char* RemoteFrame::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t RemoteFrame::WillEnterFullscreen_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::EnforceInsecureNavigationsSet_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::SetFrameOwnerProperties_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::EnforceInsecureRequestPolicy_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::SetReplicatedOrigin_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::SetReplicatedIsAdFrame_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::SetReplicatedName_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::DispatchLoadEventForFrameOwner_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::SetNeedsOcclusionTracking_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::Collapse_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::Focus_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::SetHadStickyUserActivationBeforeNavigation_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::BubbleLogicalScroll_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::UpdateUserActivationState_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::SetEmbeddingToken_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::SetPageFocus_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::RenderFallbackContent_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::AddResourceTimingFromChild_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::ScrollRectToVisible_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::DidStartLoading_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::DidStopLoading_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::IntrinsicSizingInfoOfChildChanged_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::DidSetFramePolicyHeaders_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::DidUpdateFramePolicy_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::UpdateOpener_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::DetachAndDispose_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::EnableAutoResize_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::DisableAutoResize_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::DidUpdateVisualProperties_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::SetFrameSinkId_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::ChildProcessGone_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::CreateRemoteChild_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::CreateRemoteChildren_Sym::IPCStableHash() { … }
uint32_t RemoteFrame::ForwardFencedFrameEventToEmbedder_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

RemoteFrameProxy::RemoteFrameProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void RemoteFrameProxy::WillEnterFullscreen(
    ::blink::mojom::FullscreenOptionsPtr in_options) { … }

void RemoteFrameProxy::EnforceInsecureNavigationsSet(
    const std::vector<uint32_t>& in_set) { … }

void RemoteFrameProxy::SetFrameOwnerProperties(
    ::blink::mojom::FrameOwnerPropertiesPtr in_properties) { … }

void RemoteFrameProxy::EnforceInsecureRequestPolicy(
    ::blink::mojom::InsecureRequestPolicy in_policy) { … }

void RemoteFrameProxy::SetReplicatedOrigin(
    const ::url::Origin& in_origin, bool in_is_potentially_trustworthy_unique_origin) { … }

void RemoteFrameProxy::SetReplicatedIsAdFrame(
    bool in_is_ad_frame) { … }

void RemoteFrameProxy::SetReplicatedName(
    const std::string& in_name, const std::string& in_unique_name) { … }

void RemoteFrameProxy::DispatchLoadEventForFrameOwner(
    ) { … }

void RemoteFrameProxy::SetNeedsOcclusionTracking(
    bool in_needs_tracking) { … }

void RemoteFrameProxy::Collapse(
    bool in_collapsed) { … }

void RemoteFrameProxy::Focus(
    ) { … }

void RemoteFrameProxy::SetHadStickyUserActivationBeforeNavigation(
    bool in_has_gesture) { … }

void RemoteFrameProxy::BubbleLogicalScroll(
    ::blink::mojom::ScrollDirection in_direction, ::ui::ScrollGranularity in_granularity) { … }

void RemoteFrameProxy::UpdateUserActivationState(
    ::blink::mojom::UserActivationUpdateType in_state_update_type, ::blink::mojom::UserActivationNotificationType in_notification_type) { … }

void RemoteFrameProxy::SetEmbeddingToken(
    const ::base::UnguessableToken& in_embedding_token) { … }

void RemoteFrameProxy::SetPageFocus(
    bool in_is_focused) { … }

void RemoteFrameProxy::RenderFallbackContent(
    ) { … }

void RemoteFrameProxy::AddResourceTimingFromChild(
    ::blink::mojom::ResourceTimingInfoPtr in_timing) { … }

void RemoteFrameProxy::ScrollRectToVisible(
    const ::gfx::RectF& in_rect, ::blink::mojom::ScrollIntoViewParamsPtr in_params) { … }

void RemoteFrameProxy::DidStartLoading(
    ) { … }

void RemoteFrameProxy::DidStopLoading(
    ) { … }

void RemoteFrameProxy::IntrinsicSizingInfoOfChildChanged(
    ::blink::mojom::IntrinsicSizingInfoPtr in_sizing_info) { … }

void RemoteFrameProxy::DidSetFramePolicyHeaders(
    ::network::mojom::WebSandboxFlags in_sandbox_flags, const std::vector<::blink::ParsedPermissionsPolicyDeclaration>& in_parsed_permissions_policy) { … }

void RemoteFrameProxy::DidUpdateFramePolicy(
    const ::blink::FramePolicy& in_frame_policy) { … }

void RemoteFrameProxy::UpdateOpener(
    const std::optional<::blink::FrameToken>& in_opener_frame_token) { … }

void RemoteFrameProxy::DetachAndDispose(
    ) { … }

void RemoteFrameProxy::EnableAutoResize(
    const ::gfx::Size& in_min_size, const ::gfx::Size& in_max_size) { … }

void RemoteFrameProxy::DisableAutoResize(
    ) { … }

void RemoteFrameProxy::DidUpdateVisualProperties(
    const ::cc::RenderFrameMetadata& in_metadata) { … }

void RemoteFrameProxy::SetFrameSinkId(
    const ::viz::FrameSinkId& in_frame_sink_id, bool in_allow_paint_holding) { … }

void RemoteFrameProxy::ChildProcessGone(
    ) { … }

void RemoteFrameProxy::CreateRemoteChild(
    const ::blink::RemoteFrameToken& in_token, const std::optional<::blink::FrameToken>& in_opener_frame_token, ::blink::mojom::TreeScopeType in_tree_scope_type, ::blink::mojom::FrameReplicationStatePtr in_replication_state, ::blink::mojom::FrameOwnerPropertiesPtr in_owner_properties, bool in_is_loading, const ::base::UnguessableToken& in_devtools_frame_token, RemoteFrameInterfacesFromBrowserPtr in_remote_frame_interfaces) { … }

void RemoteFrameProxy::CreateRemoteChildren(
    std::vector<CreateRemoteChildParamsPtr> in_params) { … }

void RemoteFrameProxy::ForwardFencedFrameEventToEmbedder(
    const std::string& in_event_type) { … }

// static
bool RemoteFrameStubDispatch::Accept(
    RemoteFrame* impl,
    mojo::Message* message) { … }

// static
bool RemoteFrameStubDispatch::AcceptWithResponder(
    RemoteFrame* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kRemoteFrameValidationInfo[] = …;

bool RemoteFrameRequestValidator::Accept(mojo::Message* message) { … }

const char RemoteMainFrame::Name_[] = …;

RemoteMainFrame::IPCStableHashFunction RemoteMainFrame::MessageToMethodInfo_(mojo::Message& message) { … }


const char* RemoteMainFrame::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t RemoteMainFrame::UpdateTextAutosizerPageInfo_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

RemoteMainFrameProxy::RemoteMainFrameProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void RemoteMainFrameProxy::UpdateTextAutosizerPageInfo(
    ::blink::mojom::TextAutosizerPageInfoPtr in_page_info) { … }

// static
bool RemoteMainFrameStubDispatch::Accept(
    RemoteMainFrame* impl,
    mojo::Message* message) { … }

// static
bool RemoteMainFrameStubDispatch::AcceptWithResponder(
    RemoteMainFrame* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kRemoteMainFrameValidationInfo[] = …;

bool RemoteMainFrameRequestValidator::Accept(mojo::Message* message) { … }

const char RemoteMainFrameHost::Name_[] = …;

RemoteMainFrameHost::IPCStableHashFunction RemoteMainFrameHost::MessageToMethodInfo_(mojo::Message& message) { … }


const char* RemoteMainFrameHost::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t RemoteMainFrameHost::FocusPage_Sym::IPCStableHash() { … }
uint32_t RemoteMainFrameHost::TakeFocus_Sym::IPCStableHash() { … }
uint32_t RemoteMainFrameHost::UpdateTargetURL_Sym::IPCStableHash() { … }
uint32_t RemoteMainFrameHost::RouteCloseEvent_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class RemoteMainFrameHost_UpdateTargetURL_ForwardToCallback
    : public mojo::MessageReceiver { … };

RemoteMainFrameHostProxy::RemoteMainFrameHostProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void RemoteMainFrameHostProxy::FocusPage(
    ) { … }

void RemoteMainFrameHostProxy::TakeFocus(
    bool in_reverse) { … }

void RemoteMainFrameHostProxy::UpdateTargetURL(
    const ::GURL& in_url, UpdateTargetURLCallback callback) { … }

void RemoteMainFrameHostProxy::RouteCloseEvent(
    ) { … }
class RemoteMainFrameHost_UpdateTargetURL_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

bool RemoteMainFrameHost_UpdateTargetURL_ForwardToCallback::Accept(
    mojo::Message* message) { … }

void RemoteMainFrameHost_UpdateTargetURL_ProxyToResponder::Run(
    ) { … }

// static
bool RemoteMainFrameHostStubDispatch::Accept(
    RemoteMainFrameHost* impl,
    mojo::Message* message) { … }

// static
bool RemoteMainFrameHostStubDispatch::AcceptWithResponder(
    RemoteMainFrameHost* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kRemoteMainFrameHostValidationInfo[] = …;

bool RemoteMainFrameHostRequestValidator::Accept(mojo::Message* message) { … }

bool RemoteMainFrameHostResponseValidator::Accept(mojo::Message* message) { … }


}  // blink::mojom


namespace mojo {


// static
bool StructTraits<::blink::mojom::RemoteMainFrameInterfaces::DataView, ::blink::mojom::RemoteMainFrameInterfacesPtr>::Read(
    ::blink::mojom::RemoteMainFrameInterfaces::DataView input,
    ::blink::mojom::RemoteMainFrameInterfacesPtr* output) { … }


// static
bool StructTraits<::blink::mojom::RemoteFrameInterfacesFromRenderer::DataView, ::blink::mojom::RemoteFrameInterfacesFromRendererPtr>::Read(
    ::blink::mojom::RemoteFrameInterfacesFromRenderer::DataView input,
    ::blink::mojom::RemoteFrameInterfacesFromRendererPtr* output) { … }


// static
bool StructTraits<::blink::mojom::RemoteFrameInterfacesFromBrowser::DataView, ::blink::mojom::RemoteFrameInterfacesFromBrowserPtr>::Read(
    ::blink::mojom::RemoteFrameInterfacesFromBrowser::DataView input,
    ::blink::mojom::RemoteFrameInterfacesFromBrowserPtr* output) { … }


// static
bool StructTraits<::blink::mojom::CreateRemoteChildParams::DataView, ::blink::mojom::CreateRemoteChildParamsPtr>::Read(
    ::blink::mojom::CreateRemoteChildParams::DataView input,
    ::blink::mojom::CreateRemoteChildParamsPtr* output) { … }


// static
bool StructTraits<::blink::mojom::OpenURLParams::DataView, ::blink::mojom::OpenURLParamsPtr>::Read(
    ::blink::mojom::OpenURLParams::DataView input,
    ::blink::mojom::OpenURLParamsPtr* output) { … }

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace blink::mojom {


NavigationStateKeepAliveHandleAsyncWaiter::NavigationStateKeepAliveHandleAsyncWaiter(
    NavigationStateKeepAliveHandle* proxy) : … { … }

NavigationStateKeepAliveHandleAsyncWaiter::~NavigationStateKeepAliveHandleAsyncWaiter() = default;




void RemoteFrameHostInterceptorForTesting::SetInheritedEffectiveTouchAction(::cc::TouchAction touch_action) { … }
void RemoteFrameHostInterceptorForTesting::UpdateRenderThrottlingStatus(bool is_throttled, bool subtree_throttled, bool display_locked) { … }
void RemoteFrameHostInterceptorForTesting::VisibilityChanged(::blink::mojom::FrameVisibility visibility) { … }
void RemoteFrameHostInterceptorForTesting::DidFocusFrame() { … }
void RemoteFrameHostInterceptorForTesting::CheckCompleted() { … }
void RemoteFrameHostInterceptorForTesting::CapturePaintPreviewOfCrossProcessSubframe(const ::gfx::Rect& clip_rect, const ::base::UnguessableToken& guid) { … }
void RemoteFrameHostInterceptorForTesting::SetIsInert(bool inert) { … }
void RemoteFrameHostInterceptorForTesting::DidChangeOpener(const std::optional<::blink::LocalFrameToken>& opener_frame) { … }
void RemoteFrameHostInterceptorForTesting::AdvanceFocus(::blink::mojom::FocusType focus_type, const ::blink::LocalFrameToken& source_frame_token) { … }
void RemoteFrameHostInterceptorForTesting::RouteMessageEvent(const std::optional<::blink::LocalFrameToken>& source_frame_token, const ::url::Origin& source_origin, const ::std::u16string& target_origin, ::blink::TransferableMessage message) { … }
void RemoteFrameHostInterceptorForTesting::PrintCrossProcessSubframe(const ::gfx::Rect& frame_content_rect, int32_t document_cookie) { … }
void RemoteFrameHostInterceptorForTesting::Detach() { … }
void RemoteFrameHostInterceptorForTesting::UpdateViewportIntersection(::blink::mojom::ViewportIntersectionStatePtr intersection_state, const std::optional<::blink::FrameVisualProperties>& visual_properties) { … }
void RemoteFrameHostInterceptorForTesting::SynchronizeVisualProperties(const ::blink::FrameVisualProperties& properties) { … }
void RemoteFrameHostInterceptorForTesting::OpenURL(OpenURLParamsPtr params) { … }
RemoteFrameHostAsyncWaiter::RemoteFrameHostAsyncWaiter(
    RemoteFrameHost* proxy) : … { … }

RemoteFrameHostAsyncWaiter::~RemoteFrameHostAsyncWaiter() = default;




void RemoteFrameInterceptorForTesting::WillEnterFullscreen(::blink::mojom::FullscreenOptionsPtr options) { … }
void RemoteFrameInterceptorForTesting::EnforceInsecureNavigationsSet(const std::vector<uint32_t>& set) { … }
void RemoteFrameInterceptorForTesting::SetFrameOwnerProperties(::blink::mojom::FrameOwnerPropertiesPtr properties) { … }
void RemoteFrameInterceptorForTesting::EnforceInsecureRequestPolicy(::blink::mojom::InsecureRequestPolicy policy) { … }
void RemoteFrameInterceptorForTesting::SetReplicatedOrigin(const ::url::Origin& origin, bool is_potentially_trustworthy_unique_origin) { … }
void RemoteFrameInterceptorForTesting::SetReplicatedIsAdFrame(bool is_ad_frame) { … }
void RemoteFrameInterceptorForTesting::SetReplicatedName(const std::string& name, const std::string& unique_name) { … }
void RemoteFrameInterceptorForTesting::DispatchLoadEventForFrameOwner() { … }
void RemoteFrameInterceptorForTesting::SetNeedsOcclusionTracking(bool needs_tracking) { … }
void RemoteFrameInterceptorForTesting::Collapse(bool collapsed) { … }
void RemoteFrameInterceptorForTesting::Focus() { … }
void RemoteFrameInterceptorForTesting::SetHadStickyUserActivationBeforeNavigation(bool has_gesture) { … }
void RemoteFrameInterceptorForTesting::BubbleLogicalScroll(::blink::mojom::ScrollDirection direction, ::ui::ScrollGranularity granularity) { … }
void RemoteFrameInterceptorForTesting::UpdateUserActivationState(::blink::mojom::UserActivationUpdateType state_update_type, ::blink::mojom::UserActivationNotificationType notification_type) { … }
void RemoteFrameInterceptorForTesting::SetEmbeddingToken(const ::base::UnguessableToken& embedding_token) { … }
void RemoteFrameInterceptorForTesting::SetPageFocus(bool is_focused) { … }
void RemoteFrameInterceptorForTesting::RenderFallbackContent() { … }
void RemoteFrameInterceptorForTesting::AddResourceTimingFromChild(::blink::mojom::ResourceTimingInfoPtr timing) { … }
void RemoteFrameInterceptorForTesting::ScrollRectToVisible(const ::gfx::RectF& rect, ::blink::mojom::ScrollIntoViewParamsPtr params) { … }
void RemoteFrameInterceptorForTesting::DidStartLoading() { … }
void RemoteFrameInterceptorForTesting::DidStopLoading() { … }
void RemoteFrameInterceptorForTesting::IntrinsicSizingInfoOfChildChanged(::blink::mojom::IntrinsicSizingInfoPtr sizing_info) { … }
void RemoteFrameInterceptorForTesting::DidSetFramePolicyHeaders(::network::mojom::WebSandboxFlags sandbox_flags, const std::vector<::blink::ParsedPermissionsPolicyDeclaration>& parsed_permissions_policy) { … }
void RemoteFrameInterceptorForTesting::DidUpdateFramePolicy(const ::blink::FramePolicy& frame_policy) { … }
void RemoteFrameInterceptorForTesting::UpdateOpener(const std::optional<::blink::FrameToken>& opener_frame_token) { … }
void RemoteFrameInterceptorForTesting::DetachAndDispose() { … }
void RemoteFrameInterceptorForTesting::EnableAutoResize(const ::gfx::Size& min_size, const ::gfx::Size& max_size) { … }
void RemoteFrameInterceptorForTesting::DisableAutoResize() { … }
void RemoteFrameInterceptorForTesting::DidUpdateVisualProperties(const ::cc::RenderFrameMetadata& metadata) { … }
void RemoteFrameInterceptorForTesting::SetFrameSinkId(const ::viz::FrameSinkId& frame_sink_id, bool allow_paint_holding) { … }
void RemoteFrameInterceptorForTesting::ChildProcessGone() { … }
void RemoteFrameInterceptorForTesting::CreateRemoteChild(const ::blink::RemoteFrameToken& token, const std::optional<::blink::FrameToken>& opener_frame_token, ::blink::mojom::TreeScopeType tree_scope_type, ::blink::mojom::FrameReplicationStatePtr replication_state, ::blink::mojom::FrameOwnerPropertiesPtr owner_properties, bool is_loading, const ::base::UnguessableToken& devtools_frame_token, RemoteFrameInterfacesFromBrowserPtr remote_frame_interfaces) { … }
void RemoteFrameInterceptorForTesting::CreateRemoteChildren(std::vector<CreateRemoteChildParamsPtr> params) { … }
void RemoteFrameInterceptorForTesting::ForwardFencedFrameEventToEmbedder(const std::string& event_type) { … }
RemoteFrameAsyncWaiter::RemoteFrameAsyncWaiter(
    RemoteFrame* proxy) : … { … }

RemoteFrameAsyncWaiter::~RemoteFrameAsyncWaiter() = default;




void RemoteMainFrameInterceptorForTesting::UpdateTextAutosizerPageInfo(::blink::mojom::TextAutosizerPageInfoPtr page_info) { … }
RemoteMainFrameAsyncWaiter::RemoteMainFrameAsyncWaiter(
    RemoteMainFrame* proxy) : … { … }

RemoteMainFrameAsyncWaiter::~RemoteMainFrameAsyncWaiter() = default;




void RemoteMainFrameHostInterceptorForTesting::FocusPage() { … }
void RemoteMainFrameHostInterceptorForTesting::TakeFocus(bool reverse) { … }
void RemoteMainFrameHostInterceptorForTesting::UpdateTargetURL(const ::GURL& url, UpdateTargetURLCallback callback) { … }
void RemoteMainFrameHostInterceptorForTesting::RouteCloseEvent() { … }
RemoteMainFrameHostAsyncWaiter::RemoteMainFrameHostAsyncWaiter(
    RemoteMainFrameHost* proxy) : … { … }

RemoteMainFrameHostAsyncWaiter::~RemoteMainFrameHostAsyncWaiter() = default;

void RemoteMainFrameHostAsyncWaiter::UpdateTargetURL(
    const ::GURL& url) { … }








}  // blink::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/third_party/blink/public/mojom/frame/remote_frame.mojom.cc
