win-Debug/gen/services/viz/public/interfaces/hit_test/hit_test_region_list.mojom.h

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

#ifndef SERVICES_VIZ_PUBLIC_INTERFACES_HIT_TEST_HIT_TEST_REGION_LIST_MOJOM_H_
#define SERVICES_VIZ_PUBLIC_INTERFACES_HIT_TEST_HIT_TEST_REGION_LIST_MOJOM_H_

#include <stdint.h>

#include <limits>
#include <type_traits>
#include <utility>

#include "base/callback.h"
#include "base/macros.h"
#include "base/optional.h"

#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#if BUILDFLAG(MOJO_TRACE_ENABLED)
#include "base/trace_event/trace_event.h"
#endif
#include "mojo/public/cpp/bindings/clone_traits.h"
#include "mojo/public/cpp/bindings/equals_traits.h"
#include "mojo/public/cpp/bindings/lib/serialization.h"
#include "mojo/public/cpp/bindings/struct_ptr.h"
#include "mojo/public/cpp/bindings/struct_traits.h"
#include "mojo/public/cpp/bindings/union_traits.h"
#include "services/viz/public/interfaces/hit_test/hit_test_region_list.mojom-shared.h"
#include "services/viz/public/interfaces/hit_test/hit_test_region_list.mojom-forward.h"
#include "services/viz/public/interfaces/compositing/frame_sink_id.mojom.h"
#include "services/viz/public/interfaces/compositing/surface_id.mojom.h"
#include "ui/gfx/geometry/mojo/geometry.mojom.h"
#include "ui/gfx/mojo/transform.mojom.h"
#include <string>
#include <vector>

#include "mojo/public/cpp/bindings/associated_interface_ptr.h"
#include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
#include "mojo/public/cpp/bindings/associated_interface_request.h"
#include "mojo/public/cpp/bindings/interface_ptr.h"
#include "mojo/public/cpp/bindings/interface_request.h"
#include "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"
#include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h"


#include "mojo/public/cpp/bindings/lib/native_enum_serialization.h"
#include "mojo/public/cpp/bindings/lib/native_struct_serialization.h"
#include "components/viz/common/hit_test/hit_test_region_list.h"

#ifdef KYTHE_IS_RUNNING
#pragma kythe_inline_metadata "Metadata comment"
#endif


namespace viz {
namespace mojom {









// @generated_from: viz.mojom.HitTestRegion
class  HitTestRegion {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<HitTestRegion, T>::value>;
  using DataView = HitTestRegionDataView;
  using Data_ = internal::HitTestRegion_Data;

  template <typename... Args>
  static HitTestRegionPtr New(Args&&... args) {
    return HitTestRegionPtr(
        base::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static HitTestRegionPtr From(const U& u) {
    return mojo::TypeConverter<HitTestRegionPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, HitTestRegion>::Convert(*this);
  }


  HitTestRegion();

  HitTestRegion(
      uint32_t flags,
      uint32_t async_hit_test_reasons,
      const viz::FrameSinkId& frame_sink_id,
      const gfx::Rect& rect,
      const gfx::Transform& transform);

  ~HitTestRegion();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = HitTestRegionPtr>
  HitTestRegionPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, HitTestRegion::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        HitTestRegion::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        HitTestRegion::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::HitTestRegion_UnserializedMessageContext<
            UserType, HitTestRegion::DataView>>(0, 0, std::move(input)));
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    return mojo::internal::DeserializeImpl<HitTestRegion::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return HitTestRegion::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::HitTestRegion_UnserializedMessageContext<
            UserType, HitTestRegion::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<HitTestRegion::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: viz.mojom.HitTestRegion.flags
  uint32_t flags;
  
// @generated_from: viz.mojom.HitTestRegion.async_hit_test_reasons
  uint32_t async_hit_test_reasons;
  
// @generated_from: viz.mojom.HitTestRegion.frame_sink_id
  viz::FrameSinkId frame_sink_id;
  
// @generated_from: viz.mojom.HitTestRegion.rect
  gfx::Rect rect;
  
// @generated_from: viz.mojom.HitTestRegion.transform
  gfx::Transform transform;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, HitTestRegion::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, HitTestRegion::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, HitTestRegion::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, HitTestRegion::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}





// @generated_from: viz.mojom.HitTestRegionList
class  HitTestRegionList {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<HitTestRegionList, T>::value>;
  using DataView = HitTestRegionListDataView;
  using Data_ = internal::HitTestRegionList_Data;

  template <typename... Args>
  static HitTestRegionListPtr New(Args&&... args) {
    return HitTestRegionListPtr(
        base::in_place, std::forward<Args>(args)...);
  }

  template <typename U>
  static HitTestRegionListPtr From(const U& u) {
    return mojo::TypeConverter<HitTestRegionListPtr, U>::Convert(u);
  }

  template <typename U>
  U To() const {
    return mojo::TypeConverter<U, HitTestRegionList>::Convert(*this);
  }


  HitTestRegionList();

  HitTestRegionList(
      uint32_t flags,
      uint32_t async_hit_test_reasons,
      const gfx::Rect& bounds,
      const gfx::Transform& transform,
      const std::vector<viz::HitTestRegion>& regions);

  ~HitTestRegionList();

  // Clone() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Clone() or copy
  // constructor/assignment are available for members.
  template <typename StructPtrType = HitTestRegionListPtr>
  HitTestRegionListPtr Clone() const;

  // Equals() is a template so it is only instantiated if it is used. Thus, the
  // bindings generator does not need to know whether Equals() or == operator
  // are available for members.
  template <typename T, HitTestRegionList::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename UserType>
  static std::vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        HitTestRegionList::DataView, std::vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        HitTestRegionList::DataView>(input);
  }

  // The returned Message is serialized only if the message is moved
  // cross-process or cross-language. Otherwise if the message is Deserialized
  // as the same UserType |input| will just be moved to |output| in
  // DeserializeFromMessage.
  template <typename UserType>
  static mojo::Message WrapAsMessage(UserType input) {
    return mojo::Message(std::make_unique<
        internal::HitTestRegionList_UnserializedMessageContext<
            UserType, HitTestRegionList::DataView>>(0, 0, std::move(input)));
  }

  template <typename UserType>
  static bool Deserialize(const void* data,
                          size_t data_num_bytes,
                          UserType* output) {
    return mojo::internal::DeserializeImpl<HitTestRegionList::DataView>(
        data, data_num_bytes, std::vector<mojo::ScopedHandle>(), output, Validate);
  }

  template <typename UserType>
  static bool Deserialize(const std::vector<uint8_t>& input,
                          UserType* output) {
    return HitTestRegionList::Deserialize(
        input.size() == 0 ? nullptr : &input.front(), input.size(), output);
  }

  template <typename UserType>
  static bool DeserializeFromMessage(mojo::Message input,
                                     UserType* output) {
    auto context = input.TakeUnserializedContext<
        internal::HitTestRegionList_UnserializedMessageContext<
            UserType, HitTestRegionList::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<HitTestRegionList::DataView>(
        input.payload(), input.payload_num_bytes(),
        std::move(*input.mutable_handles()), output, Validate);
  }

  
// @generated_from: viz.mojom.HitTestRegionList.flags
  uint32_t flags;
  
// @generated_from: viz.mojom.HitTestRegionList.async_hit_test_reasons
  uint32_t async_hit_test_reasons;
  
// @generated_from: viz.mojom.HitTestRegionList.bounds
  gfx::Rect bounds;
  
// @generated_from: viz.mojom.HitTestRegionList.transform
  gfx::Transform transform;
  
// @generated_from: viz.mojom.HitTestRegionList.regions
  std::vector<viz::HitTestRegion> regions;

 private:
  static bool Validate(const void* data,
                       mojo::internal::ValidationContext* validation_context);
};

// The comparison operators are templates, so they are only instantiated if they
// are used. Thus, the bindings generator does not need to know whether
// comparison operators are available for members.
template <typename T, HitTestRegionList::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

template <typename T, HitTestRegionList::EnableIfSame<T>* = nullptr>
bool operator<=(const T& lhs, const T& rhs) {
  return !(rhs < lhs);
}

template <typename T, HitTestRegionList::EnableIfSame<T>* = nullptr>
bool operator>(const T& lhs, const T& rhs) {
  return rhs < lhs;
}

template <typename T, HitTestRegionList::EnableIfSame<T>* = nullptr>
bool operator>=(const T& lhs, const T& rhs) {
  return !(lhs < rhs);
}

template <typename StructPtrType>
HitTestRegionPtr HitTestRegion::Clone() const {
  return New(
      mojo::Clone(flags),
      mojo::Clone(async_hit_test_reasons),
      mojo::Clone(frame_sink_id),
      mojo::Clone(rect),
      mojo::Clone(transform)
  );
}

template <typename T, HitTestRegion::EnableIfSame<T>*>
bool HitTestRegion::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->flags, other_struct.flags))
    return false;
  if (!mojo::Equals(this->async_hit_test_reasons, other_struct.async_hit_test_reasons))
    return false;
  if (!mojo::Equals(this->frame_sink_id, other_struct.frame_sink_id))
    return false;
  if (!mojo::Equals(this->rect, other_struct.rect))
    return false;
  if (!mojo::Equals(this->transform, other_struct.transform))
    return false;
  return true;
}

template <typename T, HitTestRegion::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.flags < rhs.flags)
    return true;
  if (rhs.flags < lhs.flags)
    return false;
  if (lhs.async_hit_test_reasons < rhs.async_hit_test_reasons)
    return true;
  if (rhs.async_hit_test_reasons < lhs.async_hit_test_reasons)
    return false;
  if (lhs.frame_sink_id < rhs.frame_sink_id)
    return true;
  if (rhs.frame_sink_id < lhs.frame_sink_id)
    return false;
  if (lhs.rect < rhs.rect)
    return true;
  if (rhs.rect < lhs.rect)
    return false;
  if (lhs.transform < rhs.transform)
    return true;
  if (rhs.transform < lhs.transform)
    return false;
  return false;
}
template <typename StructPtrType>
HitTestRegionListPtr HitTestRegionList::Clone() const {
  return New(
      mojo::Clone(flags),
      mojo::Clone(async_hit_test_reasons),
      mojo::Clone(bounds),
      mojo::Clone(transform),
      mojo::Clone(regions)
  );
}

template <typename T, HitTestRegionList::EnableIfSame<T>*>
bool HitTestRegionList::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->flags, other_struct.flags))
    return false;
  if (!mojo::Equals(this->async_hit_test_reasons, other_struct.async_hit_test_reasons))
    return false;
  if (!mojo::Equals(this->bounds, other_struct.bounds))
    return false;
  if (!mojo::Equals(this->transform, other_struct.transform))
    return false;
  if (!mojo::Equals(this->regions, other_struct.regions))
    return false;
  return true;
}

template <typename T, HitTestRegionList::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.flags < rhs.flags)
    return true;
  if (rhs.flags < lhs.flags)
    return false;
  if (lhs.async_hit_test_reasons < rhs.async_hit_test_reasons)
    return true;
  if (rhs.async_hit_test_reasons < lhs.async_hit_test_reasons)
    return false;
  if (lhs.bounds < rhs.bounds)
    return true;
  if (rhs.bounds < lhs.bounds)
    return false;
  if (lhs.transform < rhs.transform)
    return true;
  if (rhs.transform < lhs.transform)
    return false;
  if (lhs.regions < rhs.regions)
    return true;
  if (rhs.regions < lhs.regions)
    return false;
  return false;
}


}  // namespace mojom
}  // namespace viz

namespace mojo {


template <>
struct  StructTraits<::viz::mojom::HitTestRegion::DataView,
                                         ::viz::mojom::HitTestRegionPtr> {
  static bool IsNull(const ::viz::mojom::HitTestRegionPtr& input) { return !input; }
  static void SetToNull(::viz::mojom::HitTestRegionPtr* output) { output->reset(); }

  static decltype(::viz::mojom::HitTestRegion::flags) flags(
      const ::viz::mojom::HitTestRegionPtr& input) {
    return input->flags;
  }

  static decltype(::viz::mojom::HitTestRegion::async_hit_test_reasons) async_hit_test_reasons(
      const ::viz::mojom::HitTestRegionPtr& input) {
    return input->async_hit_test_reasons;
  }

  static const decltype(::viz::mojom::HitTestRegion::frame_sink_id)& frame_sink_id(
      const ::viz::mojom::HitTestRegionPtr& input) {
    return input->frame_sink_id;
  }

  static const decltype(::viz::mojom::HitTestRegion::rect)& rect(
      const ::viz::mojom::HitTestRegionPtr& input) {
    return input->rect;
  }

  static const decltype(::viz::mojom::HitTestRegion::transform)& transform(
      const ::viz::mojom::HitTestRegionPtr& input) {
    return input->transform;
  }

  static bool Read(::viz::mojom::HitTestRegion::DataView input, ::viz::mojom::HitTestRegionPtr* output);
};


template <>
struct  StructTraits<::viz::mojom::HitTestRegionList::DataView,
                                         ::viz::mojom::HitTestRegionListPtr> {
  static bool IsNull(const ::viz::mojom::HitTestRegionListPtr& input) { return !input; }
  static void SetToNull(::viz::mojom::HitTestRegionListPtr* output) { output->reset(); }

  static decltype(::viz::mojom::HitTestRegionList::flags) flags(
      const ::viz::mojom::HitTestRegionListPtr& input) {
    return input->flags;
  }

  static decltype(::viz::mojom::HitTestRegionList::async_hit_test_reasons) async_hit_test_reasons(
      const ::viz::mojom::HitTestRegionListPtr& input) {
    return input->async_hit_test_reasons;
  }

  static const decltype(::viz::mojom::HitTestRegionList::bounds)& bounds(
      const ::viz::mojom::HitTestRegionListPtr& input) {
    return input->bounds;
  }

  static const decltype(::viz::mojom::HitTestRegionList::transform)& transform(
      const ::viz::mojom::HitTestRegionListPtr& input) {
    return input->transform;
  }

  static const decltype(::viz::mojom::HitTestRegionList::regions)& regions(
      const ::viz::mojom::HitTestRegionListPtr& input) {
    return input->regions;
  }

  static bool Read(::viz::mojom::HitTestRegionList::DataView input, ::viz::mojom::HitTestRegionListPtr* output);
};

}  // namespace mojo

#endif  // SERVICES_VIZ_PUBLIC_INTERFACES_HIT_TEST_HIT_TEST_REGION_LIST_MOJOM_H_
/* Metadata comment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*/