// media/capture/mojom/image_capture.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 "media/capture/mojom/image_capture.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 "media/capture/mojom/image_capture.mojom-params-data.h"
namespace media {
namespace mojom {

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

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

std::ostream& operator<<(std::ostream& os, BackgroundBlurMode value) {
  return os << BackgroundBlurModeToString(value);
}

NOINLINE static const char* EyeGazeCorrectionModeToStringHelper(EyeGazeCorrectionMode value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case EyeGazeCorrectionMode::OFF:
      return "OFF";
    case EyeGazeCorrectionMode::ON:
      return "ON";
    case EyeGazeCorrectionMode::STARE:
      return "STARE";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, EyeGazeCorrectionMode value) {
  return os << EyeGazeCorrectionModeToString(value);
}

NOINLINE static const char* MeteringModeToStringHelper(MeteringMode value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case MeteringMode::NONE:
      return "NONE";
    case MeteringMode::MANUAL:
      return "MANUAL";
    case MeteringMode::SINGLE_SHOT:
      return "SINGLE_SHOT";
    case MeteringMode::CONTINUOUS:
      return "CONTINUOUS";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, MeteringMode value) {
  return os << MeteringModeToString(value);
}

NOINLINE static const char* RedEyeReductionToStringHelper(RedEyeReduction value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case RedEyeReduction::NEVER:
      return "NEVER";
    case RedEyeReduction::ALWAYS:
      return "ALWAYS";
    case RedEyeReduction::CONTROLLABLE:
      return "CONTROLLABLE";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, RedEyeReduction value) {
  return os << RedEyeReductionToString(value);
}

NOINLINE static const char* FillLightModeToStringHelper(FillLightMode value) {
  // Defined in a helper function to ensure that Clang generates a lookup table.
  switch(value) {
    case FillLightMode::OFF:
      return "OFF";
    case FillLightMode::AUTO:
      return "AUTO";
    case FillLightMode::FLASH:
      return "FLASH";
    default:
      return nullptr;
  }
}

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

std::ostream& operator<<(std::ostream& os, FillLightMode value) {
  return os << FillLightModeToString(value);
}

namespace internal {


// static
bool Range_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 Range_Data* object =
      static_cast<const Range_Data*>(data);

  return true;
}

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


// static
bool PhotoState_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 224, 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 PhotoState_Data* object =
      static_cast<const PhotoState_Data*>(data);

  if (!mojo::internal::ValidatePointerNonNullable(
          object->supported_white_balance_modes, 1, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& supported_white_balance_modes_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::media::mojom::internal::MeteringMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->supported_white_balance_modes, validation_context,
                                         &supported_white_balance_modes_validate_params)) {
    return false;
  }


  if (!::media::mojom::internal::MeteringMode_Data
        ::Validate(object->current_white_balance_mode, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->supported_exposure_modes, 3, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& supported_exposure_modes_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::media::mojom::internal::MeteringMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->supported_exposure_modes, validation_context,
                                         &supported_exposure_modes_validate_params)) {
    return false;
  }


  if (!::media::mojom::internal::MeteringMode_Data
        ::Validate(object->current_exposure_mode, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->supported_focus_modes, 5, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& supported_focus_modes_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::media::mojom::internal::MeteringMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->supported_focus_modes, validation_context,
                                         &supported_focus_modes_validate_params)) {
    return false;
  }


  if (!::media::mojom::internal::MeteringMode_Data
        ::Validate(object->current_focus_mode, validation_context))
    return false;

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

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

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

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

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

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

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

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

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

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

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

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

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


  if (!::media::mojom::internal::RedEyeReduction_Data
        ::Validate(object->red_eye_reduction, validation_context))
    return false;

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

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

  if (!mojo::internal::ValidatePointerNonNullable(
          object->fill_light_mode, 25, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& fill_light_mode_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::media::mojom::internal::FillLightMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->fill_light_mode, validation_context,
                                         &fill_light_mode_validate_params)) {
    return false;
  }

  if (!mojo::internal::ValidatePointerNonNullable(
          object->supported_background_blur_modes, 26, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& supported_background_blur_modes_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::media::mojom::internal::BackgroundBlurMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->supported_background_blur_modes, validation_context,
                                         &supported_background_blur_modes_validate_params)) {
    return false;
  }


  if (!::media::mojom::internal::BackgroundBlurMode_Data
        ::Validate(object->background_blur_mode, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->supported_face_framing_modes, 28, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& supported_face_framing_modes_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::media::mojom::internal::MeteringMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->supported_face_framing_modes, validation_context,
                                         &supported_face_framing_modes_validate_params)) {
    return false;
  }


  if (!::media::mojom::internal::MeteringMode_Data
        ::Validate(object->current_face_framing_mode, validation_context))
    return false;

  if (!mojo::internal::ValidatePointerNonNullable(
          object->supported_eye_gaze_correction_modes, 30, validation_context)) {
    return false;
  }
  constexpr const mojo::internal::ContainerValidateParams& supported_eye_gaze_correction_modes_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::media::mojom::internal::EyeGazeCorrectionMode_Data::Validate>();
  if (!mojo::internal::ValidateContainer(object->supported_eye_gaze_correction_modes, validation_context,
                                         &supported_eye_gaze_correction_modes_validate_params)) {
    return false;
  }


  if (!::media::mojom::internal::EyeGazeCorrectionMode_Data
        ::Validate(object->current_eye_gaze_correction_mode, validation_context))
    return false;

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

  return true;
}

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


// static
bool Point2D_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 Point2D_Data* object =
      static_cast<const Point2D_Data*>(data);

  return true;
}

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


// static
bool PhotoSettings_Data::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  if (!data)
    return true;
  if (!ValidateUnversionedStructHeaderAndSizeAndClaimMemory(
          data, 160, 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 PhotoSettings_Data* object =
      static_cast<const PhotoSettings_Data*>(data);


  if (!::media::mojom::internal::MeteringMode_Data
        ::Validate(object->white_balance_mode, validation_context))
    return false;


  if (!::media::mojom::internal::MeteringMode_Data
        ::Validate(object->exposure_mode, validation_context))
    return false;


  if (!::media::mojom::internal::MeteringMode_Data
        ::Validate(object->focus_mode, validation_context))
    return false;

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


  if (!::media::mojom::internal::FillLightMode_Data
        ::Validate(object->fill_light_mode, validation_context))
    return false;


  if (!::media::mojom::internal::BackgroundBlurMode_Data
        ::Validate(object->background_blur_mode, validation_context))
    return false;


  if (!::media::mojom::internal::MeteringMode_Data
        ::Validate(object->face_framing_mode, validation_context))
    return false;


  if (!::media::mojom::internal::EyeGazeCorrectionMode_Data
        ::Validate(object->eye_gaze_correction_mode_$value, validation_context))
    return false;

  return true;
}

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


// static
bool Blob_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 Blob_Data* object =
      static_cast<const Blob_Data*>(data);

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

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

  return true;
}

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


// static
bool ImageCapture_GetPhotoState_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 ImageCapture_GetPhotoState_Params_Data* object =
      static_cast<const ImageCapture_GetPhotoState_Params_Data*>(data);

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

  return true;
}

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


// static
bool ImageCapture_GetPhotoState_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 ImageCapture_GetPhotoState_ResponseParams_Data* object =
      static_cast<const ImageCapture_GetPhotoState_ResponseParams_Data*>(data);

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

  return true;
}

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


// static
bool ImageCapture_SetPhotoOptions_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 ImageCapture_SetPhotoOptions_Params_Data* object =
      static_cast<const ImageCapture_SetPhotoOptions_Params_Data*>(data);

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

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

  return true;
}

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


// static
bool ImageCapture_SetPhotoOptions_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 ImageCapture_SetPhotoOptions_ResponseParams_Data* object =
      static_cast<const ImageCapture_SetPhotoOptions_ResponseParams_Data*>(data);

  return true;
}

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


// static
bool ImageCapture_TakePhoto_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 ImageCapture_TakePhoto_Params_Data* object =
      static_cast<const ImageCapture_TakePhoto_Params_Data*>(data);

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

  return true;
}

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


// static
bool ImageCapture_TakePhoto_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 ImageCapture_TakePhoto_ResponseParams_Data* object =
      static_cast<const ImageCapture_TakePhoto_ResponseParams_Data*>(data);

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

  return true;
}

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

}  // namespace internal
}  // namespace mojom
}  // namespace media

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto

namespace perfetto {

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

} // namespace perfetto