// ui/gfx/geometry/mojom/geometry.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 UI_GFX_GEOMETRY_MOJOM_GEOMETRY_MOJOM_SHARED_INTERNAL_H_
#define UI_GFX_GEOMETRY_MOJOM_GEOMETRY_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 "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 gfx::mojom {
namespace internal {
class Point_Data;
class PointF_Data;
class Point3F_Data;
class Size_Data;
class SizeF_Data;
class Rect_Data;
class RectF_Data;
class Insets_Data;
class InsetsF_Data;
class Vector2d_Data;
class Vector2dF_Data;
class Vector3dF_Data;
class Quaternion_Data;
class QuadF_Data;
class AxisTransform2d_Data;

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

  mojo::internal::StructHeader header_;
  int32_t x;
  int32_t y;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  float x;
  float y;

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t width;
  int32_t height;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  float width;
  float height;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t x;
  int32_t y;
  int32_t width;
  int32_t height;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  float x;
  float y;
  float width;
  float height;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t top;
  int32_t left;
  int32_t bottom;
  int32_t right;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  float top;
  float left;
  float bottom;
  float right;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  int32_t x;
  int32_t y;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  float x;
  float y;

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

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

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

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

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

  UserType user_data_;
};

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

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

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  double x;
  double y;
  double z;
  double w;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::PointF_Data> p1;
  mojo::internal::Pointer<internal::PointF_Data> p2;
  mojo::internal::Pointer<internal::PointF_Data> p3;
  mojo::internal::Pointer<internal::PointF_Data> p4;

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

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

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

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

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

  UserType user_data_;
};

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

  mojo::internal::StructHeader header_;
  mojo::internal::Pointer<internal::Vector2dF_Data> scale;
  mojo::internal::Pointer<internal::Vector2dF_Data> translation;

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

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

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

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

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

  UserType user_data_;
};

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

#pragma pack(pop)

}  // namespace internal

}  // gfx::mojom

#endif  // UI_GFX_GEOMETRY_MOJOM_GEOMETRY_MOJOM_SHARED_INTERNAL_H_