Debug/gen/gpu/ipc/common/gpu_info.mojom-blink.h

// gpu/ipc/common/gpu_info.mojom-blink.h is auto generated by mojom_bindings_generator.py, do not edit

// 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 GPU_IPC_COMMON_GPU_INFO_MOJOM_BLINK_H_
#define GPU_IPC_COMMON_GPU_INFO_MOJOM_BLINK_H_

#include <stdint.h>

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

#include "third_party/abseil-cpp/absl/types/optional.h"
#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 "third_party/perfetto/include/perfetto/tracing/traced_value_forward.h"

#include "gpu/ipc/common/gpu_info.mojom-shared.h"
#include "gpu/ipc/common/gpu_info.mojom-blink-forward.h"
#include "gpu/ipc/common/dx_diag_node.mojom-blink-forward.h"
#include "mojo/public/mojom/base/time.mojom-blink.h"
#include "ui/gfx/geometry/mojom/geometry.mojom-blink.h"
#include "ui/gl/mojom/gpu_preference.mojom-blink-forward.h"
#include "gpu/ipc/common/vulkan_info.mojom-blink.h"

#include "mojo/public/cpp/bindings/lib/wtf_clone_equals_util.h"
#include "mojo/public/cpp/bindings/lib/wtf_hash_util.h"
#include "third_party/blink/renderer/platform/wtf/hash_functions.h"
#include "third_party/blink/renderer/platform/wtf/text/wtf_string.h"




#include "third_party/blink/public/platform/web_common.h"

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


namespace WTF {
struct gpu_mojom_internal_VideoCodecProfile_DataHashFn {
  static unsigned GetHash(const ::gpu::mojom::VideoCodecProfile& value) {
    using utype = std::underlying_type<::gpu::mojom::VideoCodecProfile>::type;
    return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
  }
  static bool Equal(const ::gpu::mojom::VideoCodecProfile& left, const ::gpu::mojom::VideoCodecProfile& right) {
    return left == right;
  }
  static const bool safe_to_compare_to_empty_or_deleted = true;
};

template <>
struct HashTraits<::gpu::mojom::VideoCodecProfile>
    : public GenericHashTraits<::gpu::mojom::VideoCodecProfile> {
  static_assert(true,
                "-1000000 is a reserved enum value");
  static_assert(true,
                "-1000001 is a reserved enum value");
  static const bool kEmptyValueIsZero = false;
  static ::gpu::mojom::VideoCodecProfile EmptyValue() { return static_cast<::gpu::mojom::VideoCodecProfile>(-1000000); }
  static void ConstructDeletedValue(::gpu::mojom::VideoCodecProfile& slot, bool) {
    slot = static_cast<::gpu::mojom::VideoCodecProfile>(-1000001);
  }
  static bool IsDeletedValue(const ::gpu::mojom::VideoCodecProfile& value) {
    return value == static_cast<::gpu::mojom::VideoCodecProfile>(-1000001);
  }
};
}  // namespace WTF


namespace WTF {
struct gpu_mojom_internal_ImageDecodeAcceleratorType_DataHashFn {
  static unsigned GetHash(const ::gpu::mojom::ImageDecodeAcceleratorType& value) {
    using utype = std::underlying_type<::gpu::mojom::ImageDecodeAcceleratorType>::type;
    return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
  }
  static bool Equal(const ::gpu::mojom::ImageDecodeAcceleratorType& left, const ::gpu::mojom::ImageDecodeAcceleratorType& right) {
    return left == right;
  }
  static const bool safe_to_compare_to_empty_or_deleted = true;
};

template <>
struct HashTraits<::gpu::mojom::ImageDecodeAcceleratorType>
    : public GenericHashTraits<::gpu::mojom::ImageDecodeAcceleratorType> {
  static_assert(true,
                "-1000000 is a reserved enum value");
  static_assert(true,
                "-1000001 is a reserved enum value");
  static const bool kEmptyValueIsZero = false;
  static ::gpu::mojom::ImageDecodeAcceleratorType EmptyValue() { return static_cast<::gpu::mojom::ImageDecodeAcceleratorType>(-1000000); }
  static void ConstructDeletedValue(::gpu::mojom::ImageDecodeAcceleratorType& slot, bool) {
    slot = static_cast<::gpu::mojom::ImageDecodeAcceleratorType>(-1000001);
  }
  static bool IsDeletedValue(const ::gpu::mojom::ImageDecodeAcceleratorType& value) {
    return value == static_cast<::gpu::mojom::ImageDecodeAcceleratorType>(-1000001);
  }
};
}  // namespace WTF


namespace WTF {
struct gpu_mojom_internal_ImageDecodeAcceleratorSubsampling_DataHashFn {
  static unsigned GetHash(const ::gpu::mojom::ImageDecodeAcceleratorSubsampling& value) {
    using utype = std::underlying_type<::gpu::mojom::ImageDecodeAcceleratorSubsampling>::type;
    return DefaultHash<utype>::Hash().GetHash(static_cast<utype>(value));
  }
  static bool Equal(const ::gpu::mojom::ImageDecodeAcceleratorSubsampling& left, const ::gpu::mojom::ImageDecodeAcceleratorSubsampling& right) {
    return left == right;
  }
  static const bool safe_to_compare_to_empty_or_deleted = true;
};

template <>
struct HashTraits<::gpu::mojom::ImageDecodeAcceleratorSubsampling>
    : public GenericHashTraits<::gpu::mojom::ImageDecodeAcceleratorSubsampling> {
  static_assert(true,
                "-1000000 is a reserved enum value");
  static_assert(true,
                "-1000001 is a reserved enum value");
  static const bool kEmptyValueIsZero = false;
  static ::gpu::mojom::ImageDecodeAcceleratorSubsampling EmptyValue() { return static_cast<::gpu::mojom::ImageDecodeAcceleratorSubsampling>(-1000000); }
  static void ConstructDeletedValue(::gpu::mojom::ImageDecodeAcceleratorSubsampling& slot, bool) {
    slot = static_cast<::gpu::mojom::ImageDecodeAcceleratorSubsampling>(-1000001);
  }
  static bool IsDeletedValue(const ::gpu::mojom::ImageDecodeAcceleratorSubsampling& value) {
    return value == static_cast<::gpu::mojom::ImageDecodeAcceleratorSubsampling>(-1000001);
  }
};
}  // namespace WTF


namespace gpu {
namespace mojom {
namespace blink {













// @generated_from: gpu.mojom.GpuDevice
class BLINK_PLATFORM_EXPORT GpuDevice {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GpuDevice, T>::value>;
  using DataView = GpuDeviceDataView;
  using Data_ = internal::GpuDevice_Data;

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

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

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


  GpuDevice();

  GpuDevice(
      uint32_t vendor_id,
      uint32_t device_id,
      bool active,
      const WTF::String& vendor_string,
      const WTF::String& device_string,
      const WTF::String& driver_vendor,
      const WTF::String& driver_version,
      int32_t cuda_compute_capability_major,
      ::gl::mojom::blink::GpuPreference gpu_preference);


  ~GpuDevice();

  // 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 = GpuDevicePtr>
  GpuDevicePtr 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, GpuDevice::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, GpuDevice::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  size_t Hash(size_t seed) const;
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        GpuDevice::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        GpuDevice::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::GpuDevice_UnserializedMessageContext<
            UserType, GpuDevice::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return GpuDevice::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::GpuDevice_UnserializedMessageContext<
            UserType, GpuDevice::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<GpuDevice::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: gpu.mojom.GpuDevice.vendor_id
  uint32_t vendor_id;
  
// @generated_from: gpu.mojom.GpuDevice.device_id
  uint32_t device_id;
  
// @generated_from: gpu.mojom.GpuDevice.active
  bool active;
  
// @generated_from: gpu.mojom.GpuDevice.vendor_string
  WTF::String vendor_string;
  
// @generated_from: gpu.mojom.GpuDevice.device_string
  WTF::String device_string;
  
// @generated_from: gpu.mojom.GpuDevice.driver_vendor
  WTF::String driver_vendor;
  
// @generated_from: gpu.mojom.GpuDevice.driver_version
  WTF::String driver_version;
  
// @generated_from: gpu.mojom.GpuDevice.cuda_compute_capability_major
  int32_t cuda_compute_capability_major;
  
// @generated_from: gpu.mojom.GpuDevice.gpu_preference
  ::gl::mojom::blink::GpuPreference gpu_preference;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, GpuDevice::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





// @generated_from: gpu.mojom.VideoDecodeAcceleratorSupportedProfile
class BLINK_PLATFORM_EXPORT VideoDecodeAcceleratorSupportedProfile {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<VideoDecodeAcceleratorSupportedProfile, T>::value>;
  using DataView = VideoDecodeAcceleratorSupportedProfileDataView;
  using Data_ = internal::VideoDecodeAcceleratorSupportedProfile_Data;

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

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

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


  VideoDecodeAcceleratorSupportedProfile();

  VideoDecodeAcceleratorSupportedProfile(
      VideoCodecProfile profile,
      const ::gfx::Size& max_resolution,
      const ::gfx::Size& min_resolution,
      bool encrypted_only);


  ~VideoDecodeAcceleratorSupportedProfile();

  // 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 = VideoDecodeAcceleratorSupportedProfilePtr>
  VideoDecodeAcceleratorSupportedProfilePtr 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, VideoDecodeAcceleratorSupportedProfile::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, VideoDecodeAcceleratorSupportedProfile::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        VideoDecodeAcceleratorSupportedProfile::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        VideoDecodeAcceleratorSupportedProfile::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::VideoDecodeAcceleratorSupportedProfile_UnserializedMessageContext<
            UserType, VideoDecodeAcceleratorSupportedProfile::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return VideoDecodeAcceleratorSupportedProfile::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::VideoDecodeAcceleratorSupportedProfile_UnserializedMessageContext<
            UserType, VideoDecodeAcceleratorSupportedProfile::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<VideoDecodeAcceleratorSupportedProfile::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: gpu.mojom.VideoDecodeAcceleratorSupportedProfile.profile
  VideoCodecProfile profile;
  
// @generated_from: gpu.mojom.VideoDecodeAcceleratorSupportedProfile.max_resolution
  ::gfx::Size max_resolution;
  
// @generated_from: gpu.mojom.VideoDecodeAcceleratorSupportedProfile.min_resolution
  ::gfx::Size min_resolution;
  
// @generated_from: gpu.mojom.VideoDecodeAcceleratorSupportedProfile.encrypted_only
  bool encrypted_only;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, VideoDecodeAcceleratorSupportedProfile::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





// @generated_from: gpu.mojom.VideoDecodeAcceleratorCapabilities
class BLINK_PLATFORM_EXPORT VideoDecodeAcceleratorCapabilities {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<VideoDecodeAcceleratorCapabilities, T>::value>;
  using DataView = VideoDecodeAcceleratorCapabilitiesDataView;
  using Data_ = internal::VideoDecodeAcceleratorCapabilities_Data;

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

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

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


  VideoDecodeAcceleratorCapabilities();

  VideoDecodeAcceleratorCapabilities(
      WTF::Vector<VideoDecodeAcceleratorSupportedProfilePtr> supported_profiles,
      uint32_t flags);

VideoDecodeAcceleratorCapabilities(const VideoDecodeAcceleratorCapabilities&) = delete;
VideoDecodeAcceleratorCapabilities& operator=(const VideoDecodeAcceleratorCapabilities&) = delete;

  ~VideoDecodeAcceleratorCapabilities();

  // 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 = VideoDecodeAcceleratorCapabilitiesPtr>
  VideoDecodeAcceleratorCapabilitiesPtr 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, VideoDecodeAcceleratorCapabilities::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, VideoDecodeAcceleratorCapabilities::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        VideoDecodeAcceleratorCapabilities::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        VideoDecodeAcceleratorCapabilities::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::VideoDecodeAcceleratorCapabilities_UnserializedMessageContext<
            UserType, VideoDecodeAcceleratorCapabilities::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return VideoDecodeAcceleratorCapabilities::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::VideoDecodeAcceleratorCapabilities_UnserializedMessageContext<
            UserType, VideoDecodeAcceleratorCapabilities::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<VideoDecodeAcceleratorCapabilities::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: gpu.mojom.VideoDecodeAcceleratorCapabilities.supported_profiles
  WTF::Vector<VideoDecodeAcceleratorSupportedProfilePtr> supported_profiles;
  
// @generated_from: gpu.mojom.VideoDecodeAcceleratorCapabilities.flags
  uint32_t flags;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, VideoDecodeAcceleratorCapabilities::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





// @generated_from: gpu.mojom.VideoEncodeAcceleratorSupportedProfile
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorSupportedProfile {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<VideoEncodeAcceleratorSupportedProfile, T>::value>;
  using DataView = VideoEncodeAcceleratorSupportedProfileDataView;
  using Data_ = internal::VideoEncodeAcceleratorSupportedProfile_Data;

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

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

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


  VideoEncodeAcceleratorSupportedProfile();

  VideoEncodeAcceleratorSupportedProfile(
      VideoCodecProfile profile,
      const ::gfx::Size& min_resolution,
      const ::gfx::Size& max_resolution,
      uint32_t max_framerate_numerator,
      uint32_t max_framerate_denominator);


  ~VideoEncodeAcceleratorSupportedProfile();

  // 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 = VideoEncodeAcceleratorSupportedProfilePtr>
  VideoEncodeAcceleratorSupportedProfilePtr 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, VideoEncodeAcceleratorSupportedProfile::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, VideoEncodeAcceleratorSupportedProfile::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        VideoEncodeAcceleratorSupportedProfile::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        VideoEncodeAcceleratorSupportedProfile::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::VideoEncodeAcceleratorSupportedProfile_UnserializedMessageContext<
            UserType, VideoEncodeAcceleratorSupportedProfile::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return VideoEncodeAcceleratorSupportedProfile::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::VideoEncodeAcceleratorSupportedProfile_UnserializedMessageContext<
            UserType, VideoEncodeAcceleratorSupportedProfile::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<VideoEncodeAcceleratorSupportedProfile::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: gpu.mojom.VideoEncodeAcceleratorSupportedProfile.profile
  VideoCodecProfile profile;
  
// @generated_from: gpu.mojom.VideoEncodeAcceleratorSupportedProfile.min_resolution
  ::gfx::Size min_resolution;
  
// @generated_from: gpu.mojom.VideoEncodeAcceleratorSupportedProfile.max_resolution
  ::gfx::Size max_resolution;
  
// @generated_from: gpu.mojom.VideoEncodeAcceleratorSupportedProfile.max_framerate_numerator
  uint32_t max_framerate_numerator;
  
// @generated_from: gpu.mojom.VideoEncodeAcceleratorSupportedProfile.max_framerate_denominator
  uint32_t max_framerate_denominator;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, VideoEncodeAcceleratorSupportedProfile::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





// @generated_from: gpu.mojom.ImageDecodeAcceleratorSupportedProfile
class BLINK_PLATFORM_EXPORT ImageDecodeAcceleratorSupportedProfile {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<ImageDecodeAcceleratorSupportedProfile, T>::value>;
  using DataView = ImageDecodeAcceleratorSupportedProfileDataView;
  using Data_ = internal::ImageDecodeAcceleratorSupportedProfile_Data;

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

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

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


  ImageDecodeAcceleratorSupportedProfile();

  ImageDecodeAcceleratorSupportedProfile(
      ImageDecodeAcceleratorType image_type,
      const ::gfx::Size& min_encoded_dimensions,
      const ::gfx::Size& max_encoded_dimensions,
      WTF::Vector<ImageDecodeAcceleratorSubsampling> subsamplings);


  ~ImageDecodeAcceleratorSupportedProfile();

  // 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 = ImageDecodeAcceleratorSupportedProfilePtr>
  ImageDecodeAcceleratorSupportedProfilePtr 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, ImageDecodeAcceleratorSupportedProfile::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, ImageDecodeAcceleratorSupportedProfile::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        ImageDecodeAcceleratorSupportedProfile::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        ImageDecodeAcceleratorSupportedProfile::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::ImageDecodeAcceleratorSupportedProfile_UnserializedMessageContext<
            UserType, ImageDecodeAcceleratorSupportedProfile::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return ImageDecodeAcceleratorSupportedProfile::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::ImageDecodeAcceleratorSupportedProfile_UnserializedMessageContext<
            UserType, ImageDecodeAcceleratorSupportedProfile::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<ImageDecodeAcceleratorSupportedProfile::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: gpu.mojom.ImageDecodeAcceleratorSupportedProfile.image_type
  ImageDecodeAcceleratorType image_type;
  
// @generated_from: gpu.mojom.ImageDecodeAcceleratorSupportedProfile.min_encoded_dimensions
  ::gfx::Size min_encoded_dimensions;
  
// @generated_from: gpu.mojom.ImageDecodeAcceleratorSupportedProfile.max_encoded_dimensions
  ::gfx::Size max_encoded_dimensions;
  
// @generated_from: gpu.mojom.ImageDecodeAcceleratorSupportedProfile.subsamplings
  WTF::Vector<ImageDecodeAcceleratorSubsampling> subsamplings;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, ImageDecodeAcceleratorSupportedProfile::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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





// @generated_from: gpu.mojom.GpuInfo
class BLINK_PLATFORM_EXPORT GpuInfo {
 public:
  template <typename T>
  using EnableIfSame = std::enable_if_t<std::is_same<GpuInfo, T>::value>;
  using DataView = GpuInfoDataView;
  using Data_ = internal::GpuInfo_Data;

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

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

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


  GpuInfo();

  GpuInfo(
      ::base::TimeDelta initialization_time,
      bool optimus,
      bool amd_switchable,
      GpuDevicePtr gpu,
      WTF::Vector<GpuDevicePtr> secondary_gpus,
      const WTF::String& pixel_shader_version,
      const WTF::String& vertex_shader_version,
      const WTF::String& max_msaa_samples,
      const WTF::String& machine_model_name,
      const WTF::String& machine_model_version,
      const WTF::String& gl_version,
      const WTF::String& gl_vendor,
      const WTF::String& gl_renderer,
      const WTF::String& gl_extensions,
      const WTF::String& gl_ws_vendor,
      const WTF::String& gl_ws_version,
      const WTF::String& gl_ws_extensions,
      uint32_t gl_reset_notification_strategy,
      bool software_rendering,
      const WTF::String& direct_rendering_version,
      bool sandboxed,
      bool in_process_gpu,
      bool passthrough_cmd_decoder,
      bool can_support_threaded_texture_mailbox,
      WTF::Vector<VideoDecodeAcceleratorSupportedProfilePtr> video_decode_accelerator_supported_profiles,
      WTF::Vector<VideoEncodeAcceleratorSupportedProfilePtr> video_encode_accelerator_supported_profiles,
      bool jpeg_decode_accelerator_supported,
      WTF::Vector<ImageDecodeAcceleratorSupportedProfilePtr> image_decode_accelerator_supported_profiles,
      bool subpixel_font_rendering,
      uint32_t visibility_callback_call_count,
      ::gpu::mojom::blink::VulkanInfoPtr vulkan_info);

GpuInfo(const GpuInfo&) = delete;
GpuInfo& operator=(const GpuInfo&) = delete;

  ~GpuInfo();

  // 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 = GpuInfoPtr>
  GpuInfoPtr 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, GpuInfo::EnableIfSame<T>* = nullptr>
  bool Equals(const T& other) const;

  template <typename T, GpuInfo::EnableIfSame<T>* = nullptr>
  bool operator==(const T& rhs) const { return Equals(rhs); }
  template <typename UserType>
  static WTF::Vector<uint8_t> Serialize(UserType* input) {
    return mojo::internal::SerializeImpl<
        GpuInfo::DataView, WTF::Vector<uint8_t>>(input);
  }

  template <typename UserType>
  static mojo::Message SerializeAsMessage(UserType* input) {
    return mojo::internal::SerializeAsMessageImpl<
        GpuInfo::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::GpuInfo_UnserializedMessageContext<
            UserType, GpuInfo::DataView>>(0, 0, std::move(input)),
        MOJO_CREATE_MESSAGE_FLAG_NONE);
  }

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

  template <typename UserType>
  static bool Deserialize(const WTF::Vector<uint8_t>& input,
                          UserType* output) {
    return GpuInfo::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::GpuInfo_UnserializedMessageContext<
            UserType, GpuInfo::DataView>>();
    if (context) {
      *output = std::move(context->TakeData());
      return true;
    }
    input.SerializeIfNecessary();
    return mojo::internal::DeserializeImpl<GpuInfo::DataView>(
        input, input.payload(), input.payload_num_bytes(), output, Validate);
  }

  
// @generated_from: gpu.mojom.GpuInfo.initialization_time
  ::base::TimeDelta initialization_time;
  
// @generated_from: gpu.mojom.GpuInfo.optimus
  bool optimus;
  
// @generated_from: gpu.mojom.GpuInfo.amd_switchable
  bool amd_switchable;
  
// @generated_from: gpu.mojom.GpuInfo.gpu
  GpuDevicePtr gpu;
  
// @generated_from: gpu.mojom.GpuInfo.secondary_gpus
  WTF::Vector<GpuDevicePtr> secondary_gpus;
  
// @generated_from: gpu.mojom.GpuInfo.pixel_shader_version
  WTF::String pixel_shader_version;
  
// @generated_from: gpu.mojom.GpuInfo.vertex_shader_version
  WTF::String vertex_shader_version;
  
// @generated_from: gpu.mojom.GpuInfo.max_msaa_samples
  WTF::String max_msaa_samples;
  
// @generated_from: gpu.mojom.GpuInfo.machine_model_name
  WTF::String machine_model_name;
  
// @generated_from: gpu.mojom.GpuInfo.machine_model_version
  WTF::String machine_model_version;
  
// @generated_from: gpu.mojom.GpuInfo.gl_version
  WTF::String gl_version;
  
// @generated_from: gpu.mojom.GpuInfo.gl_vendor
  WTF::String gl_vendor;
  
// @generated_from: gpu.mojom.GpuInfo.gl_renderer
  WTF::String gl_renderer;
  
// @generated_from: gpu.mojom.GpuInfo.gl_extensions
  WTF::String gl_extensions;
  
// @generated_from: gpu.mojom.GpuInfo.gl_ws_vendor
  WTF::String gl_ws_vendor;
  
// @generated_from: gpu.mojom.GpuInfo.gl_ws_version
  WTF::String gl_ws_version;
  
// @generated_from: gpu.mojom.GpuInfo.gl_ws_extensions
  WTF::String gl_ws_extensions;
  
// @generated_from: gpu.mojom.GpuInfo.gl_reset_notification_strategy
  uint32_t gl_reset_notification_strategy;
  
// @generated_from: gpu.mojom.GpuInfo.software_rendering
  bool software_rendering;
  
// @generated_from: gpu.mojom.GpuInfo.direct_rendering_version
  WTF::String direct_rendering_version;
  
// @generated_from: gpu.mojom.GpuInfo.sandboxed
  bool sandboxed;
  
// @generated_from: gpu.mojom.GpuInfo.in_process_gpu
  bool in_process_gpu;
  
// @generated_from: gpu.mojom.GpuInfo.passthrough_cmd_decoder
  bool passthrough_cmd_decoder;
  
// @generated_from: gpu.mojom.GpuInfo.can_support_threaded_texture_mailbox
  bool can_support_threaded_texture_mailbox;
  
// @generated_from: gpu.mojom.GpuInfo.video_decode_accelerator_supported_profiles
  WTF::Vector<VideoDecodeAcceleratorSupportedProfilePtr> video_decode_accelerator_supported_profiles;
  
// @generated_from: gpu.mojom.GpuInfo.video_encode_accelerator_supported_profiles
  WTF::Vector<VideoEncodeAcceleratorSupportedProfilePtr> video_encode_accelerator_supported_profiles;
  
// @generated_from: gpu.mojom.GpuInfo.jpeg_decode_accelerator_supported
  bool jpeg_decode_accelerator_supported;
  
// @generated_from: gpu.mojom.GpuInfo.image_decode_accelerator_supported_profiles
  WTF::Vector<ImageDecodeAcceleratorSupportedProfilePtr> image_decode_accelerator_supported_profiles;
  
// @generated_from: gpu.mojom.GpuInfo.subpixel_font_rendering
  bool subpixel_font_rendering;
  
// @generated_from: gpu.mojom.GpuInfo.visibility_callback_call_count
  uint32_t visibility_callback_call_count;
  
// @generated_from: gpu.mojom.GpuInfo.vulkan_info
  ::gpu::mojom::blink::VulkanInfoPtr vulkan_info;

  // Serialise this struct into a trace.
  void WriteIntoTrace(perfetto::TracedValue traced_context) const;

 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, GpuInfo::EnableIfSame<T>* = nullptr>
bool operator<(const T& lhs, const T& rhs);

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

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

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

template <typename StructPtrType>
GpuDevicePtr GpuDevice::Clone() const {
  return New(
      mojo::Clone(vendor_id),
      mojo::Clone(device_id),
      mojo::Clone(active),
      mojo::Clone(vendor_string),
      mojo::Clone(device_string),
      mojo::Clone(driver_vendor),
      mojo::Clone(driver_version),
      mojo::Clone(cuda_compute_capability_major),
      mojo::Clone(gpu_preference)
  );
}

template <typename T, GpuDevice::EnableIfSame<T>*>
bool GpuDevice::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->vendor_id, other_struct.vendor_id))
    return false;
  if (!mojo::Equals(this->device_id, other_struct.device_id))
    return false;
  if (!mojo::Equals(this->active, other_struct.active))
    return false;
  if (!mojo::Equals(this->vendor_string, other_struct.vendor_string))
    return false;
  if (!mojo::Equals(this->device_string, other_struct.device_string))
    return false;
  if (!mojo::Equals(this->driver_vendor, other_struct.driver_vendor))
    return false;
  if (!mojo::Equals(this->driver_version, other_struct.driver_version))
    return false;
  if (!mojo::Equals(this->cuda_compute_capability_major, other_struct.cuda_compute_capability_major))
    return false;
  if (!mojo::Equals(this->gpu_preference, other_struct.gpu_preference))
    return false;
  return true;
}

template <typename T, GpuDevice::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.vendor_id < rhs.vendor_id)
    return true;
  if (rhs.vendor_id < lhs.vendor_id)
    return false;
  if (lhs.device_id < rhs.device_id)
    return true;
  if (rhs.device_id < lhs.device_id)
    return false;
  if (lhs.active < rhs.active)
    return true;
  if (rhs.active < lhs.active)
    return false;
  if (lhs.vendor_string < rhs.vendor_string)
    return true;
  if (rhs.vendor_string < lhs.vendor_string)
    return false;
  if (lhs.device_string < rhs.device_string)
    return true;
  if (rhs.device_string < lhs.device_string)
    return false;
  if (lhs.driver_vendor < rhs.driver_vendor)
    return true;
  if (rhs.driver_vendor < lhs.driver_vendor)
    return false;
  if (lhs.driver_version < rhs.driver_version)
    return true;
  if (rhs.driver_version < lhs.driver_version)
    return false;
  if (lhs.cuda_compute_capability_major < rhs.cuda_compute_capability_major)
    return true;
  if (rhs.cuda_compute_capability_major < lhs.cuda_compute_capability_major)
    return false;
  if (lhs.gpu_preference < rhs.gpu_preference)
    return true;
  if (rhs.gpu_preference < lhs.gpu_preference)
    return false;
  return false;
}
template <typename StructPtrType>
VideoDecodeAcceleratorSupportedProfilePtr VideoDecodeAcceleratorSupportedProfile::Clone() const {
  return New(
      mojo::Clone(profile),
      mojo::Clone(max_resolution),
      mojo::Clone(min_resolution),
      mojo::Clone(encrypted_only)
  );
}

template <typename T, VideoDecodeAcceleratorSupportedProfile::EnableIfSame<T>*>
bool VideoDecodeAcceleratorSupportedProfile::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->profile, other_struct.profile))
    return false;
  if (!mojo::Equals(this->max_resolution, other_struct.max_resolution))
    return false;
  if (!mojo::Equals(this->min_resolution, other_struct.min_resolution))
    return false;
  if (!mojo::Equals(this->encrypted_only, other_struct.encrypted_only))
    return false;
  return true;
}

template <typename T, VideoDecodeAcceleratorSupportedProfile::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.profile < rhs.profile)
    return true;
  if (rhs.profile < lhs.profile)
    return false;
  if (lhs.max_resolution < rhs.max_resolution)
    return true;
  if (rhs.max_resolution < lhs.max_resolution)
    return false;
  if (lhs.min_resolution < rhs.min_resolution)
    return true;
  if (rhs.min_resolution < lhs.min_resolution)
    return false;
  if (lhs.encrypted_only < rhs.encrypted_only)
    return true;
  if (rhs.encrypted_only < lhs.encrypted_only)
    return false;
  return false;
}
template <typename StructPtrType>
VideoDecodeAcceleratorCapabilitiesPtr VideoDecodeAcceleratorCapabilities::Clone() const {
  return New(
      mojo::Clone(supported_profiles),
      mojo::Clone(flags)
  );
}

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

template <typename T, VideoDecodeAcceleratorCapabilities::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.supported_profiles < rhs.supported_profiles)
    return true;
  if (rhs.supported_profiles < lhs.supported_profiles)
    return false;
  if (lhs.flags < rhs.flags)
    return true;
  if (rhs.flags < lhs.flags)
    return false;
  return false;
}
template <typename StructPtrType>
VideoEncodeAcceleratorSupportedProfilePtr VideoEncodeAcceleratorSupportedProfile::Clone() const {
  return New(
      mojo::Clone(profile),
      mojo::Clone(min_resolution),
      mojo::Clone(max_resolution),
      mojo::Clone(max_framerate_numerator),
      mojo::Clone(max_framerate_denominator)
  );
}

template <typename T, VideoEncodeAcceleratorSupportedProfile::EnableIfSame<T>*>
bool VideoEncodeAcceleratorSupportedProfile::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->profile, other_struct.profile))
    return false;
  if (!mojo::Equals(this->min_resolution, other_struct.min_resolution))
    return false;
  if (!mojo::Equals(this->max_resolution, other_struct.max_resolution))
    return false;
  if (!mojo::Equals(this->max_framerate_numerator, other_struct.max_framerate_numerator))
    return false;
  if (!mojo::Equals(this->max_framerate_denominator, other_struct.max_framerate_denominator))
    return false;
  return true;
}

template <typename T, VideoEncodeAcceleratorSupportedProfile::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.profile < rhs.profile)
    return true;
  if (rhs.profile < lhs.profile)
    return false;
  if (lhs.min_resolution < rhs.min_resolution)
    return true;
  if (rhs.min_resolution < lhs.min_resolution)
    return false;
  if (lhs.max_resolution < rhs.max_resolution)
    return true;
  if (rhs.max_resolution < lhs.max_resolution)
    return false;
  if (lhs.max_framerate_numerator < rhs.max_framerate_numerator)
    return true;
  if (rhs.max_framerate_numerator < lhs.max_framerate_numerator)
    return false;
  if (lhs.max_framerate_denominator < rhs.max_framerate_denominator)
    return true;
  if (rhs.max_framerate_denominator < lhs.max_framerate_denominator)
    return false;
  return false;
}
template <typename StructPtrType>
ImageDecodeAcceleratorSupportedProfilePtr ImageDecodeAcceleratorSupportedProfile::Clone() const {
  return New(
      mojo::Clone(image_type),
      mojo::Clone(min_encoded_dimensions),
      mojo::Clone(max_encoded_dimensions),
      mojo::Clone(subsamplings)
  );
}

template <typename T, ImageDecodeAcceleratorSupportedProfile::EnableIfSame<T>*>
bool ImageDecodeAcceleratorSupportedProfile::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->image_type, other_struct.image_type))
    return false;
  if (!mojo::Equals(this->min_encoded_dimensions, other_struct.min_encoded_dimensions))
    return false;
  if (!mojo::Equals(this->max_encoded_dimensions, other_struct.max_encoded_dimensions))
    return false;
  if (!mojo::Equals(this->subsamplings, other_struct.subsamplings))
    return false;
  return true;
}

template <typename T, ImageDecodeAcceleratorSupportedProfile::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.image_type < rhs.image_type)
    return true;
  if (rhs.image_type < lhs.image_type)
    return false;
  if (lhs.min_encoded_dimensions < rhs.min_encoded_dimensions)
    return true;
  if (rhs.min_encoded_dimensions < lhs.min_encoded_dimensions)
    return false;
  if (lhs.max_encoded_dimensions < rhs.max_encoded_dimensions)
    return true;
  if (rhs.max_encoded_dimensions < lhs.max_encoded_dimensions)
    return false;
  if (lhs.subsamplings < rhs.subsamplings)
    return true;
  if (rhs.subsamplings < lhs.subsamplings)
    return false;
  return false;
}
template <typename StructPtrType>
GpuInfoPtr GpuInfo::Clone() const {
  return New(
      mojo::Clone(initialization_time),
      mojo::Clone(optimus),
      mojo::Clone(amd_switchable),
      mojo::Clone(gpu),
      mojo::Clone(secondary_gpus),
      mojo::Clone(pixel_shader_version),
      mojo::Clone(vertex_shader_version),
      mojo::Clone(max_msaa_samples),
      mojo::Clone(machine_model_name),
      mojo::Clone(machine_model_version),
      mojo::Clone(gl_version),
      mojo::Clone(gl_vendor),
      mojo::Clone(gl_renderer),
      mojo::Clone(gl_extensions),
      mojo::Clone(gl_ws_vendor),
      mojo::Clone(gl_ws_version),
      mojo::Clone(gl_ws_extensions),
      mojo::Clone(gl_reset_notification_strategy),
      mojo::Clone(software_rendering),
      mojo::Clone(direct_rendering_version),
      mojo::Clone(sandboxed),
      mojo::Clone(in_process_gpu),
      mojo::Clone(passthrough_cmd_decoder),
      mojo::Clone(can_support_threaded_texture_mailbox),
      mojo::Clone(video_decode_accelerator_supported_profiles),
      mojo::Clone(video_encode_accelerator_supported_profiles),
      mojo::Clone(jpeg_decode_accelerator_supported),
      mojo::Clone(image_decode_accelerator_supported_profiles),
      mojo::Clone(subpixel_font_rendering),
      mojo::Clone(visibility_callback_call_count),
      mojo::Clone(vulkan_info)
  );
}

template <typename T, GpuInfo::EnableIfSame<T>*>
bool GpuInfo::Equals(const T& other_struct) const {
  if (!mojo::Equals(this->initialization_time, other_struct.initialization_time))
    return false;
  if (!mojo::Equals(this->optimus, other_struct.optimus))
    return false;
  if (!mojo::Equals(this->amd_switchable, other_struct.amd_switchable))
    return false;
  if (!mojo::Equals(this->gpu, other_struct.gpu))
    return false;
  if (!mojo::Equals(this->secondary_gpus, other_struct.secondary_gpus))
    return false;
  if (!mojo::Equals(this->pixel_shader_version, other_struct.pixel_shader_version))
    return false;
  if (!mojo::Equals(this->vertex_shader_version, other_struct.vertex_shader_version))
    return false;
  if (!mojo::Equals(this->max_msaa_samples, other_struct.max_msaa_samples))
    return false;
  if (!mojo::Equals(this->machine_model_name, other_struct.machine_model_name))
    return false;
  if (!mojo::Equals(this->machine_model_version, other_struct.machine_model_version))
    return false;
  if (!mojo::Equals(this->gl_version, other_struct.gl_version))
    return false;
  if (!mojo::Equals(this->gl_vendor, other_struct.gl_vendor))
    return false;
  if (!mojo::Equals(this->gl_renderer, other_struct.gl_renderer))
    return false;
  if (!mojo::Equals(this->gl_extensions, other_struct.gl_extensions))
    return false;
  if (!mojo::Equals(this->gl_ws_vendor, other_struct.gl_ws_vendor))
    return false;
  if (!mojo::Equals(this->gl_ws_version, other_struct.gl_ws_version))
    return false;
  if (!mojo::Equals(this->gl_ws_extensions, other_struct.gl_ws_extensions))
    return false;
  if (!mojo::Equals(this->gl_reset_notification_strategy, other_struct.gl_reset_notification_strategy))
    return false;
  if (!mojo::Equals(this->software_rendering, other_struct.software_rendering))
    return false;
  if (!mojo::Equals(this->direct_rendering_version, other_struct.direct_rendering_version))
    return false;
  if (!mojo::Equals(this->sandboxed, other_struct.sandboxed))
    return false;
  if (!mojo::Equals(this->in_process_gpu, other_struct.in_process_gpu))
    return false;
  if (!mojo::Equals(this->passthrough_cmd_decoder, other_struct.passthrough_cmd_decoder))
    return false;
  if (!mojo::Equals(this->can_support_threaded_texture_mailbox, other_struct.can_support_threaded_texture_mailbox))
    return false;
  if (!mojo::Equals(this->video_decode_accelerator_supported_profiles, other_struct.video_decode_accelerator_supported_profiles))
    return false;
  if (!mojo::Equals(this->video_encode_accelerator_supported_profiles, other_struct.video_encode_accelerator_supported_profiles))
    return false;
  if (!mojo::Equals(this->jpeg_decode_accelerator_supported, other_struct.jpeg_decode_accelerator_supported))
    return false;
  if (!mojo::Equals(this->image_decode_accelerator_supported_profiles, other_struct.image_decode_accelerator_supported_profiles))
    return false;
  if (!mojo::Equals(this->subpixel_font_rendering, other_struct.subpixel_font_rendering))
    return false;
  if (!mojo::Equals(this->visibility_callback_call_count, other_struct.visibility_callback_call_count))
    return false;
  if (!mojo::Equals(this->vulkan_info, other_struct.vulkan_info))
    return false;
  return true;
}

template <typename T, GpuInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) {
  if (lhs.initialization_time < rhs.initialization_time)
    return true;
  if (rhs.initialization_time < lhs.initialization_time)
    return false;
  if (lhs.optimus < rhs.optimus)
    return true;
  if (rhs.optimus < lhs.optimus)
    return false;
  if (lhs.amd_switchable < rhs.amd_switchable)
    return true;
  if (rhs.amd_switchable < lhs.amd_switchable)
    return false;
  if (lhs.gpu < rhs.gpu)
    return true;
  if (rhs.gpu < lhs.gpu)
    return false;
  if (lhs.secondary_gpus < rhs.secondary_gpus)
    return true;
  if (rhs.secondary_gpus < lhs.secondary_gpus)
    return false;
  if (lhs.pixel_shader_version < rhs.pixel_shader_version)
    return true;
  if (rhs.pixel_shader_version < lhs.pixel_shader_version)
    return false;
  if (lhs.vertex_shader_version < rhs.vertex_shader_version)
    return true;
  if (rhs.vertex_shader_version < lhs.vertex_shader_version)
    return false;
  if (lhs.max_msaa_samples < rhs.max_msaa_samples)
    return true;
  if (rhs.max_msaa_samples < lhs.max_msaa_samples)
    return false;
  if (lhs.machine_model_name < rhs.machine_model_name)
    return true;
  if (rhs.machine_model_name < lhs.machine_model_name)
    return false;
  if (lhs.machine_model_version < rhs.machine_model_version)
    return true;
  if (rhs.machine_model_version < lhs.machine_model_version)
    return false;
  if (lhs.gl_version < rhs.gl_version)
    return true;
  if (rhs.gl_version < lhs.gl_version)
    return false;
  if (lhs.gl_vendor < rhs.gl_vendor)
    return true;
  if (rhs.gl_vendor < lhs.gl_vendor)
    return false;
  if (lhs.gl_renderer < rhs.gl_renderer)
    return true;
  if (rhs.gl_renderer < lhs.gl_renderer)
    return false;
  if (lhs.gl_extensions < rhs.gl_extensions)
    return true;
  if (rhs.gl_extensions < lhs.gl_extensions)
    return false;
  if (lhs.gl_ws_vendor < rhs.gl_ws_vendor)
    return true;
  if (rhs.gl_ws_vendor < lhs.gl_ws_vendor)
    return false;
  if (lhs.gl_ws_version < rhs.gl_ws_version)
    return true;
  if (rhs.gl_ws_version < lhs.gl_ws_version)
    return false;
  if (lhs.gl_ws_extensions < rhs.gl_ws_extensions)
    return true;
  if (rhs.gl_ws_extensions < lhs.gl_ws_extensions)
    return false;
  if (lhs.gl_reset_notification_strategy < rhs.gl_reset_notification_strategy)
    return true;
  if (rhs.gl_reset_notification_strategy < lhs.gl_reset_notification_strategy)
    return false;
  if (lhs.software_rendering < rhs.software_rendering)
    return true;
  if (rhs.software_rendering < lhs.software_rendering)
    return false;
  if (lhs.direct_rendering_version < rhs.direct_rendering_version)
    return true;
  if (rhs.direct_rendering_version < lhs.direct_rendering_version)
    return false;
  if (lhs.sandboxed < rhs.sandboxed)
    return true;
  if (rhs.sandboxed < lhs.sandboxed)
    return false;
  if (lhs.in_process_gpu < rhs.in_process_gpu)
    return true;
  if (rhs.in_process_gpu < lhs.in_process_gpu)
    return false;
  if (lhs.passthrough_cmd_decoder < rhs.passthrough_cmd_decoder)
    return true;
  if (rhs.passthrough_cmd_decoder < lhs.passthrough_cmd_decoder)
    return false;
  if (lhs.can_support_threaded_texture_mailbox < rhs.can_support_threaded_texture_mailbox)
    return true;
  if (rhs.can_support_threaded_texture_mailbox < lhs.can_support_threaded_texture_mailbox)
    return false;
  if (lhs.video_decode_accelerator_supported_profiles < rhs.video_decode_accelerator_supported_profiles)
    return true;
  if (rhs.video_decode_accelerator_supported_profiles < lhs.video_decode_accelerator_supported_profiles)
    return false;
  if (lhs.video_encode_accelerator_supported_profiles < rhs.video_encode_accelerator_supported_profiles)
    return true;
  if (rhs.video_encode_accelerator_supported_profiles < lhs.video_encode_accelerator_supported_profiles)
    return false;
  if (lhs.jpeg_decode_accelerator_supported < rhs.jpeg_decode_accelerator_supported)
    return true;
  if (rhs.jpeg_decode_accelerator_supported < lhs.jpeg_decode_accelerator_supported)
    return false;
  if (lhs.image_decode_accelerator_supported_profiles < rhs.image_decode_accelerator_supported_profiles)
    return true;
  if (rhs.image_decode_accelerator_supported_profiles < lhs.image_decode_accelerator_supported_profiles)
    return false;
  if (lhs.subpixel_font_rendering < rhs.subpixel_font_rendering)
    return true;
  if (rhs.subpixel_font_rendering < lhs.subpixel_font_rendering)
    return false;
  if (lhs.visibility_callback_call_count < rhs.visibility_callback_call_count)
    return true;
  if (rhs.visibility_callback_call_count < lhs.visibility_callback_call_count)
    return false;
  if (lhs.vulkan_info < rhs.vulkan_info)
    return true;
  if (rhs.vulkan_info < lhs.vulkan_info)
    return false;
  return false;
}


}  // namespace blink
}  // namespace mojom
}  // namespace gpu

namespace mojo {


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::gpu::mojom::blink::GpuDevice::DataView,
                                         ::gpu::mojom::blink::GpuDevicePtr> {
  static bool IsNull(const ::gpu::mojom::blink::GpuDevicePtr& input) { return !input; }
  static void SetToNull(::gpu::mojom::blink::GpuDevicePtr* output) { output->reset(); }

  static decltype(::gpu::mojom::blink::GpuDevice::vendor_id) vendor_id(
      const ::gpu::mojom::blink::GpuDevicePtr& input) {
    return input->vendor_id;
  }

  static decltype(::gpu::mojom::blink::GpuDevice::device_id) device_id(
      const ::gpu::mojom::blink::GpuDevicePtr& input) {
    return input->device_id;
  }

  static decltype(::gpu::mojom::blink::GpuDevice::active) active(
      const ::gpu::mojom::blink::GpuDevicePtr& input) {
    return input->active;
  }

  static const decltype(::gpu::mojom::blink::GpuDevice::vendor_string)& vendor_string(
      const ::gpu::mojom::blink::GpuDevicePtr& input) {
    return input->vendor_string;
  }

  static const decltype(::gpu::mojom::blink::GpuDevice::device_string)& device_string(
      const ::gpu::mojom::blink::GpuDevicePtr& input) {
    return input->device_string;
  }

  static const decltype(::gpu::mojom::blink::GpuDevice::driver_vendor)& driver_vendor(
      const ::gpu::mojom::blink::GpuDevicePtr& input) {
    return input->driver_vendor;
  }

  static const decltype(::gpu::mojom::blink::GpuDevice::driver_version)& driver_version(
      const ::gpu::mojom::blink::GpuDevicePtr& input) {
    return input->driver_version;
  }

  static decltype(::gpu::mojom::blink::GpuDevice::cuda_compute_capability_major) cuda_compute_capability_major(
      const ::gpu::mojom::blink::GpuDevicePtr& input) {
    return input->cuda_compute_capability_major;
  }

  static decltype(::gpu::mojom::blink::GpuDevice::gpu_preference) gpu_preference(
      const ::gpu::mojom::blink::GpuDevicePtr& input) {
    return input->gpu_preference;
  }

  static bool Read(::gpu::mojom::blink::GpuDevice::DataView input, ::gpu::mojom::blink::GpuDevicePtr* output);
};


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfile::DataView,
                                         ::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfilePtr> {
  static bool IsNull(const ::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfilePtr& input) { return !input; }
  static void SetToNull(::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfilePtr* output) { output->reset(); }

  static decltype(::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfile::profile) profile(
      const ::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfilePtr& input) {
    return input->profile;
  }

  static const decltype(::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfile::max_resolution)& max_resolution(
      const ::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfilePtr& input) {
    return input->max_resolution;
  }

  static const decltype(::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfile::min_resolution)& min_resolution(
      const ::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfilePtr& input) {
    return input->min_resolution;
  }

  static decltype(::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfile::encrypted_only) encrypted_only(
      const ::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfilePtr& input) {
    return input->encrypted_only;
  }

  static bool Read(::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfile::DataView input, ::gpu::mojom::blink::VideoDecodeAcceleratorSupportedProfilePtr* output);
};


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::gpu::mojom::blink::VideoDecodeAcceleratorCapabilities::DataView,
                                         ::gpu::mojom::blink::VideoDecodeAcceleratorCapabilitiesPtr> {
  static bool IsNull(const ::gpu::mojom::blink::VideoDecodeAcceleratorCapabilitiesPtr& input) { return !input; }
  static void SetToNull(::gpu::mojom::blink::VideoDecodeAcceleratorCapabilitiesPtr* output) { output->reset(); }

  static const decltype(::gpu::mojom::blink::VideoDecodeAcceleratorCapabilities::supported_profiles)& supported_profiles(
      const ::gpu::mojom::blink::VideoDecodeAcceleratorCapabilitiesPtr& input) {
    return input->supported_profiles;
  }

  static decltype(::gpu::mojom::blink::VideoDecodeAcceleratorCapabilities::flags) flags(
      const ::gpu::mojom::blink::VideoDecodeAcceleratorCapabilitiesPtr& input) {
    return input->flags;
  }

  static bool Read(::gpu::mojom::blink::VideoDecodeAcceleratorCapabilities::DataView input, ::gpu::mojom::blink::VideoDecodeAcceleratorCapabilitiesPtr* output);
};


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfile::DataView,
                                         ::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr> {
  static bool IsNull(const ::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr& input) { return !input; }
  static void SetToNull(::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr* output) { output->reset(); }

  static decltype(::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfile::profile) profile(
      const ::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr& input) {
    return input->profile;
  }

  static const decltype(::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfile::min_resolution)& min_resolution(
      const ::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr& input) {
    return input->min_resolution;
  }

  static const decltype(::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfile::max_resolution)& max_resolution(
      const ::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr& input) {
    return input->max_resolution;
  }

  static decltype(::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfile::max_framerate_numerator) max_framerate_numerator(
      const ::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr& input) {
    return input->max_framerate_numerator;
  }

  static decltype(::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfile::max_framerate_denominator) max_framerate_denominator(
      const ::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr& input) {
    return input->max_framerate_denominator;
  }

  static bool Read(::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfile::DataView input, ::gpu::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr* output);
};


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfile::DataView,
                                         ::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfilePtr> {
  static bool IsNull(const ::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfilePtr& input) { return !input; }
  static void SetToNull(::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfilePtr* output) { output->reset(); }

  static decltype(::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfile::image_type) image_type(
      const ::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfilePtr& input) {
    return input->image_type;
  }

  static const decltype(::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfile::min_encoded_dimensions)& min_encoded_dimensions(
      const ::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfilePtr& input) {
    return input->min_encoded_dimensions;
  }

  static const decltype(::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfile::max_encoded_dimensions)& max_encoded_dimensions(
      const ::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfilePtr& input) {
    return input->max_encoded_dimensions;
  }

  static const decltype(::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfile::subsamplings)& subsamplings(
      const ::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfilePtr& input) {
    return input->subsamplings;
  }

  static bool Read(::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfile::DataView input, ::gpu::mojom::blink::ImageDecodeAcceleratorSupportedProfilePtr* output);
};


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::gpu::mojom::blink::GpuInfo::DataView,
                                         ::gpu::mojom::blink::GpuInfoPtr> {
  static bool IsNull(const ::gpu::mojom::blink::GpuInfoPtr& input) { return !input; }
  static void SetToNull(::gpu::mojom::blink::GpuInfoPtr* output) { output->reset(); }

  static const decltype(::gpu::mojom::blink::GpuInfo::initialization_time)& initialization_time(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->initialization_time;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::optimus) optimus(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->optimus;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::amd_switchable) amd_switchable(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->amd_switchable;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::gpu)& gpu(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->gpu;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::secondary_gpus)& secondary_gpus(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->secondary_gpus;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::pixel_shader_version)& pixel_shader_version(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->pixel_shader_version;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::vertex_shader_version)& vertex_shader_version(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->vertex_shader_version;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::max_msaa_samples)& max_msaa_samples(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->max_msaa_samples;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::machine_model_name)& machine_model_name(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->machine_model_name;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::machine_model_version)& machine_model_version(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->machine_model_version;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::gl_version)& gl_version(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->gl_version;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::gl_vendor)& gl_vendor(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->gl_vendor;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::gl_renderer)& gl_renderer(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->gl_renderer;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::gl_extensions)& gl_extensions(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->gl_extensions;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::gl_ws_vendor)& gl_ws_vendor(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->gl_ws_vendor;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::gl_ws_version)& gl_ws_version(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->gl_ws_version;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::gl_ws_extensions)& gl_ws_extensions(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->gl_ws_extensions;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::gl_reset_notification_strategy) gl_reset_notification_strategy(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->gl_reset_notification_strategy;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::software_rendering) software_rendering(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->software_rendering;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::direct_rendering_version)& direct_rendering_version(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->direct_rendering_version;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::sandboxed) sandboxed(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->sandboxed;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::in_process_gpu) in_process_gpu(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->in_process_gpu;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::passthrough_cmd_decoder) passthrough_cmd_decoder(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->passthrough_cmd_decoder;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::can_support_threaded_texture_mailbox) can_support_threaded_texture_mailbox(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->can_support_threaded_texture_mailbox;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::video_decode_accelerator_supported_profiles)& video_decode_accelerator_supported_profiles(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->video_decode_accelerator_supported_profiles;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::video_encode_accelerator_supported_profiles)& video_encode_accelerator_supported_profiles(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->video_encode_accelerator_supported_profiles;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::jpeg_decode_accelerator_supported) jpeg_decode_accelerator_supported(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->jpeg_decode_accelerator_supported;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::image_decode_accelerator_supported_profiles)& image_decode_accelerator_supported_profiles(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->image_decode_accelerator_supported_profiles;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::subpixel_font_rendering) subpixel_font_rendering(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->subpixel_font_rendering;
  }

  static decltype(::gpu::mojom::blink::GpuInfo::visibility_callback_call_count) visibility_callback_call_count(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->visibility_callback_call_count;
  }

  static const decltype(::gpu::mojom::blink::GpuInfo::vulkan_info)& vulkan_info(
      const ::gpu::mojom::blink::GpuInfoPtr& input) {
    return input->vulkan_info;
  }

  static bool Read(::gpu::mojom::blink::GpuInfo::DataView input, ::gpu::mojom::blink::GpuInfoPtr* output);
};

}  // namespace mojo

#endif  // GPU_IPC_COMMON_GPU_INFO_MOJOM_BLINK_H_

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