vr_service.mojom.cc | Explore in Territory

// device/vr/public/mojom/vr_service.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 "device/vr/public/mojom/vr_service.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 "device/vr/public/mojom/vr_service.mojom-params-data.h"
#include "device/vr/public/mojom/vr_service.mojom-shared-message-ids.h"

#include "device/vr/public/mojom/vr_service.mojom-import-headers.h"
#include "device/vr/public/mojom/vr_service.mojom-test-utils.h"


namespace device::mojom {
constexpr uint64_t XRCubeMap::kNumComponentsPerPixel;
XRDepthConfig::XRDepthConfig()
    : … { … }

XRDepthConfig::XRDepthConfig(
    ::device::mojom::XRDepthUsage depth_usage_in,
    ::device::mojom::XRDepthDataFormat depth_data_format_in)
    : … { … }

XRDepthConfig::~XRDepthConfig() = default;
size_t XRDepthConfig::Hash(size_t seed) const { … }

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

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

XRSessionDeviceConfig::XRSessionDeviceConfig(
    float default_framebuffer_scale_in,
    std::vector<XRViewPtr> views_in,
    bool supports_viewport_scaling_in,
    bool enable_anti_aliasing_in,
    XRDepthConfigPtr depth_configuration_in)
    : … { … }

XRSessionDeviceConfig::~XRSessionDeviceConfig() = default;

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

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

XRSession::XRSession(
    ::mojo::PendingRemote<XRFrameDataProvider> data_provider_in,
    ::mojo::PendingReceiver<XRSessionClient> client_receiver_in,
    XRPresentationConnectionPtr submit_frame_sink_in,
    std::vector<::device::mojom::XRSessionFeature> enabled_features_in,
    XRSessionDeviceConfigPtr device_config_in,
    XREnvironmentBlendMode enviroment_blend_mode_in,
    XRInteractionMode interaction_mode_in)
    : … { … }

XRSession::~XRSession() = default;

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

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

XRPresentationConnection::XRPresentationConnection(
    ::mojo::PendingRemote<XRPresentationProvider> provider_in,
    ::mojo::PendingReceiver<XRPresentationClient> client_receiver_in,
    XRPresentationTransportOptionsPtr transport_options_in)
    : … { … }

XRPresentationConnection::~XRPresentationConnection() = default;

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

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

XRInputSourceDescription::XRInputSourceDescription(
    XRTargetRayMode target_ray_mode_in,
    XRHandedness handedness_in,
    const std::optional<::gfx::Transform>& input_from_pointer_in,
    std::vector<std::string> profiles_in)
    : … { … }

XRInputSourceDescription::~XRInputSourceDescription() = default;

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

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

XRHandJointData::XRHandJointData(
    XRHandJoint joint_in,
    const std::optional<::gfx::Transform>& mojo_from_joint_in,
    float radius_in)
    : … { … }

XRHandJointData::~XRHandJointData() = default;

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

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

XRHandTrackingData::XRHandTrackingData(
    std::vector<XRHandJointDataPtr> hand_joint_data_in)
    : … { … }

XRHandTrackingData::~XRHandTrackingData() = default;

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

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

XRInputSourceState::XRInputSourceState(
    uint32_t source_id_in,
    XRInputSourceDescriptionPtr description_in,
    const std::optional<::gfx::Transform>& mojo_from_input_in,
    bool emulated_position_in,
    bool is_auxiliary_in,
    bool primary_input_pressed_in,
    bool primary_input_clicked_in,
    bool primary_squeeze_pressed_in,
    bool primary_squeeze_clicked_in,
    const std::optional<::device::Gamepad>& gamepad_in,
    const std::optional<::gfx::PointF>& overlay_pointer_position_in,
    XRHandTrackingDataPtr hand_tracking_data_in)
    : … { … }

XRInputSourceState::~XRInputSourceState() = default;

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

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

VRFieldOfView::VRFieldOfView(
    float up_degrees_in,
    float down_degrees_in,
    float left_degrees_in,
    float right_degrees_in)
    : … { … }

VRFieldOfView::~VRFieldOfView() = default;
size_t VRFieldOfView::Hash(size_t seed) const { … }

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

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

VRPose::VRPose(
    const std::optional<::gfx::Quaternion>& orientation_in,
    const std::optional<::gfx::Point3F>& position_in,
    bool emulated_position_in)
    : … { … }

VRPose::~VRPose() = default;

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

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

Pose::Pose(
    const ::gfx::Quaternion& orientation_in,
    const ::gfx::Point3F& position_in)
    : … { … }

Pose::~Pose() = default;

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

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

XRRay::XRRay(
    const ::gfx::Point3F& origin_in,
    const ::gfx::Vector3dF& direction_in)
    : … { … }

XRRay::~XRRay() = default;

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

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

XRHitResult::XRHitResult(
    const ::device::Pose& mojo_from_result_in,
    uint64_t plane_id_in)
    : … { … }

XRHitResult::~XRHitResult() = default;

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

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

XRView::XRView(
    XREye eye_in,
    VRFieldOfViewPtr field_of_view_in,
    const ::gfx::Transform& mojo_from_view_in,
    const ::gfx::Rect& viewport_in,
    XRDepthDataPtr depth_data_in,
    bool is_first_person_observer_in)
    : … { … }

XRView::~XRView() = default;

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

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

VRStageParameters::VRStageParameters(
    const ::gfx::Transform& mojo_from_floor_in,
    std::optional<std::vector<::gfx::Point3F>> bounds_in)
    : … { … }

VRStageParameters::~VRStageParameters() = default;

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

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

XRPresentationTransportOptions::XRPresentationTransportOptions(
    XRPresentationTransportMethod transport_method_in,
    bool wait_for_transfer_notification_in,
    bool wait_for_render_notification_in,
    bool wait_for_gpu_fence_in)
    : … { … }

XRPresentationTransportOptions::~XRPresentationTransportOptions() = default;
size_t XRPresentationTransportOptions::Hash(size_t seed) const { … }

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

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

XRInputSourceSpaceInfo::XRInputSourceSpaceInfo(
    uint32_t input_source_id_in,
    XRInputSourceSpaceType input_source_space_type_in)
    : … { … }

XRInputSourceSpaceInfo::~XRInputSourceSpaceInfo() = default;
size_t XRInputSourceSpaceInfo::Hash(size_t seed) const { … }

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

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

XRHandJointSpaceInfo::XRHandJointSpaceInfo(
    XRHandedness handedness_in,
    XRHandJoint joint_in)
    : … { … }

XRHandJointSpaceInfo::~XRHandJointSpaceInfo() = default;
size_t XRHandJointSpaceInfo::Hash(size_t seed) const { … }

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

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

XRPlanePointData::XRPlanePointData(
    float x_in,
    float z_in)
    : … { … }

XRPlanePointData::~XRPlanePointData() = default;
size_t XRPlanePointData::Hash(size_t seed) const { … }

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

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

XRPlaneData::XRPlaneData(
    uint64_t id_in,
    XRPlaneOrientation orientation_in,
    const std::optional<::device::Pose>& mojo_from_plane_in,
    std::vector<XRPlanePointDataPtr> polygon_in)
    : … { … }

XRPlaneData::~XRPlaneData() = default;

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

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

XRPlaneDetectionData::XRPlaneDetectionData(
    std::vector<uint64_t> all_planes_ids_in,
    std::vector<XRPlaneDataPtr> updated_planes_data_in)
    : … { … }

XRPlaneDetectionData::~XRPlaneDetectionData() = default;

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

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

XRAnchorData::XRAnchorData(
    uint64_t id_in,
    const std::optional<::device::Pose>& mojo_from_anchor_in)
    : … { … }

XRAnchorData::~XRAnchorData() = default;

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

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

XRAnchorsData::XRAnchorsData(
    std::vector<uint64_t> all_anchors_ids_in,
    std::vector<XRAnchorDataPtr> updated_anchors_data_in)
    : … { … }

XRAnchorsData::~XRAnchorsData() = default;

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

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

XRHitTestSubscriptionResultData::XRHitTestSubscriptionResultData(
    uint64_t subscription_id_in,
    std::vector<XRHitResultPtr> hit_test_results_in)
    : … { … }

XRHitTestSubscriptionResultData::~XRHitTestSubscriptionResultData() = default;

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

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

XRHitTestTransientInputSubscriptionResultData::XRHitTestTransientInputSubscriptionResultData(
    uint64_t subscription_id_in,
    base::flat_map<uint32_t, std::vector<XRHitResultPtr>> input_source_id_to_hit_test_results_in)
    : … { … }

XRHitTestTransientInputSubscriptionResultData::~XRHitTestTransientInputSubscriptionResultData() = default;

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

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

XRHitTestSubscriptionResultsData::XRHitTestSubscriptionResultsData(
    std::vector<XRHitTestSubscriptionResultDataPtr> results_in,
    std::vector<XRHitTestTransientInputSubscriptionResultDataPtr> transient_input_results_in)
    : … { … }

XRHitTestSubscriptionResultsData::~XRHitTestSubscriptionResultsData() = default;

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

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

RgbTupleF32::RgbTupleF32(
    float red_in,
    float green_in,
    float blue_in)
    : … { … }

RgbTupleF32::~RgbTupleF32() = default;

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

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

XRSphericalHarmonics::XRSphericalHarmonics(
    std::vector<::device::RgbTupleF32> coefficients_in)
    : … { … }

XRSphericalHarmonics::~XRSphericalHarmonics() = default;

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

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

RgbaTupleF16::RgbaTupleF16(
    uint16_t red_in,
    uint16_t green_in,
    uint16_t blue_in,
    uint16_t alpha_in)
    : … { … }

RgbaTupleF16::~RgbaTupleF16() = default;

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

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

XRCubeMap::XRCubeMap(
    uint32_t width_and_height_in,
    std::vector<::device::RgbaTupleF16> positive_x_in,
    std::vector<::device::RgbaTupleF16> negative_x_in,
    std::vector<::device::RgbaTupleF16> positive_y_in,
    std::vector<::device::RgbaTupleF16> negative_y_in,
    std::vector<::device::RgbaTupleF16> positive_z_in,
    std::vector<::device::RgbaTupleF16> negative_z_in)
    : … { … }

XRCubeMap::~XRCubeMap() = default;

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

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

XRLightProbe::XRLightProbe(
    XRSphericalHarmonicsPtr spherical_harmonics_in,
    const ::gfx::Vector3dF& main_light_direction_in,
    const ::device::RgbTupleF32& main_light_intensity_in)
    : … { … }

XRLightProbe::~XRLightProbe() = default;

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

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

XRReflectionProbe::XRReflectionProbe(
    XRCubeMapPtr cube_map_in)
    : … { … }

XRReflectionProbe::~XRReflectionProbe() = default;

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

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

XRLightEstimationData::XRLightEstimationData(
    XRLightProbePtr light_probe_in,
    XRReflectionProbePtr reflection_probe_in)
    : … { … }

XRLightEstimationData::~XRLightEstimationData() = default;

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

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

XRDepthDataStillValid::~XRDepthDataStillValid() = default;
size_t XRDepthDataStillValid::Hash(size_t seed) const { … }

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

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

XRDepthDataUpdated::XRDepthDataUpdated(
    ::mojo_base::BigBuffer pixel_data_in,
    const ::gfx::Transform& norm_texture_from_norm_view_in,
    const ::gfx::Size& size_in,
    float raw_value_to_meters_in)
    : … { … }

XRDepthDataUpdated::~XRDepthDataUpdated() = default;

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

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

XRTrackedImageData::XRTrackedImageData(
    uint32_t index_in,
    const ::device::Pose& mojo_from_image_in,
    bool actively_tracked_in,
    float width_in_meters_in)
    : … { … }

XRTrackedImageData::~XRTrackedImageData() = default;

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

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

XRTrackedImagesData::XRTrackedImagesData(
    std::vector<XRTrackedImageDataPtr> images_data_in,
    std::optional<std::vector<bool>> image_trackable_scores_in)
    : … { … }

XRTrackedImagesData::~XRTrackedImagesData() = default;

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

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

XRFrameData::XRFrameData(
    VRPosePtr mojo_from_viewer_in,
    ::base::TimeDelta time_delta_in,
    const std::optional<::gpu::ExportedSharedImage>& buffer_shared_image_in,
    const std::optional<::gpu::SyncToken>& buffer_sync_token_in,
    const std::optional<::gpu::ExportedSharedImage>& camera_image_buffer_shared_image_in,
    const std::optional<::gpu::SyncToken>& camera_image_buffer_sync_token_in,
    const std::optional<::gfx::Size>& camera_image_size_in,
    bool mojo_space_reset_in,
    int16_t frame_id_in,
    std::vector<XRViewPtr> views_in,
    std::optional<std::vector<XRInputSourceStatePtr>> input_state_in,
    uint32_t stage_parameters_id_in,
    VRStageParametersPtr stage_parameters_in,
    XRPlaneDetectionDataPtr detected_planes_data_in,
    XRAnchorsDataPtr anchors_data_in,
    XRLightEstimationDataPtr light_estimation_data_in,
    XRHitTestSubscriptionResultsDataPtr hit_test_subscription_results_in,
    float rendering_time_ratio_in,
    XRTrackedImagesDataPtr tracked_images_in)
    : … { … }

XRFrameData::~XRFrameData() = default;

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

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

RequestSessionSuccess::RequestSessionSuccess(
    XRSessionPtr session_in,
    uint64_t trace_id_in,
    ::mojo::PendingRemote<XRSessionMetricsRecorder> metrics_recorder_in,
    ::mojo::PendingRemote<WebXrInternalsRendererListener> xr_internals_listener_in)
    : … { … }

RequestSessionSuccess::~RequestSessionSuccess() = default;

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

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

XRFrameDataRequestOptions::XRFrameDataRequestOptions(
    bool include_lighting_estimation_data_in,
    uint32_t stage_parameters_id_in)
    : … { … }

XRFrameDataRequestOptions::~XRFrameDataRequestOptions() = default;
size_t XRFrameDataRequestOptions::Hash(size_t seed) const { … }

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

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

XRNativeOriginInformation::~XRNativeOriginInformation() { … }


void XRNativeOriginInformation::set_input_source_space_info(
    XRInputSourceSpaceInfoPtr input_source_space_info) { … }
void XRNativeOriginInformation::set_plane_id(
    uint64_t plane_id) { … }
void XRNativeOriginInformation::set_anchor_id(
    uint64_t anchor_id) { … }
void XRNativeOriginInformation::set_reference_space_type(
    XRReferenceSpaceType reference_space_type) { … }
void XRNativeOriginInformation::set_hand_joint_space_info(
    XRHandJointSpaceInfoPtr hand_joint_space_info) { … }
void XRNativeOriginInformation::set_image_index(
    uint32_t image_index) { … }

void XRNativeOriginInformation::DestroyActive() { … }
size_t XRNativeOriginInformation::Hash(size_t seed) const { … }

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

XRDepthData::~XRDepthData() { … }


void XRDepthData::set_data_still_valid(
    XRDepthDataStillValidPtr data_still_valid) { … }
void XRDepthData::set_updated_depth_data(
    XRDepthDataUpdatedPtr updated_depth_data) { … }

void XRDepthData::DestroyActive() { … }

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

RequestSessionResult::~RequestSessionResult() { … }


void RequestSessionResult::set_success(
    RequestSessionSuccessPtr success) { … }
void RequestSessionResult::set_failure_reason(
    ::device::mojom::RequestSessionError failure_reason) { … }

void RequestSessionResult::DestroyActive() { … }

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

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t VRService::SetClient_Sym::IPCStableHash() { … }
uint32_t VRService::RequestSession_Sym::IPCStableHash() { … }
uint32_t VRService::SupportsSession_Sym::IPCStableHash() { … }
uint32_t VRService::ExitPresent_Sym::IPCStableHash() { … }
uint32_t VRService::SetFramesThrottled_Sym::IPCStableHash() { … }
uint32_t VRService::MakeXrCompatible_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)
bool VRService::MakeXrCompatible(XrCompatibleResult* out_xr_compatible_result) { … }

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

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

class VRService_ExitPresent_ForwardToCallback
    : public mojo::MessageReceiver { … };
class VRService_MakeXrCompatible_HandleSyncResponse
    : public mojo::MessageReceiver { … };

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

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

void VRServiceProxy::SetClient(
    ::mojo::PendingRemote<VRServiceClient> in_client) { … }

void VRServiceProxy::RequestSession(
    ::device::mojom::XRSessionOptionsPtr in_options, RequestSessionCallback callback) { … }

void VRServiceProxy::SupportsSession(
    ::device::mojom::XRSessionOptionsPtr in_options, SupportsSessionCallback callback) { … }

void VRServiceProxy::ExitPresent(
    ExitPresentCallback callback) { … }

void VRServiceProxy::SetFramesThrottled(
    bool in_throttled) { … }
bool VRServiceProxy::MakeXrCompatible(
    XrCompatibleResult* out_param_xr_compatible_result) { … }

void VRServiceProxy::MakeXrCompatible(
    MakeXrCompatibleCallback callback) { … }
class VRService_RequestSession_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void VRService_RequestSession_ProxyToResponder::Run(
    RequestSessionResultPtr in_result) { … }
class VRService_SupportsSession_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void VRService_SupportsSession_ProxyToResponder::Run(
    bool in_supports_session) { … }
class VRService_ExitPresent_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void VRService_ExitPresent_ProxyToResponder::Run(
    ) { … }
class VRService_MakeXrCompatible_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void VRService_MakeXrCompatible_ProxyToResponder::Run(
    XrCompatibleResult in_xr_compatible_result) { … }
bool VRService_MakeXrCompatible_HandleSyncResponse::Accept(
    mojo::Message* message) { … }

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

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

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

bool VRServiceResponseValidator::Accept(mojo::Message* message) { … }
const char XRSessionMetricsRecorder::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XRSessionMetricsRecorder::ReportFeatureUsed_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void XRSessionMetricsRecorderProxy::ReportFeatureUsed(
    ::device::mojom::XRSessionFeature in_feature) { … }

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

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

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

const char VRServiceClient::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t VRServiceClient::OnDeviceChanged_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void VRServiceClientProxy::OnDeviceChanged(
    ) { … }

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

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

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

const char XREnvironmentIntegrationProvider::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XREnvironmentIntegrationProvider::SubscribeToHitTest_Sym::IPCStableHash() { … }
uint32_t XREnvironmentIntegrationProvider::SubscribeToHitTestForTransientInput_Sym::IPCStableHash() { … }
uint32_t XREnvironmentIntegrationProvider::UnsubscribeFromHitTest_Sym::IPCStableHash() { … }
uint32_t XREnvironmentIntegrationProvider::CreateAnchor_Sym::IPCStableHash() { … }
uint32_t XREnvironmentIntegrationProvider::CreatePlaneAnchor_Sym::IPCStableHash() { … }
uint32_t XREnvironmentIntegrationProvider::DetachAnchor_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

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

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

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

void XREnvironmentIntegrationProviderProxy::SubscribeToHitTest(
    XRNativeOriginInformationPtr in_native_origin_information, const std::vector<EntityTypeForHitTest>& in_entity_types, XRRayPtr in_ray, SubscribeToHitTestCallback callback) { … }

void XREnvironmentIntegrationProviderProxy::SubscribeToHitTestForTransientInput(
    const std::string& in_profile_name, const std::vector<EntityTypeForHitTest>& in_entity_types, XRRayPtr in_ray, SubscribeToHitTestForTransientInputCallback callback) { … }

void XREnvironmentIntegrationProviderProxy::UnsubscribeFromHitTest(
    uint64_t in_subscription_id) { … }

void XREnvironmentIntegrationProviderProxy::CreateAnchor(
    XRNativeOriginInformationPtr in_native_origin_information, const ::device::Pose& in_native_origin_from_anchor, CreateAnchorCallback callback) { … }

void XREnvironmentIntegrationProviderProxy::CreatePlaneAnchor(
    XRNativeOriginInformationPtr in_native_origin_information, const ::device::Pose& in_native_origin_from_anchor, uint64_t in_plane_id, CreatePlaneAnchorCallback callback) { … }

void XREnvironmentIntegrationProviderProxy::DetachAnchor(
    uint64_t in_anchor_id) { … }
class XREnvironmentIntegrationProvider_SubscribeToHitTest_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void XREnvironmentIntegrationProvider_SubscribeToHitTest_ProxyToResponder::Run(
    SubscribeToHitTestResult in_result, uint64_t in_subscription_id) { … }
class XREnvironmentIntegrationProvider_SubscribeToHitTestForTransientInput_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void XREnvironmentIntegrationProvider_SubscribeToHitTestForTransientInput_ProxyToResponder::Run(
    SubscribeToHitTestResult in_result, uint64_t in_subscription_id) { … }
class XREnvironmentIntegrationProvider_CreateAnchor_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void XREnvironmentIntegrationProvider_CreateAnchor_ProxyToResponder::Run(
    CreateAnchorResult in_result, uint64_t in_anchor_id) { … }
class XREnvironmentIntegrationProvider_CreatePlaneAnchor_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void XREnvironmentIntegrationProvider_CreatePlaneAnchor_ProxyToResponder::Run(
    CreateAnchorResult in_result, uint64_t in_anchor_id) { … }

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

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

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

bool XREnvironmentIntegrationProviderResponseValidator::Accept(mojo::Message* message) { … }
const char XRFrameDataProvider::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XRFrameDataProvider::GetFrameData_Sym::IPCStableHash() { … }
uint32_t XRFrameDataProvider::GetEnvironmentIntegrationProvider_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

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

void XRFrameDataProviderProxy::GetFrameData(
    XRFrameDataRequestOptionsPtr in_options, GetFrameDataCallback callback) { … }

void XRFrameDataProviderProxy::GetEnvironmentIntegrationProvider(
    ::mojo::PendingAssociatedReceiver<XREnvironmentIntegrationProvider> in_environment_provider) { … }
class XRFrameDataProvider_GetFrameData_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void XRFrameDataProvider_GetFrameData_ProxyToResponder::Run(
    XRFrameDataPtr in_frame_data) { … }

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

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

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

bool XRFrameDataProviderResponseValidator::Accept(mojo::Message* message) { … }
const char XRPresentationProvider::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XRPresentationProvider::UpdateLayerBounds_Sym::IPCStableHash() { … }
uint32_t XRPresentationProvider::SubmitFrameMissing_Sym::IPCStableHash() { … }
uint32_t XRPresentationProvider::SubmitFrame_Sym::IPCStableHash() { … }
uint32_t XRPresentationProvider::SubmitFrameDrawnIntoTexture_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void XRPresentationProviderProxy::UpdateLayerBounds(
    int16_t in_frame_id, const ::gfx::RectF& in_left_bounds, const ::gfx::RectF& in_right_bounds, const ::gfx::Size& in_source_size) { … }

void XRPresentationProviderProxy::SubmitFrameMissing(
    int16_t in_frame_id, const ::gpu::SyncToken& in_sync_token) { … }

void XRPresentationProviderProxy::SubmitFrame(
    int16_t in_frame_id, const ::gpu::MailboxHolder& in_mailbox_holder, ::base::TimeDelta in_time_waited) { … }

void XRPresentationProviderProxy::SubmitFrameDrawnIntoTexture(
    int16_t in_frameId, const ::gpu::SyncToken& in_sync_token, ::base::TimeDelta in_time_waited) { … }

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

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

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

const char XRPresentationClient::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XRPresentationClient::OnSubmitFrameTransferred_Sym::IPCStableHash() { … }
uint32_t XRPresentationClient::OnSubmitFrameRendered_Sym::IPCStableHash() { … }
uint32_t XRPresentationClient::OnSubmitFrameGpuFence_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void XRPresentationClientProxy::OnSubmitFrameTransferred(
    bool in_success) { … }

void XRPresentationClientProxy::OnSubmitFrameRendered(
    ) { … }

void XRPresentationClientProxy::OnSubmitFrameGpuFence(
    ::gfx::GpuFenceHandle in_gpu_fence_handle) { … }

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

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

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

const char XRSessionClient::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t XRSessionClient::OnExitPresent_Sym::IPCStableHash() { … }
uint32_t XRSessionClient::OnVisibilityStateChanged_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void XRSessionClientProxy::OnExitPresent(
    ) { … }

void XRSessionClientProxy::OnVisibilityStateChanged(
    XRVisibilityState in_visibility_state) { … }

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

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

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

const char WebXrInternalsRendererListener::Name_[] = …;

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


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

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t WebXrInternalsRendererListener::OnFrameData_Sym::IPCStableHash() { … }
uint32_t WebXrInternalsRendererListener::OnConsoleLog_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

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

void WebXrInternalsRendererListenerProxy::OnFrameData(
    ::device::mojom::XrFrameStatisticsPtr in_xrframe_statistics) { … }

void WebXrInternalsRendererListenerProxy::OnConsoleLog(
    ::device::mojom::XrLogMessagePtr in_xrlogging_statistics) { … }

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

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

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



}  // device::mojom


namespace mojo {


// static
bool StructTraits<::device::mojom::XRDepthConfig::DataView, ::device::mojom::XRDepthConfigPtr>::Read(
    ::device::mojom::XRDepthConfig::DataView input,
    ::device::mojom::XRDepthConfigPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRSessionDeviceConfig::DataView, ::device::mojom::XRSessionDeviceConfigPtr>::Read(
    ::device::mojom::XRSessionDeviceConfig::DataView input,
    ::device::mojom::XRSessionDeviceConfigPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRSession::DataView, ::device::mojom::XRSessionPtr>::Read(
    ::device::mojom::XRSession::DataView input,
    ::device::mojom::XRSessionPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRPresentationConnection::DataView, ::device::mojom::XRPresentationConnectionPtr>::Read(
    ::device::mojom::XRPresentationConnection::DataView input,
    ::device::mojom::XRPresentationConnectionPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRInputSourceDescription::DataView, ::device::mojom::XRInputSourceDescriptionPtr>::Read(
    ::device::mojom::XRInputSourceDescription::DataView input,
    ::device::mojom::XRInputSourceDescriptionPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRHandJointData::DataView, ::device::mojom::XRHandJointDataPtr>::Read(
    ::device::mojom::XRHandJointData::DataView input,
    ::device::mojom::XRHandJointDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRHandTrackingData::DataView, ::device::mojom::XRHandTrackingDataPtr>::Read(
    ::device::mojom::XRHandTrackingData::DataView input,
    ::device::mojom::XRHandTrackingDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRInputSourceState::DataView, ::device::mojom::XRInputSourceStatePtr>::Read(
    ::device::mojom::XRInputSourceState::DataView input,
    ::device::mojom::XRInputSourceStatePtr* output) { … }


// static
bool StructTraits<::device::mojom::VRFieldOfView::DataView, ::device::mojom::VRFieldOfViewPtr>::Read(
    ::device::mojom::VRFieldOfView::DataView input,
    ::device::mojom::VRFieldOfViewPtr* output) { … }


// static
bool StructTraits<::device::mojom::VRPose::DataView, ::device::mojom::VRPosePtr>::Read(
    ::device::mojom::VRPose::DataView input,
    ::device::mojom::VRPosePtr* output) { … }


// static
bool StructTraits<::device::mojom::Pose::DataView, ::device::mojom::PosePtr>::Read(
    ::device::mojom::Pose::DataView input,
    ::device::mojom::PosePtr* output) { … }


// static
bool StructTraits<::device::mojom::XRRay::DataView, ::device::mojom::XRRayPtr>::Read(
    ::device::mojom::XRRay::DataView input,
    ::device::mojom::XRRayPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRHitResult::DataView, ::device::mojom::XRHitResultPtr>::Read(
    ::device::mojom::XRHitResult::DataView input,
    ::device::mojom::XRHitResultPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRView::DataView, ::device::mojom::XRViewPtr>::Read(
    ::device::mojom::XRView::DataView input,
    ::device::mojom::XRViewPtr* output) { … }


// static
bool StructTraits<::device::mojom::VRStageParameters::DataView, ::device::mojom::VRStageParametersPtr>::Read(
    ::device::mojom::VRStageParameters::DataView input,
    ::device::mojom::VRStageParametersPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRPresentationTransportOptions::DataView, ::device::mojom::XRPresentationTransportOptionsPtr>::Read(
    ::device::mojom::XRPresentationTransportOptions::DataView input,
    ::device::mojom::XRPresentationTransportOptionsPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRInputSourceSpaceInfo::DataView, ::device::mojom::XRInputSourceSpaceInfoPtr>::Read(
    ::device::mojom::XRInputSourceSpaceInfo::DataView input,
    ::device::mojom::XRInputSourceSpaceInfoPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRHandJointSpaceInfo::DataView, ::device::mojom::XRHandJointSpaceInfoPtr>::Read(
    ::device::mojom::XRHandJointSpaceInfo::DataView input,
    ::device::mojom::XRHandJointSpaceInfoPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRPlanePointData::DataView, ::device::mojom::XRPlanePointDataPtr>::Read(
    ::device::mojom::XRPlanePointData::DataView input,
    ::device::mojom::XRPlanePointDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRPlaneData::DataView, ::device::mojom::XRPlaneDataPtr>::Read(
    ::device::mojom::XRPlaneData::DataView input,
    ::device::mojom::XRPlaneDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRPlaneDetectionData::DataView, ::device::mojom::XRPlaneDetectionDataPtr>::Read(
    ::device::mojom::XRPlaneDetectionData::DataView input,
    ::device::mojom::XRPlaneDetectionDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRAnchorData::DataView, ::device::mojom::XRAnchorDataPtr>::Read(
    ::device::mojom::XRAnchorData::DataView input,
    ::device::mojom::XRAnchorDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRAnchorsData::DataView, ::device::mojom::XRAnchorsDataPtr>::Read(
    ::device::mojom::XRAnchorsData::DataView input,
    ::device::mojom::XRAnchorsDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRHitTestSubscriptionResultData::DataView, ::device::mojom::XRHitTestSubscriptionResultDataPtr>::Read(
    ::device::mojom::XRHitTestSubscriptionResultData::DataView input,
    ::device::mojom::XRHitTestSubscriptionResultDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRHitTestTransientInputSubscriptionResultData::DataView, ::device::mojom::XRHitTestTransientInputSubscriptionResultDataPtr>::Read(
    ::device::mojom::XRHitTestTransientInputSubscriptionResultData::DataView input,
    ::device::mojom::XRHitTestTransientInputSubscriptionResultDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRHitTestSubscriptionResultsData::DataView, ::device::mojom::XRHitTestSubscriptionResultsDataPtr>::Read(
    ::device::mojom::XRHitTestSubscriptionResultsData::DataView input,
    ::device::mojom::XRHitTestSubscriptionResultsDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::RgbTupleF32::DataView, ::device::mojom::RgbTupleF32Ptr>::Read(
    ::device::mojom::RgbTupleF32::DataView input,
    ::device::mojom::RgbTupleF32Ptr* output) { … }


// static
bool StructTraits<::device::mojom::XRSphericalHarmonics::DataView, ::device::mojom::XRSphericalHarmonicsPtr>::Read(
    ::device::mojom::XRSphericalHarmonics::DataView input,
    ::device::mojom::XRSphericalHarmonicsPtr* output) { … }


// static
bool StructTraits<::device::mojom::RgbaTupleF16::DataView, ::device::mojom::RgbaTupleF16Ptr>::Read(
    ::device::mojom::RgbaTupleF16::DataView input,
    ::device::mojom::RgbaTupleF16Ptr* output) { … }


// static
bool StructTraits<::device::mojom::XRCubeMap::DataView, ::device::mojom::XRCubeMapPtr>::Read(
    ::device::mojom::XRCubeMap::DataView input,
    ::device::mojom::XRCubeMapPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRLightProbe::DataView, ::device::mojom::XRLightProbePtr>::Read(
    ::device::mojom::XRLightProbe::DataView input,
    ::device::mojom::XRLightProbePtr* output) { … }


// static
bool StructTraits<::device::mojom::XRReflectionProbe::DataView, ::device::mojom::XRReflectionProbePtr>::Read(
    ::device::mojom::XRReflectionProbe::DataView input,
    ::device::mojom::XRReflectionProbePtr* output) { … }


// static
bool StructTraits<::device::mojom::XRLightEstimationData::DataView, ::device::mojom::XRLightEstimationDataPtr>::Read(
    ::device::mojom::XRLightEstimationData::DataView input,
    ::device::mojom::XRLightEstimationDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRDepthDataStillValid::DataView, ::device::mojom::XRDepthDataStillValidPtr>::Read(
    ::device::mojom::XRDepthDataStillValid::DataView input,
    ::device::mojom::XRDepthDataStillValidPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRDepthDataUpdated::DataView, ::device::mojom::XRDepthDataUpdatedPtr>::Read(
    ::device::mojom::XRDepthDataUpdated::DataView input,
    ::device::mojom::XRDepthDataUpdatedPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRTrackedImageData::DataView, ::device::mojom::XRTrackedImageDataPtr>::Read(
    ::device::mojom::XRTrackedImageData::DataView input,
    ::device::mojom::XRTrackedImageDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRTrackedImagesData::DataView, ::device::mojom::XRTrackedImagesDataPtr>::Read(
    ::device::mojom::XRTrackedImagesData::DataView input,
    ::device::mojom::XRTrackedImagesDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRFrameData::DataView, ::device::mojom::XRFrameDataPtr>::Read(
    ::device::mojom::XRFrameData::DataView input,
    ::device::mojom::XRFrameDataPtr* output) { … }


// static
bool StructTraits<::device::mojom::RequestSessionSuccess::DataView, ::device::mojom::RequestSessionSuccessPtr>::Read(
    ::device::mojom::RequestSessionSuccess::DataView input,
    ::device::mojom::RequestSessionSuccessPtr* output) { … }


// static
bool StructTraits<::device::mojom::XRFrameDataRequestOptions::DataView, ::device::mojom::XRFrameDataRequestOptionsPtr>::Read(
    ::device::mojom::XRFrameDataRequestOptions::DataView input,
    ::device::mojom::XRFrameDataRequestOptionsPtr* output) { … }

// static
bool UnionTraits<::device::mojom::XRNativeOriginInformation::DataView, ::device::mojom::XRNativeOriginInformationPtr>::Read(
    ::device::mojom::XRNativeOriginInformation::DataView input,
    ::device::mojom::XRNativeOriginInformationPtr* output) { … }

// static
bool UnionTraits<::device::mojom::XRDepthData::DataView, ::device::mojom::XRDepthDataPtr>::Read(
    ::device::mojom::XRDepthData::DataView input,
    ::device::mojom::XRDepthDataPtr* output) { … }

// static
bool UnionTraits<::device::mojom::RequestSessionResult::DataView, ::device::mojom::RequestSessionResultPtr>::Read(
    ::device::mojom::RequestSessionResult::DataView input,
    ::device::mojom::RequestSessionResultPtr* 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 device::mojom {


void VRServiceInterceptorForTesting::SetClient(::mojo::PendingRemote<VRServiceClient> client) { … }
void VRServiceInterceptorForTesting::RequestSession(::device::mojom::XRSessionOptionsPtr options, RequestSessionCallback callback) { … }
void VRServiceInterceptorForTesting::SupportsSession(::device::mojom::XRSessionOptionsPtr options, SupportsSessionCallback callback) { … }
void VRServiceInterceptorForTesting::ExitPresent(ExitPresentCallback callback) { … }
void VRServiceInterceptorForTesting::SetFramesThrottled(bool throttled) { … }
void VRServiceInterceptorForTesting::MakeXrCompatible(MakeXrCompatibleCallback callback) { … }
VRServiceAsyncWaiter::VRServiceAsyncWaiter(
    VRService* proxy) : … { … }

VRServiceAsyncWaiter::~VRServiceAsyncWaiter() = default;

void VRServiceAsyncWaiter::RequestSession(
    ::device::mojom::XRSessionOptionsPtr options, RequestSessionResultPtr* out_result) { … }

RequestSessionResultPtr VRServiceAsyncWaiter::RequestSession(
    ::device::mojom::XRSessionOptionsPtr options) { … }

void VRServiceAsyncWaiter::SupportsSession(
    ::device::mojom::XRSessionOptionsPtr options, bool* out_supports_session) { … }

bool VRServiceAsyncWaiter::SupportsSession(
    ::device::mojom::XRSessionOptionsPtr options) { … }

void VRServiceAsyncWaiter::ExitPresent(
    ) { … }



void VRServiceAsyncWaiter::MakeXrCompatible(
    XrCompatibleResult* out_xr_compatible_result) { … }

XrCompatibleResult VRServiceAsyncWaiter::MakeXrCompatible(
    ) { … }




void XRSessionMetricsRecorderInterceptorForTesting::ReportFeatureUsed(::device::mojom::XRSessionFeature feature) { … }
XRSessionMetricsRecorderAsyncWaiter::XRSessionMetricsRecorderAsyncWaiter(
    XRSessionMetricsRecorder* proxy) : … { … }

XRSessionMetricsRecorderAsyncWaiter::~XRSessionMetricsRecorderAsyncWaiter() = default;




void VRServiceClientInterceptorForTesting::OnDeviceChanged() { … }
VRServiceClientAsyncWaiter::VRServiceClientAsyncWaiter(
    VRServiceClient* proxy) : … { … }

VRServiceClientAsyncWaiter::~VRServiceClientAsyncWaiter() = default;




void XREnvironmentIntegrationProviderInterceptorForTesting::SubscribeToHitTest(XRNativeOriginInformationPtr native_origin_information, const std::vector<EntityTypeForHitTest>& entity_types, XRRayPtr ray, SubscribeToHitTestCallback callback) { … }
void XREnvironmentIntegrationProviderInterceptorForTesting::SubscribeToHitTestForTransientInput(const std::string& profile_name, const std::vector<EntityTypeForHitTest>& entity_types, XRRayPtr ray, SubscribeToHitTestForTransientInputCallback callback) { … }
void XREnvironmentIntegrationProviderInterceptorForTesting::UnsubscribeFromHitTest(uint64_t subscription_id) { … }
void XREnvironmentIntegrationProviderInterceptorForTesting::CreateAnchor(XRNativeOriginInformationPtr native_origin_information, const ::device::Pose& native_origin_from_anchor, CreateAnchorCallback callback) { … }
void XREnvironmentIntegrationProviderInterceptorForTesting::CreatePlaneAnchor(XRNativeOriginInformationPtr native_origin_information, const ::device::Pose& native_origin_from_anchor, uint64_t plane_id, CreatePlaneAnchorCallback callback) { … }
void XREnvironmentIntegrationProviderInterceptorForTesting::DetachAnchor(uint64_t anchor_id) { … }
XREnvironmentIntegrationProviderAsyncWaiter::XREnvironmentIntegrationProviderAsyncWaiter(
    XREnvironmentIntegrationProvider* proxy) : … { … }

XREnvironmentIntegrationProviderAsyncWaiter::~XREnvironmentIntegrationProviderAsyncWaiter() = default;

void XREnvironmentIntegrationProviderAsyncWaiter::SubscribeToHitTest(
    XRNativeOriginInformationPtr native_origin_information, const std::vector<EntityTypeForHitTest>& entity_types, XRRayPtr ray, SubscribeToHitTestResult* out_result, uint64_t* out_subscription_id) { … }



void XREnvironmentIntegrationProviderAsyncWaiter::SubscribeToHitTestForTransientInput(
    const std::string& profile_name, const std::vector<EntityTypeForHitTest>& entity_types, XRRayPtr ray, SubscribeToHitTestResult* out_result, uint64_t* out_subscription_id) { … }



void XREnvironmentIntegrationProviderAsyncWaiter::CreateAnchor(
    XRNativeOriginInformationPtr native_origin_information, const ::device::Pose& native_origin_from_anchor, CreateAnchorResult* out_result, uint64_t* out_anchor_id) { … }



void XREnvironmentIntegrationProviderAsyncWaiter::CreatePlaneAnchor(
    XRNativeOriginInformationPtr native_origin_information, const ::device::Pose& native_origin_from_anchor, uint64_t plane_id, CreateAnchorResult* out_result, uint64_t* out_anchor_id) { … }






void XRFrameDataProviderInterceptorForTesting::GetFrameData(XRFrameDataRequestOptionsPtr options, GetFrameDataCallback callback) { … }
void XRFrameDataProviderInterceptorForTesting::GetEnvironmentIntegrationProvider(::mojo::PendingAssociatedReceiver<XREnvironmentIntegrationProvider> environment_provider) { … }
XRFrameDataProviderAsyncWaiter::XRFrameDataProviderAsyncWaiter(
    XRFrameDataProvider* proxy) : … { … }

XRFrameDataProviderAsyncWaiter::~XRFrameDataProviderAsyncWaiter() = default;

void XRFrameDataProviderAsyncWaiter::GetFrameData(
    XRFrameDataRequestOptionsPtr options, XRFrameDataPtr* out_frame_data) { … }

XRFrameDataPtr XRFrameDataProviderAsyncWaiter::GetFrameData(
    XRFrameDataRequestOptionsPtr options) { … }




void XRPresentationProviderInterceptorForTesting::UpdateLayerBounds(int16_t frame_id, const ::gfx::RectF& left_bounds, const ::gfx::RectF& right_bounds, const ::gfx::Size& source_size) { … }
void XRPresentationProviderInterceptorForTesting::SubmitFrameMissing(int16_t frame_id, const ::gpu::SyncToken& sync_token) { … }
void XRPresentationProviderInterceptorForTesting::SubmitFrame(int16_t frame_id, const ::gpu::MailboxHolder& mailbox_holder, ::base::TimeDelta time_waited) { … }
void XRPresentationProviderInterceptorForTesting::SubmitFrameDrawnIntoTexture(int16_t frameId, const ::gpu::SyncToken& sync_token, ::base::TimeDelta time_waited) { … }
XRPresentationProviderAsyncWaiter::XRPresentationProviderAsyncWaiter(
    XRPresentationProvider* proxy) : … { … }

XRPresentationProviderAsyncWaiter::~XRPresentationProviderAsyncWaiter() = default;




void XRPresentationClientInterceptorForTesting::OnSubmitFrameTransferred(bool success) { … }
void XRPresentationClientInterceptorForTesting::OnSubmitFrameRendered() { … }
void XRPresentationClientInterceptorForTesting::OnSubmitFrameGpuFence(::gfx::GpuFenceHandle gpu_fence_handle) { … }
XRPresentationClientAsyncWaiter::XRPresentationClientAsyncWaiter(
    XRPresentationClient* proxy) : … { … }

XRPresentationClientAsyncWaiter::~XRPresentationClientAsyncWaiter() = default;




void XRSessionClientInterceptorForTesting::OnExitPresent() { … }
void XRSessionClientInterceptorForTesting::OnVisibilityStateChanged(XRVisibilityState visibility_state) { … }
XRSessionClientAsyncWaiter::XRSessionClientAsyncWaiter(
    XRSessionClient* proxy) : … { … }

XRSessionClientAsyncWaiter::~XRSessionClientAsyncWaiter() = default;




void WebXrInternalsRendererListenerInterceptorForTesting::OnFrameData(::device::mojom::XrFrameStatisticsPtr xrframe_statistics) { … }
void WebXrInternalsRendererListenerInterceptorForTesting::OnConsoleLog(::device::mojom::XrLogMessagePtr xrlogging_statistics) { … }
WebXrInternalsRendererListenerAsyncWaiter::WebXrInternalsRendererListenerAsyncWaiter(
    WebXrInternalsRendererListener* proxy) : … { … }

WebXrInternalsRendererListenerAsyncWaiter::~WebXrInternalsRendererListenerAsyncWaiter() = default;






}  // device::mojom


#if defined(__clang__)
#pragma clang diagnostic pop
#endif
chromium/out/Default/gen/device/vr/public/mojom/vr_service.mojom.cc
