// third_party/blink/public/mojom/input/input_handler.mojom-send-validation.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef THIRD_PARTY_BLINK_PUBLIC_MOJOM_INPUT_INPUT_HANDLER_MOJOM_SEND_VALIDATION_H_
#define THIRD_PARTY_BLINK_PUBLIC_MOJOM_INPUT_INPUT_HANDLER_MOJOM_SEND_VALIDATION_H_

#include "third_party/blink/public/mojom/input/input_handler.mojom-shared-internal.h"
#include "cc/mojom/browser_controls_offset_tag_modifications.mojom-shared.h"
#include "cc/mojom/browser_controls_state.mojom-shared.h"
#include "cc/mojom/overscroll_behavior.mojom-shared.h"
#include "cc/mojom/touch_action.mojom-shared.h"
#include "mojo/public/mojom/base/big_buffer.mojom-shared.h"
#include "mojo/public/mojom/base/string16.mojom-shared.h"
#include "mojo/public/mojom/base/time.mojom-shared.h"
#include "third_party/blink/public/mojom/dom/dom_node_id.mojom-shared.h"
#include "third_party/blink/public/mojom/input/gesture_event.mojom-shared.h"
#include "third_party/blink/public/mojom/input/handwriting_gesture_result.mojom-shared.h"
#include "third_party/blink/public/mojom/input/input_event.mojom-shared.h"
#include "third_party/blink/public/mojom/input/input_event_result.mojom-shared.h"
#include "third_party/blink/public/mojom/input/pointer_lock_context.mojom-shared.h"
#include "third_party/blink/public/mojom/input/pointer_lock_result.mojom-shared.h"
#include "third_party/blink/public/mojom/input/stylus_writing_gesture.mojom-shared.h"
#include "third_party/blink/public/mojom/input/touch_event.mojom-shared.h"
#include "third_party/blink/public/mojom/selection_menu/selection_menu_behavior.mojom-shared.h"
#include "ui/base/ime/mojom/ime_types.mojom-shared.h"
#include "ui/events/mojom/event.mojom-shared.h"
#include "ui/events/mojom/event_constants.mojom-shared.h"
#include "ui/events/mojom/event_latency_metadata.mojom-shared.h"
#include "ui/events/mojom/scroll_granularity.mojom-shared.h"
#include "ui/gfx/geometry/mojom/geometry.mojom-shared.h"
#include "ui/gfx/range/mojom/range.mojom-shared.h"
#include "ui/latency/mojom/latency_info.mojom-shared.h"
#include "third_party/blink/public/mojom/input/synchronous_compositor.mojom-shared.h"

#include "third_party/blink/public/mojom/input/input_handler.mojom-data-view.h"

#include "mojo/public/cpp/bindings/lib/send_validation_type.h"
#include "mojo/public/cpp/bindings/lib/send_validation.h"
#include "mojo/public/cpp/bindings/lib/interface_serialization_send_validation.h"
#include "mojo/public/cpp/bindings/lib/has_send_validation_helper.h"

namespace mojo::internal {
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::SelectionGranularity, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::PanAction, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::ImeState, MaybeConstUserType>
    : std::false_type {};
template <typename MaybeConstUserType>
struct HasSendValidationSerialize<::blink::mojom::FocusState, MaybeConstUserType>
    : std::false_type {};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::KeyDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::KeyDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::KeyData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->dom_key = Traits::dom_key(input);

      fragment->dom_code = Traits::dom_code(input);

      fragment->windows_key_code = Traits::windows_key_code(input);

      fragment->native_key_code = Traits::native_key_code(input);

      fragment->is_system_key = Traits::is_system_key(input);

      fragment->is_browser_shortcut = Traits::is_browser_shortcut(input);

      fragment->is_confirmed_physical_keyboard_input = Traits::is_confirmed_physical_keyboard_input(input);

      decltype(Traits::text(input)) in_text = Traits::text(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->text)::BaseType> text_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::String16DataView, send_validation>(
        in_text,
        text_fragment);

      fragment->text.Set(
          text_fragment.is_null() ? nullptr : text_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->text.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null text in KeyData struct");

      decltype(Traits::unmodified_text(input)) in_unmodified_text = Traits::unmodified_text(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->unmodified_text)::BaseType> unmodified_text_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::String16DataView, send_validation>(
        in_unmodified_text,
        unmodified_text_fragment);

      fragment->unmodified_text.Set(
          unmodified_text_fragment.is_null() ? nullptr : unmodified_text_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->unmodified_text.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null unmodified_text in KeyData struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PointerDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PointerDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PointerData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->pointer_id = Traits::pointer_id(input);

      fragment->force = Traits::force(input);

      fragment->tilt_x = Traits::tilt_x(input);

      fragment->tilt_y = Traits::tilt_y(input);

      fragment->tangential_pressure = Traits::tangential_pressure(input);

      fragment->twist = Traits::twist(input);

      
      mojo::internal::Serialize<::blink::mojom::Button>(
        Traits::button(input),
        &fragment->button);

      
      mojo::internal::Serialize<::ui::mojom::EventPointerType>(
        Traits::pointer_type(input),
        &fragment->pointer_type);

      fragment->movement_x = Traits::movement_x(input);

      fragment->movement_y = Traits::movement_y(input);

      fragment->is_raw_movement_event = Traits::is_raw_movement_event(input);

      decltype(Traits::widget_position(input)) in_widget_position = Traits::widget_position(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->widget_position)::BaseType> widget_position_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::gfx::mojom::PointFDataView, send_validation>(
        in_widget_position,
        widget_position_fragment);

      fragment->widget_position.Set(
          widget_position_fragment.is_null() ? nullptr : widget_position_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->widget_position.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null widget_position in PointerData struct");

      decltype(Traits::screen_position(input)) in_screen_position = Traits::screen_position(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->screen_position)::BaseType> screen_position_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::gfx::mojom::PointFDataView, send_validation>(
        in_screen_position,
        screen_position_fragment);

      fragment->screen_position.Set(
          screen_position_fragment.is_null() ? nullptr : screen_position_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->screen_position.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null screen_position in PointerData struct");

      decltype(Traits::mouse_data(input)) in_mouse_data = Traits::mouse_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->mouse_data)::BaseType> mouse_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::MouseDataDataView, send_validation>(
        in_mouse_data,
        mouse_data_fragment);

      fragment->mouse_data.Set(
          mouse_data_fragment.is_null() ? nullptr : mouse_data_fragment.data());

      fragment->device_id = Traits::device_id(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::WheelDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::WheelDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::WheelData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->delta_x = Traits::delta_x(input);

      fragment->delta_y = Traits::delta_y(input);

      fragment->wheel_ticks_x = Traits::wheel_ticks_x(input);

      fragment->wheel_ticks_y = Traits::wheel_ticks_y(input);

      fragment->acceleration_ratio_x = Traits::acceleration_ratio_x(input);

      fragment->acceleration_ratio_y = Traits::acceleration_ratio_y(input);

      fragment->phase = Traits::phase(input);

      fragment->momentum_phase = Traits::momentum_phase(input);

      
      mojo::internal::Serialize<::blink::mojom::DispatchType>(
        Traits::cancelable(input),
        &fragment->cancelable);

      fragment->event_action = Traits::event_action(input);

      fragment->delta_units = Traits::delta_units(input);

      
      mojo::internal::Serialize<::blink::mojom::RailsMode>(
        Traits::rails_mode(input),
        &fragment->rails_mode);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::MouseDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::MouseDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::MouseData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->click_count = Traits::click_count(input);

      decltype(Traits::wheel_data(input)) in_wheel_data = Traits::wheel_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->wheel_data)::BaseType> wheel_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::WheelDataDataView, send_validation>(
        in_wheel_data,
        wheel_data_fragment);

      fragment->wheel_data.Set(
          wheel_data_fragment.is_null() ? nullptr : wheel_data_fragment.data());
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::ScrollDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::ScrollDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::ScrollData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->delta_x = Traits::delta_x(input);

      fragment->delta_y = Traits::delta_y(input);

      
      mojo::internal::Serialize<::ui::mojom::ScrollGranularity>(
        Traits::delta_units(input),
        &fragment->delta_units);

      fragment->target_viewport = Traits::target_viewport(input);

      
      mojo::internal::Serialize<::blink::mojom::InertialPhaseState>(
        Traits::inertial_phase(input),
        &fragment->inertial_phase);

      fragment->synthetic = Traits::synthetic(input);

      fragment->pointer_count = Traits::pointer_count(input);

      fragment->cursor_control = Traits::cursor_control(input);

      fragment->delta_x_unconstrained = Traits::delta_x_unconstrained(input);

      fragment->delta_y_unconstrained = Traits::delta_y_unconstrained(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PinchBeginDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PinchBeginDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PinchBeginData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->needs_wheel_event = Traits::needs_wheel_event(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PinchUpdateDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PinchUpdateDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PinchUpdateData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->scale = Traits::scale(input);

      fragment->zoom_disabled = Traits::zoom_disabled(input);

      fragment->needs_wheel_event = Traits::needs_wheel_event(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::PinchEndDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::PinchEndDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::PinchEndData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->needs_wheel_event = Traits::needs_wheel_event(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::FlingDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::FlingDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::FlingData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->velocity_x = Traits::velocity_x(input);

      fragment->velocity_y = Traits::velocity_y(input);

      fragment->target_viewport = Traits::target_viewport(input);

      fragment->prevent_boosting = Traits::prevent_boosting(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::TapDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::TapDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::TapData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->tap_count = Traits::tap_count(input);

      fragment->needs_wheel_event = Traits::needs_wheel_event(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::TapDownDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::TapDownDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::TapDownData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->tap_down_count = Traits::tap_down_count(input);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::GestureDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::GestureDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::GestureData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::screen_position(input)) in_screen_position = Traits::screen_position(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->screen_position)::BaseType> screen_position_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::gfx::mojom::PointFDataView, send_validation>(
        in_screen_position,
        screen_position_fragment);

      fragment->screen_position.Set(
          screen_position_fragment.is_null() ? nullptr : screen_position_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->screen_position.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null screen_position in GestureData struct");

      decltype(Traits::widget_position(input)) in_widget_position = Traits::widget_position(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->widget_position)::BaseType> widget_position_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::gfx::mojom::PointFDataView, send_validation>(
        in_widget_position,
        widget_position_fragment);

      fragment->widget_position.Set(
          widget_position_fragment.is_null() ? nullptr : widget_position_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->widget_position.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null widget_position in GestureData struct");

      
      mojo::internal::Serialize<::blink::mojom::GestureDevice>(
        Traits::source_device(input),
        &fragment->source_device);

      fragment->is_source_touch_event_set_blocking = Traits::is_source_touch_event_set_blocking(input);

      
      mojo::internal::Serialize<::ui::mojom::EventPointerType>(
        Traits::primary_pointer_type(input),
        &fragment->primary_pointer_type);

      fragment->primary_unique_touch_event_id = Traits::primary_unique_touch_event_id(input);

      fragment->unique_touch_event_id = Traits::unique_touch_event_id(input);

      decltype(Traits::contact_size(input)) in_contact_size = Traits::contact_size(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->contact_size)::BaseType> contact_size_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::gfx::mojom::SizeDataView, send_validation>(
        in_contact_size,
        contact_size_fragment);

      fragment->contact_size.Set(
          contact_size_fragment.is_null() ? nullptr : contact_size_fragment.data());

      decltype(Traits::scroll_data(input)) in_scroll_data = Traits::scroll_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->scroll_data)::BaseType> scroll_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::ScrollDataDataView, send_validation>(
        in_scroll_data,
        scroll_data_fragment);

      fragment->scroll_data.Set(
          scroll_data_fragment.is_null() ? nullptr : scroll_data_fragment.data());

      decltype(Traits::pinch_begin_data(input)) in_pinch_begin_data = Traits::pinch_begin_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->pinch_begin_data)::BaseType> pinch_begin_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PinchBeginDataDataView, send_validation>(
        in_pinch_begin_data,
        pinch_begin_data_fragment);

      fragment->pinch_begin_data.Set(
          pinch_begin_data_fragment.is_null() ? nullptr : pinch_begin_data_fragment.data());

      decltype(Traits::pinch_update_data(input)) in_pinch_update_data = Traits::pinch_update_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->pinch_update_data)::BaseType> pinch_update_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PinchUpdateDataDataView, send_validation>(
        in_pinch_update_data,
        pinch_update_data_fragment);

      fragment->pinch_update_data.Set(
          pinch_update_data_fragment.is_null() ? nullptr : pinch_update_data_fragment.data());

      decltype(Traits::pinch_end_data(input)) in_pinch_end_data = Traits::pinch_end_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->pinch_end_data)::BaseType> pinch_end_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PinchEndDataDataView, send_validation>(
        in_pinch_end_data,
        pinch_end_data_fragment);

      fragment->pinch_end_data.Set(
          pinch_end_data_fragment.is_null() ? nullptr : pinch_end_data_fragment.data());

      decltype(Traits::tap_data(input)) in_tap_data = Traits::tap_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->tap_data)::BaseType> tap_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::TapDataDataView, send_validation>(
        in_tap_data,
        tap_data_fragment);

      fragment->tap_data.Set(
          tap_data_fragment.is_null() ? nullptr : tap_data_fragment.data());

      decltype(Traits::tap_down_data(input)) in_tap_down_data = Traits::tap_down_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->tap_down_data)::BaseType> tap_down_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::TapDownDataDataView, send_validation>(
        in_tap_down_data,
        tap_down_data_fragment);

      fragment->tap_down_data.Set(
          tap_down_data_fragment.is_null() ? nullptr : tap_down_data_fragment.data());

      decltype(Traits::fling_data(input)) in_fling_data = Traits::fling_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->fling_data)::BaseType> fling_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::FlingDataDataView, send_validation>(
        in_fling_data,
        fling_data_fragment);

      fragment->fling_data.Set(
          fling_data_fragment.is_null() ? nullptr : fling_data_fragment.data());
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::TouchPointDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::TouchPointDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::TouchPoint_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      
      mojo::internal::Serialize<::blink::mojom::TouchState>(
        Traits::state(input),
        &fragment->state);

      fragment->radius_x = Traits::radius_x(input);

      fragment->radius_y = Traits::radius_y(input);

      fragment->rotation_angle = Traits::rotation_angle(input);

      decltype(Traits::pointer_data(input)) in_pointer_data = Traits::pointer_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->pointer_data)::BaseType> pointer_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PointerDataDataView, send_validation>(
        in_pointer_data,
        pointer_data_fragment);

      fragment->pointer_data.Set(
          pointer_data_fragment.is_null() ? nullptr : pointer_data_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->pointer_data.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null pointer_data in TouchPoint struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::TouchDataDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::TouchDataDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::TouchData_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      
      mojo::internal::Serialize<::blink::mojom::DispatchType>(
        Traits::cancelable(input),
        &fragment->cancelable);

      fragment->moved_beyond_slop_region = Traits::moved_beyond_slop_region(input);

      fragment->touch_start_or_first_move = Traits::touch_start_or_first_move(input);

      fragment->hovering = Traits::hovering(input);

      fragment->unique_touch_event_id = Traits::unique_touch_event_id(input);

      decltype(Traits::touches(input)) in_touches = Traits::touches(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->touches)::BaseType>
          touches_fragment(fragment.message());
      constexpr const mojo::internal::ContainerValidateParams& touches_validate_params =
          mojo::internal::GetArrayValidator<0, false, nullptr>();
      
      mojo::internal::Serialize<mojo::ArrayDataView<::blink::mojom::TouchPointDataView>, send_validation>(
        in_touches,
        touches_fragment,
        &touches_validate_params);

      fragment->touches.Set(
          touches_fragment.is_null() ? nullptr : touches_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->touches.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null touches in TouchData struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::EventDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::EventDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::Event_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      
      mojo::internal::Serialize<::blink::mojom::EventType>(
        Traits::type(input),
        &fragment->type);

      fragment->modifiers = Traits::modifiers(input);

      decltype(Traits::timestamp(input)) in_timestamp = Traits::timestamp(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->timestamp)::BaseType> timestamp_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::mojo_base::mojom::TimeTicksDataView, send_validation>(
        in_timestamp,
        timestamp_fragment);

      fragment->timestamp.Set(
          timestamp_fragment.is_null() ? nullptr : timestamp_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->timestamp.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null timestamp in Event struct");

      decltype(Traits::latency(input)) in_latency = Traits::latency(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->latency)::BaseType> latency_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::ui::mojom::LatencyInfoDataView, send_validation>(
        in_latency,
        latency_fragment);

      fragment->latency.Set(
          latency_fragment.is_null() ? nullptr : latency_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->latency.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null latency in Event struct");

      decltype(Traits::event_latency_metadata(input)) in_event_latency_metadata = Traits::event_latency_metadata(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->event_latency_metadata)::BaseType> event_latency_metadata_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::ui::mojom::EventLatencyMetadataDataView, send_validation>(
        in_event_latency_metadata,
        event_latency_metadata_fragment);

      fragment->event_latency_metadata.Set(
          event_latency_metadata_fragment.is_null() ? nullptr : event_latency_metadata_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->event_latency_metadata.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null event_latency_metadata in Event struct");

      decltype(Traits::key_data(input)) in_key_data = Traits::key_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->key_data)::BaseType> key_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::KeyDataDataView, send_validation>(
        in_key_data,
        key_data_fragment);

      fragment->key_data.Set(
          key_data_fragment.is_null() ? nullptr : key_data_fragment.data());

      decltype(Traits::pointer_data(input)) in_pointer_data = Traits::pointer_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->pointer_data)::BaseType> pointer_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::PointerDataDataView, send_validation>(
        in_pointer_data,
        pointer_data_fragment);

      fragment->pointer_data.Set(
          pointer_data_fragment.is_null() ? nullptr : pointer_data_fragment.data());

      decltype(Traits::gesture_data(input)) in_gesture_data = Traits::gesture_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->gesture_data)::BaseType> gesture_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::GestureDataDataView, send_validation>(
        in_gesture_data,
        gesture_data_fragment);

      fragment->gesture_data.Set(
          gesture_data_fragment.is_null() ? nullptr : gesture_data_fragment.data());

      decltype(Traits::touch_data(input)) in_touch_data = Traits::touch_data(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->touch_data)::BaseType> touch_data_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::blink::mojom::TouchDataDataView, send_validation>(
        in_touch_data,
        touch_data_fragment);

      fragment->touch_data.Set(
          touch_data_fragment.is_null() ? nullptr : touch_data_fragment.data());
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::DidOverscrollParamsDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::DidOverscrollParamsDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::DidOverscrollParams_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::accumulated_overscroll(input)) in_accumulated_overscroll = Traits::accumulated_overscroll(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->accumulated_overscroll)::BaseType> accumulated_overscroll_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::gfx::mojom::Vector2dFDataView, send_validation>(
        in_accumulated_overscroll,
        accumulated_overscroll_fragment);

      fragment->accumulated_overscroll.Set(
          accumulated_overscroll_fragment.is_null() ? nullptr : accumulated_overscroll_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->accumulated_overscroll.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null accumulated_overscroll in DidOverscrollParams struct");

      decltype(Traits::latest_overscroll_delta(input)) in_latest_overscroll_delta = Traits::latest_overscroll_delta(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->latest_overscroll_delta)::BaseType> latest_overscroll_delta_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::gfx::mojom::Vector2dFDataView, send_validation>(
        in_latest_overscroll_delta,
        latest_overscroll_delta_fragment);

      fragment->latest_overscroll_delta.Set(
          latest_overscroll_delta_fragment.is_null() ? nullptr : latest_overscroll_delta_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->latest_overscroll_delta.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null latest_overscroll_delta in DidOverscrollParams struct");

      decltype(Traits::current_fling_velocity(input)) in_current_fling_velocity = Traits::current_fling_velocity(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->current_fling_velocity)::BaseType> current_fling_velocity_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::gfx::mojom::Vector2dFDataView, send_validation>(
        in_current_fling_velocity,
        current_fling_velocity_fragment);

      fragment->current_fling_velocity.Set(
          current_fling_velocity_fragment.is_null() ? nullptr : current_fling_velocity_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->current_fling_velocity.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null current_fling_velocity in DidOverscrollParams struct");

      decltype(Traits::causal_event_viewport_point(input)) in_causal_event_viewport_point = Traits::causal_event_viewport_point(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->causal_event_viewport_point)::BaseType> causal_event_viewport_point_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::gfx::mojom::PointFDataView, send_validation>(
        in_causal_event_viewport_point,
        causal_event_viewport_point_fragment);

      fragment->causal_event_viewport_point.Set(
          causal_event_viewport_point_fragment.is_null() ? nullptr : causal_event_viewport_point_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->causal_event_viewport_point.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null causal_event_viewport_point in DidOverscrollParams struct");

      decltype(Traits::overscroll_behavior(input)) in_overscroll_behavior = Traits::overscroll_behavior(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->overscroll_behavior)::BaseType> overscroll_behavior_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::cc::mojom::OverscrollBehaviorDataView, send_validation>(
        in_overscroll_behavior,
        overscroll_behavior_fragment);

      fragment->overscroll_behavior.Set(
          overscroll_behavior_fragment.is_null() ? nullptr : overscroll_behavior_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->overscroll_behavior.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null overscroll_behavior in DidOverscrollParams struct");

      
      mojo::internal::Serialize<::blink::mojom::GestureDevice>(
        Traits::source_device(input),
        &fragment->source_device);
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::TouchActionOptionalDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::TouchActionOptionalDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::TouchActionOptional_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::touch_action(input)) in_touch_action = Traits::touch_action(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->touch_action)::BaseType> touch_action_fragment(
              fragment.message());
      
      mojo::internal::Serialize<::cc::mojom::TouchActionDataView, send_validation>(
        in_touch_action,
        touch_action_fragment);

      fragment->touch_action.Set(
          touch_action_fragment.is_null() ? nullptr : touch_action_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->touch_action.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null touch_action in TouchActionOptional struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::EditCommandDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::EditCommandDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::EditCommand_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      decltype(Traits::name(input)) in_name = Traits::name(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->name)::BaseType> name_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_name,
        name_fragment);

      fragment->name.Set(
          name_fragment.is_null() ? nullptr : name_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->name.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null name in EditCommand struct");

      decltype(Traits::value(input)) in_value = Traits::value(input);
      mojo::internal::MessageFragment<
          typename decltype(fragment->value)::BaseType> value_fragment(
              fragment.message());
      
      mojo::internal::Serialize<mojo::StringDataView, send_validation>(
        in_value,
        value_fragment);

      fragment->value.Set(
          value_fragment.is_null() ? nullptr : value_fragment.data());

      
      MOJO_INTERNAL_CHECK_SERIALIZATION(
        send_validation,
        !(fragment->value.is_null()),
        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
        "null value in EditCommand struct");
  }
};

template <typename MaybeConstUserType, mojo::internal::SendValidation send_validation>
struct SendValidationSerializer<::blink::mojom::SelectAroundCaretResultDataView, MaybeConstUserType, send_validation> {
  using UserType = typename std::remove_const<MaybeConstUserType>::type;
  using Traits = StructTraits<::blink::mojom::SelectAroundCaretResultDataView, UserType>;
  static void Serialize(
      MaybeConstUserType& input,
      mojo::internal::MessageFragment<::blink::mojom::internal::SelectAroundCaretResult_Data>& fragment) {
    if (CallIsNullIfExists<Traits>(input))
      return;
    fragment.Allocate();

      fragment->extended_start_adjust = Traits::extended_start_adjust(input);

      fragment->extended_end_adjust = Traits::extended_end_adjust(input);

      fragment->word_start_adjust = Traits::word_start_adjust(input);

      fragment->word_end_adjust = Traits::word_end_adjust(input);
  }
};

}  // namespace mojo::internal

#endif  // THIRD_PARTY_BLINK_PUBLIC_MOJOM_INPUT_INPUT_HANDLER_MOJOM_SEND_VALIDATION_H_