// device/gamepad/public/mojom/gamepad.mojom-shared.cc is auto generated by mojom_bindings_generator.py, do not edit

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

#include "device/gamepad/public/mojom/gamepad.mojom-shared.h"
#include <ostream>
#include <utility>
#include "base/strings/stringprintf.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/lib/validation_util.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "device/gamepad/public/mojom/gamepad.mojom-params-data.h"
namespace device {
namespace mojom {

NOINLINE static const char* GamepadButtonTypeToStringHelper(GamepadButtonType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case GamepadButtonType::GamepadButtonTypeNonStandard:
      return "GamepadButtonTypeNonStandard";
    case GamepadButtonType::GamepadButtonTypeStandard:
      return "GamepadButtonTypeStandard";
    case GamepadButtonType::GamepadButtonTypeTrackpad:
      return "GamepadButtonTypeTrackpad";
    default:
      return nullptr;
  }
}

std::string GamepadButtonTypeToString(GamepadButtonType value) {
  const char *str = GamepadButtonTypeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown GamepadButtonType value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, GamepadButtonType value) {
  return os << GamepadButtonTypeToString(value);
}

NOINLINE static const char* GamepadMappingToStringHelper(GamepadMapping value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case GamepadMapping::GamepadMappingNone:
      return "GamepadMappingNone";
    case GamepadMapping::GamepadMappingStandard:
      return "GamepadMappingStandard";
    case GamepadMapping::GamepadMappingXRStandard:
      return "GamepadMappingXRStandard";
    default:
      return nullptr;
  }
}

std::string GamepadMappingToString(GamepadMapping value) {
  const char *str = GamepadMappingToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown GamepadMapping value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, GamepadMapping value) {
  return os << GamepadMappingToString(value);
}

NOINLINE static const char* GamepadHandToStringHelper(GamepadHand value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case GamepadHand::GamepadHandNone:
      return "GamepadHandNone";
    case GamepadHand::GamepadHandLeft:
      return "GamepadHandLeft";
    case GamepadHand::GamepadHandRight:
      return "GamepadHandRight";
    default:
      return nullptr;
  }
}

std::string GamepadHandToString(GamepadHand value) {
  const char *str = GamepadHandToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown GamepadHand value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, GamepadHand value) {
  return os << GamepadHandToString(value);
}

NOINLINE static const char* GamepadHapticActuatorTypeToStringHelper(GamepadHapticActuatorType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case GamepadHapticActuatorType::GamepadHapticActuatorTypeVibration:
      return "GamepadHapticActuatorTypeVibration";
    case GamepadHapticActuatorType::GamepadHapticActuatorTypeDualRumble:
      return "GamepadHapticActuatorTypeDualRumble";
    case GamepadHapticActuatorType::GamepadHapticActuatorTypeTriggerRumble:
      return "GamepadHapticActuatorTypeTriggerRumble";
    default:
      return nullptr;
  }
}

std::string GamepadHapticActuatorTypeToString(GamepadHapticActuatorType value) {
  const char *str = GamepadHapticActuatorTypeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown GamepadHapticActuatorType value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, GamepadHapticActuatorType value) {
  return os << GamepadHapticActuatorTypeToString(value);
}

NOINLINE static const char* GamepadHapticEffectTypeToStringHelper(GamepadHapticEffectType value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case GamepadHapticEffectType::GamepadHapticEffectTypeDualRumble:
      return "GamepadHapticEffectTypeDualRumble";
    case GamepadHapticEffectType::GamepadHapticEffectTypeTriggerRumble:
      return "GamepadHapticEffectTypeTriggerRumble";
    default:
      return nullptr;
  }
}

std::string GamepadHapticEffectTypeToString(GamepadHapticEffectType value) {
  const char *str = GamepadHapticEffectTypeToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown GamepadHapticEffectType value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, GamepadHapticEffectType value) {
  return os << GamepadHapticEffectTypeToString(value);
}

NOINLINE static const char* GamepadHapticsResultToStringHelper(GamepadHapticsResult value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case GamepadHapticsResult::GamepadHapticsResultError:
      return "GamepadHapticsResultError";
    case GamepadHapticsResult::GamepadHapticsResultComplete:
      return "GamepadHapticsResultComplete";
    case GamepadHapticsResult::GamepadHapticsResultPreempted:
      return "GamepadHapticsResultPreempted";
    case GamepadHapticsResult::GamepadHapticsResultInvalidParameter:
      return "GamepadHapticsResultInvalidParameter";
    case GamepadHapticsResult::GamepadHapticsResultNotSupported:
      return "GamepadHapticsResultNotSupported";
    default:
      return nullptr;
  }
}

std::string GamepadHapticsResultToString(GamepadHapticsResult value) {
  const char *str = GamepadHapticsResultToStringHelper(value);
  if (!str) {
    return base::StringPrintf("Unknown GamepadHapticsResult value: %i", static_cast<int32_t>(value));
  }
  return str;
}

std::ostream& operator<<(std::ostream& os, GamepadHapticsResult value) {
  return os << GamepadHapticsResultToString(value);
}

namespace internal {


// static
bool GamepadQuaternion_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadQuaternion_Data* object =
      static_cast<const GamepadQuaternion_Data*>(data);

  return true;
}

GamepadQuaternion_Data::GamepadQuaternion_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadVector_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadVector_Data* object =
      static_cast<const GamepadVector_Data*>(data);

  return true;
}

GamepadVector_Data::GamepadVector_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadButton_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadButton_Data* object =
      static_cast<const GamepadButton_Data*>(data);


  if (!::device::mojom::internal::GamepadButtonType_Data
        ::Validate(object->type, validation_context))
    return false;

  return true;
}

GamepadButton_Data::GamepadButton_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadTouch_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 40, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadTouch_Data* object =
      static_cast<const GamepadTouch_Data*>(data);

  return true;
}

GamepadTouch_Data::GamepadTouch_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadPose_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 56, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadPose_Data* object =
      static_cast<const GamepadPose_Data*>(data);

  if (!mojo::internal::ValidateStruct(object->orientation, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->position, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->angular_velocity, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->linear_velocity, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->angular_acceleration, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->linear_acceleration, validation_context))
    return false;

  return true;
}

GamepadPose_Data::GamepadPose_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadHapticActuator_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadHapticActuator_Data* object =
      static_cast<const GamepadHapticActuator_Data*>(data);


  if (!::device::mojom::internal::GamepadHapticActuatorType_Data
        ::Validate(object->type, validation_context))
    return false;

  return true;
}

GamepadHapticActuator_Data::GamepadHapticActuator_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool Gamepad_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 80, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const Gamepad_Data* object =
      static_cast<const Gamepad_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->id, 2, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& id_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->id, validation_context,
                                         &id_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->axes, 4, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& axes_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->axes, validation_context,
                                         &axes_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->buttons, 5, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& buttons_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->buttons, validation_context,
                                         &buttons_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidateStruct(object->vibration_actuator, validation_context))
    return false;


  if (!::device::mojom::internal::GamepadMapping_Data
        ::Validate(object->mapping, validation_context))
    return false;

  if (!mojo::internal::ValidateStruct(object->pose, validation_context))
    return false;


  if (!::device::mojom::internal::GamepadHand_Data
        ::Validate(object->hand, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->touch_events, 10, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& touch_events_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  if (!mojo::internal::ValidateContainer(object->touch_events, validation_context,
                                         &touch_events_validate_params)) {
    return false;
  }

  return true;
}

Gamepad_Data::Gamepad_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadEffectParameters_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 56, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadEffectParameters_Data* object =
      static_cast<const GamepadEffectParameters_Data*>(data);

  return true;
}

GamepadEffectParameters_Data::GamepadEffectParameters_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadObserver_GamepadConnected_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadObserver_GamepadConnected_Params_Data* object =
      static_cast<const GamepadObserver_GamepadConnected_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->gamepad, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->gamepad, validation_context))
    return false;

  return true;
}

GamepadObserver_GamepadConnected_Params_Data::GamepadObserver_GamepadConnected_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadObserver_GamepadDisconnected_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadObserver_GamepadDisconnected_Params_Data* object =
      static_cast<const GamepadObserver_GamepadDisconnected_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->gamepad, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->gamepad, validation_context))
    return false;

  return true;
}

GamepadObserver_GamepadDisconnected_Params_Data::GamepadObserver_GamepadDisconnected_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadObserver_GamepadRawInputChanged_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadObserver_GamepadRawInputChanged_Params_Data* object =
      static_cast<const GamepadObserver_GamepadRawInputChanged_Params_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->gamepad, 2, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->gamepad, validation_context))
    return false;

  return true;
}

GamepadObserver_GamepadRawInputChanged_Params_Data::GamepadObserver_GamepadRawInputChanged_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadMonitor_GamepadStartPolling_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadMonitor_GamepadStartPolling_Params_Data* object =
      static_cast<const GamepadMonitor_GamepadStartPolling_Params_Data*>(data);

  return true;
}

GamepadMonitor_GamepadStartPolling_Params_Data::GamepadMonitor_GamepadStartPolling_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadMonitor_GamepadStartPolling_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadMonitor_GamepadStartPolling_ResponseParams_Data* object =
      static_cast<const GamepadMonitor_GamepadStartPolling_ResponseParams_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->memory_region, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->memory_region, validation_context))
    return false;

  return true;
}

GamepadMonitor_GamepadStartPolling_ResponseParams_Data::GamepadMonitor_GamepadStartPolling_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadMonitor_GamepadStopPolling_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadMonitor_GamepadStopPolling_Params_Data* object =
      static_cast<const GamepadMonitor_GamepadStopPolling_Params_Data*>(data);

  return true;
}

GamepadMonitor_GamepadStopPolling_Params_Data::GamepadMonitor_GamepadStopPolling_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadMonitor_GamepadStopPolling_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 8, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadMonitor_GamepadStopPolling_ResponseParams_Data* object =
      static_cast<const GamepadMonitor_GamepadStopPolling_ResponseParams_Data*>(data);

  return true;
}

GamepadMonitor_GamepadStopPolling_ResponseParams_Data::GamepadMonitor_GamepadStopPolling_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadMonitor_SetObserver_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadMonitor_SetObserver_Params_Data* object =
      static_cast<const GamepadMonitor_SetObserver_Params_Data*>(data);

  if (!mojo::internal::ValidateHandleOrInterfaceNonNullable(
          object->gamepad_observer, 1, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateHandleOrInterface(object->gamepad_observer,
                                                 validation_context)) {
    return false;
  }

  return true;
}

GamepadMonitor_SetObserver_Params_Data::GamepadMonitor_SetObserver_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadHapticsManager_PlayVibrationEffectOnce_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 24, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadHapticsManager_PlayVibrationEffectOnce_Params_Data* object =
      static_cast<const GamepadHapticsManager_PlayVibrationEffectOnce_Params_Data*>(data);


  if (!::device::mojom::internal::GamepadHapticEffectType_Data
        ::Validate(object->type, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->params, 3, validation_context)) {
    return false;
  }
  if (!mojo::internal::ValidateStruct(object->params, validation_context))
    return false;

  return true;
}

GamepadHapticsManager_PlayVibrationEffectOnce_Params_Data::GamepadHapticsManager_PlayVibrationEffectOnce_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadHapticsManager_PlayVibrationEffectOnce_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadHapticsManager_PlayVibrationEffectOnce_ResponseParams_Data* object =
      static_cast<const GamepadHapticsManager_PlayVibrationEffectOnce_ResponseParams_Data*>(data);


  if (!::device::mojom::internal::GamepadHapticsResult_Data
        ::Validate(object->result, validation_context))
    return false;

  return true;
}

GamepadHapticsManager_PlayVibrationEffectOnce_ResponseParams_Data::GamepadHapticsManager_PlayVibrationEffectOnce_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadHapticsManager_ResetVibrationActuator_Params_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadHapticsManager_ResetVibrationActuator_Params_Data* object =
      static_cast<const GamepadHapticsManager_ResetVibrationActuator_Params_Data*>(data);

  return true;
}

GamepadHapticsManager_ResetVibrationActuator_Params_Data::GamepadHapticsManager_ResetVibrationActuator_Params_Data()
    : header_({sizeof(*this), 0}) {}


// static
bool GamepadHapticsManager_ResetVibrationActuator_ResponseParams_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 16, validation_context)) {
    return false;
  }

  // NOTE: The memory backing |object| may be smaller than |sizeof(*object)| if
  // the message comes from an older version.
  [[maybe_unused]] const GamepadHapticsManager_ResetVibrationActuator_ResponseParams_Data* object =
      static_cast<const GamepadHapticsManager_ResetVibrationActuator_ResponseParams_Data*>(data);


  if (!::device::mojom::internal::GamepadHapticsResult_Data
        ::Validate(object->result, validation_context))
    return false;

  return true;
}

GamepadHapticsManager_ResetVibrationActuator_ResponseParams_Data::GamepadHapticsManager_ResetVibrationActuator_ResponseParams_Data()
    : header_({sizeof(*this), 0}) {}

}  // namespace internal
}  // namespace mojom
}  // namespace device

namespace perfetto {

// static
void TraceFormatTraits<::device::mojom::GamepadButtonType>::WriteIntoTrace(
   perfetto::TracedValue context, ::device::mojom::GamepadButtonType value) {
  return std::move(context).WriteString(::device::mojom::GamepadButtonTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::device::mojom::GamepadMapping>::WriteIntoTrace(
   perfetto::TracedValue context, ::device::mojom::GamepadMapping value) {
  return std::move(context).WriteString(::device::mojom::GamepadMappingToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::device::mojom::GamepadHand>::WriteIntoTrace(
   perfetto::TracedValue context, ::device::mojom::GamepadHand value) {
  return std::move(context).WriteString(::device::mojom::GamepadHandToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::device::mojom::GamepadHapticActuatorType>::WriteIntoTrace(
   perfetto::TracedValue context, ::device::mojom::GamepadHapticActuatorType value) {
  return std::move(context).WriteString(::device::mojom::GamepadHapticActuatorTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::device::mojom::GamepadHapticEffectType>::WriteIntoTrace(
   perfetto::TracedValue context, ::device::mojom::GamepadHapticEffectType value) {
  return std::move(context).WriteString(::device::mojom::GamepadHapticEffectTypeToString(value));
}

} // namespace perfetto

namespace perfetto {

// static
void TraceFormatTraits<::device::mojom::GamepadHapticsResult>::WriteIntoTrace(
   perfetto::TracedValue context, ::device::mojom::GamepadHapticsResult value) {
  return std::move(context).WriteString(::device::mojom::GamepadHapticsResultToString(value));
}

} // namespace perfetto