// skia/public/mojom/hdr_metadata.mojom-shared-internal.h 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.

#ifndef SKIA_PUBLIC_MOJOM_HDR_METADATA_MOJOM_SHARED_INTERNAL_H_
#define SKIA_PUBLIC_MOJOM_HDR_METADATA_MOJOM_SHARED_INTERNAL_H_
#include "mojo/public/cpp/bindings/lib/array_internal.h"
#include "mojo/public/cpp/bindings/lib/bindings_internal.h"
#include "mojo/public/cpp/bindings/lib/map_data_internal.h"
#include "mojo/public/cpp/bindings/lib/message_fragment.h"
#include "skia/public/mojom/skcolorspace_primaries.mojom-shared-internal.h"
#include "mojo/public/cpp/bindings/lib/native_enum_data.h"
#include "mojo/public/interfaces/bindings/native_struct.mojom-shared-internal.h"



namespace mojo {
namespace internal {
class ValidationContext;
}
}


namespace skia::mojom {
namespace internal {
class SkHdrContentLightLevelInformation_Data;
class SkHdrMasteringDisplayColorVolume_Data;
class SkHdrAgtmGainCurveControlPoint_Data;
class SkHdrAgtmGainCurve_Data;
class SkHdrAgtmComponentMixingFunction_Data;
class SkHdrAgtmColorGainFunction_Data;
class SkHdrAgtmAlternateImage_Data;
class SkHdrAgtmHeadroomAdaptiveToneMap_Data;
class SkHdrAdaptiveGlobalToneMap_Data;

#pragma pack(push, 1)
class  SkHdrContentLightLevelInformation_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float max_cll;
  float max_fall;

 private:
  friend class mojo::internal::MessageFragment<SkHdrContentLightLevelInformation_Data>;

  SkHdrContentLightLevelInformation_Data();
  ~SkHdrContentLightLevelInformation_Data() = delete;
};
static_assert(sizeof(SkHdrContentLightLevelInformation_Data) == 16,
              "Bad sizeof(SkHdrContentLightLevelInformation_Data)");
// Used by SkHdrContentLightLevelInformation::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SkHdrContentLightLevelInformation_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SkHdrContentLightLevelInformation_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SkHdrContentLightLevelInformation_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SkHdrContentLightLevelInformation_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SkHdrContentLightLevelInformation_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SkHdrMasteringDisplayColorVolume_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<::skia::mojom::internal::SkColorSpacePrimaries_Data> primaries;
  float max_luminance;
  float min_luminance;

 private:
  friend class mojo::internal::MessageFragment<SkHdrMasteringDisplayColorVolume_Data>;

  SkHdrMasteringDisplayColorVolume_Data();
  ~SkHdrMasteringDisplayColorVolume_Data() = delete;
};
static_assert(sizeof(SkHdrMasteringDisplayColorVolume_Data) == 24,
              "Bad sizeof(SkHdrMasteringDisplayColorVolume_Data)");
// Used by SkHdrMasteringDisplayColorVolume::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SkHdrMasteringDisplayColorVolume_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SkHdrMasteringDisplayColorVolume_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SkHdrMasteringDisplayColorVolume_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SkHdrMasteringDisplayColorVolume_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SkHdrMasteringDisplayColorVolume_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SkHdrAgtmGainCurveControlPoint_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float x;
  float y;
  float m;
  uint8_t padfinal_[4];

 private:
  friend class mojo::internal::MessageFragment<SkHdrAgtmGainCurveControlPoint_Data>;

  SkHdrAgtmGainCurveControlPoint_Data();
  ~SkHdrAgtmGainCurveControlPoint_Data() = delete;
};
static_assert(sizeof(SkHdrAgtmGainCurveControlPoint_Data) == 24,
              "Bad sizeof(SkHdrAgtmGainCurveControlPoint_Data)");
// Used by SkHdrAgtmGainCurveControlPoint::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SkHdrAgtmGainCurveControlPoint_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SkHdrAgtmGainCurveControlPoint_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SkHdrAgtmGainCurveControlPoint_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SkHdrAgtmGainCurveControlPoint_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SkHdrAgtmGainCurveControlPoint_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SkHdrAgtmGainCurve_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::SkHdrAgtmGainCurveControlPoint_Data>>> control_points;

 private:
  friend class mojo::internal::MessageFragment<SkHdrAgtmGainCurve_Data>;

  SkHdrAgtmGainCurve_Data();
  ~SkHdrAgtmGainCurve_Data() = delete;
};
static_assert(sizeof(SkHdrAgtmGainCurve_Data) == 16,
              "Bad sizeof(SkHdrAgtmGainCurve_Data)");
// Used by SkHdrAgtmGainCurve::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SkHdrAgtmGainCurve_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SkHdrAgtmGainCurve_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SkHdrAgtmGainCurve_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SkHdrAgtmGainCurve_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SkHdrAgtmGainCurve_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SkHdrAgtmComponentMixingFunction_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float red;
  float green;
  float blue;
  float max;
  float min;
  float component;

 private:
  friend class mojo::internal::MessageFragment<SkHdrAgtmComponentMixingFunction_Data>;

  SkHdrAgtmComponentMixingFunction_Data();
  ~SkHdrAgtmComponentMixingFunction_Data() = delete;
};
static_assert(sizeof(SkHdrAgtmComponentMixingFunction_Data) == 32,
              "Bad sizeof(SkHdrAgtmComponentMixingFunction_Data)");
// Used by SkHdrAgtmComponentMixingFunction::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SkHdrAgtmComponentMixingFunction_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SkHdrAgtmComponentMixingFunction_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SkHdrAgtmComponentMixingFunction_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SkHdrAgtmComponentMixingFunction_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SkHdrAgtmComponentMixingFunction_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SkHdrAgtmColorGainFunction_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::SkHdrAgtmComponentMixingFunction_Data> component_mixing;
  mojo::internal::Pointer<internal::SkHdrAgtmGainCurve_Data> gain_curve;

 private:
  friend class mojo::internal::MessageFragment<SkHdrAgtmColorGainFunction_Data>;

  SkHdrAgtmColorGainFunction_Data();
  ~SkHdrAgtmColorGainFunction_Data() = delete;
};
static_assert(sizeof(SkHdrAgtmColorGainFunction_Data) == 24,
              "Bad sizeof(SkHdrAgtmColorGainFunction_Data)");
// Used by SkHdrAgtmColorGainFunction::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SkHdrAgtmColorGainFunction_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SkHdrAgtmColorGainFunction_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SkHdrAgtmColorGainFunction_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SkHdrAgtmColorGainFunction_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SkHdrAgtmColorGainFunction_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SkHdrAgtmAlternateImage_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float hdr_headroom;
  uint8_t pad0_[4];
  mojo::internal::Pointer<internal::SkHdrAgtmColorGainFunction_Data> color_gain_function;

 private:
  friend class mojo::internal::MessageFragment<SkHdrAgtmAlternateImage_Data>;

  SkHdrAgtmAlternateImage_Data();
  ~SkHdrAgtmAlternateImage_Data() = delete;
};
static_assert(sizeof(SkHdrAgtmAlternateImage_Data) == 24,
              "Bad sizeof(SkHdrAgtmAlternateImage_Data)");
// Used by SkHdrAgtmAlternateImage::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SkHdrAgtmAlternateImage_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SkHdrAgtmAlternateImage_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SkHdrAgtmAlternateImage_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SkHdrAgtmAlternateImage_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SkHdrAgtmAlternateImage_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SkHdrAgtmHeadroomAdaptiveToneMap_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float baseline_hdr_headroom;
  uint8_t pad0_[4];
  mojo::internal::Pointer<::skia::mojom::internal::SkColorSpacePrimaries_Data> gain_application_space_primaries;
  mojo::internal::Pointer<mojo::internal::Array_Data<mojo::internal::Pointer<internal::SkHdrAgtmAlternateImage_Data>>> alternate_images;

 private:
  friend class mojo::internal::MessageFragment<SkHdrAgtmHeadroomAdaptiveToneMap_Data>;

  SkHdrAgtmHeadroomAdaptiveToneMap_Data();
  ~SkHdrAgtmHeadroomAdaptiveToneMap_Data() = delete;
};
static_assert(sizeof(SkHdrAgtmHeadroomAdaptiveToneMap_Data) == 32,
              "Bad sizeof(SkHdrAgtmHeadroomAdaptiveToneMap_Data)");
// Used by SkHdrAgtmHeadroomAdaptiveToneMap::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SkHdrAgtmHeadroomAdaptiveToneMap_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SkHdrAgtmHeadroomAdaptiveToneMap_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SkHdrAgtmHeadroomAdaptiveToneMap_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SkHdrAgtmHeadroomAdaptiveToneMap_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SkHdrAgtmHeadroomAdaptiveToneMap_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};
class  SkHdrAdaptiveGlobalToneMap_Data {
 public:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);

  mojo::internal::StructHeader header_;
  float hdr_reference_white;
  uint8_t pad0_[4];
  mojo::internal::Pointer<internal::SkHdrAgtmHeadroomAdaptiveToneMap_Data> headroom_adaptive_tone_map;

 private:
  friend class mojo::internal::MessageFragment<SkHdrAdaptiveGlobalToneMap_Data>;

  SkHdrAdaptiveGlobalToneMap_Data();
  ~SkHdrAdaptiveGlobalToneMap_Data() = delete;
};
static_assert(sizeof(SkHdrAdaptiveGlobalToneMap_Data) == 24,
              "Bad sizeof(SkHdrAdaptiveGlobalToneMap_Data)");
// Used by SkHdrAdaptiveGlobalToneMap::WrapAsMessage to lazily serialize the struct.
template <typename UserType, typename DataView>
struct SkHdrAdaptiveGlobalToneMap_UnserializedMessageContext
    : public mojo::internal::UnserializedMessageContext {
 public:
  static const mojo::internal::UnserializedMessageContext::Tag kMessageTag;

  SkHdrAdaptiveGlobalToneMap_UnserializedMessageContext(
    uint32_t message_name,
    uint32_t message_flags,
    UserType input)
      : mojo::internal::UnserializedMessageContext(&kMessageTag, message_name, message_flags)
      , user_data_(std::move(input)) {}
  ~SkHdrAdaptiveGlobalToneMap_UnserializedMessageContext() override = default;

  UserType TakeData() {
    return std::move(user_data_);
  }

 private:
  // mojo::internal::UnserializedMessageContext:
  void Serialize(mojo::Message& message) override {
    mojo::internal::MessageFragment<SkHdrAdaptiveGlobalToneMap_Data> fragment(message);
    mojo::internal::Serialize<DataView>(user_data_, fragment);
  }

  UserType user_data_;
};

template <typename UserType, typename DataView>
const mojo::internal::UnserializedMessageContext::Tag
    SkHdrAdaptiveGlobalToneMap_UnserializedMessageContext<UserType, DataView>::kMessageTag = {};

#pragma pack(pop)

}  // namespace internal

}  // skia::mojom

#endif  // SKIA_PUBLIC_MOJOM_HDR_METADATA_MOJOM_SHARED_INTERNAL_H_