chromium/out/Default/gen/media/mojo/mojom/video_encode_accelerator.mojom-blink.h

// media/mojo/mojom/video_encode_accelerator.mojom-blink.h is auto generated by mojom_bindings_generator.py, do not edit

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

#ifndef MEDIA_MOJO_MOJOM_VIDEO_ENCODE_ACCELERATOR_MOJOM_BLINK_H_
#define MEDIA_MOJO_MOJOM_VIDEO_ENCODE_ACCELERATOR_MOJOM_BLINK_H_

#include <stdint.h>

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

#include "base/types/cxx23_to_underlying.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 "media/mojo/mojom/video_encode_accelerator.mojom-features.h"  // IWYU pragma: export
#include "media/mojo/mojom/video_encode_accelerator.mojom-shared.h"  // IWYU pragma: export
#include "media/mojo/mojom/video_encode_accelerator.mojom-blink-forward.h"  // IWYU pragma: export
#include "media/mojo/mojom/media_log.mojom-blink-forward.h"
#include "media/mojo/mojom/media_types.mojom-blink-forward.h"
#include "mojo/public/mojom/base/shared_memory.mojom-blink.h"
#include "mojo/public/mojom/base/time.mojom-blink.h"
#include "ui/gfx/geometry/mojom/geometry.mojom-blink.h"
#include "ui/gfx/mojom/color_space.mojom-blink.h"
#include "media/mojo/mojom/video_encoder_info.mojom-blink-forward.h"
#include "sandbox/policy/mojom/sandbox.mojom-blink-forward.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 "mojo/public/cpp/bindings/lib/control_message_handler.h"
#include "mojo/public/cpp/bindings/lib/message_size_estimator.h"
#include "mojo/public/cpp/bindings/raw_ptr_impl_ref_traits.h"


#include "mojo/public/cpp/bindings/lib/native_enum_serialization.h"
#include "mojo/public/cpp/bindings/lib/native_struct_serialization.h"
#include "third_party/blink/public/platform/web_common.h"




namespace media::mojom::blink {

class VideoEncodeAcceleratorProviderProxy;

template <typename ImplRefTraits>
class VideoEncodeAcceleratorProviderStub;

class VideoEncodeAcceleratorProviderRequestValidator;
class VideoEncodeAcceleratorProviderResponseValidator;


class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorProvider
    : public VideoEncodeAcceleratorProviderInterfaceBase { … };

class VideoEncodeAcceleratorProviderFactoryProxy;

template <typename ImplRefTraits>
class VideoEncodeAcceleratorProviderFactoryStub;

class VideoEncodeAcceleratorProviderFactoryRequestValidator;


class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorProviderFactory
    : public VideoEncodeAcceleratorProviderFactoryInterfaceBase { … };

class VideoEncodeAcceleratorProxy;

template <typename ImplRefTraits>
class VideoEncodeAcceleratorStub;

class VideoEncodeAcceleratorRequestValidator;
class VideoEncodeAcceleratorResponseValidator;


class BLINK_PLATFORM_EXPORT VideoEncodeAccelerator
    : public VideoEncodeAcceleratorInterfaceBase { … };

class VideoEncodeAcceleratorClientProxy;

template <typename ImplRefTraits>
class VideoEncodeAcceleratorClientStub;

class VideoEncodeAcceleratorClientRequestValidator;


class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorClient
    : public VideoEncodeAcceleratorClientInterfaceBase { … };



class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorProviderProxy
    : public VideoEncodeAcceleratorProvider { … };



class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorProviderFactoryProxy
    : public VideoEncodeAcceleratorProviderFactory { … };



class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorProxy
    : public VideoEncodeAccelerator { … };



class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorClientProxy
    : public VideoEncodeAcceleratorClient { … };
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorProviderStubDispatch { … };

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<VideoEncodeAcceleratorProvider>>
class VideoEncodeAcceleratorProviderStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  VideoEncodeAcceleratorProviderStub() = default;
  ~VideoEncodeAcceleratorProviderStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorProviderFactoryStubDispatch { … };

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<VideoEncodeAcceleratorProviderFactory>>
class VideoEncodeAcceleratorProviderFactoryStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  VideoEncodeAcceleratorProviderFactoryStub() = default;
  ~VideoEncodeAcceleratorProviderFactoryStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorStubDispatch { … };

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<VideoEncodeAccelerator>>
class VideoEncodeAcceleratorStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  VideoEncodeAcceleratorStub() = default;
  ~VideoEncodeAcceleratorStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorClientStubDispatch { … };

template <typename ImplRefTraits =
              mojo::RawPtrImplRefTraits<VideoEncodeAcceleratorClient>>
class VideoEncodeAcceleratorClientStub
    : public mojo::MessageReceiverWithResponderStatus {
 public:
  using ImplPointerType = typename ImplRefTraits::PointerType;

  VideoEncodeAcceleratorClientStub() = default;
  ~VideoEncodeAcceleratorClientStub() override = default;

  void set_sink(ImplPointerType sink) { … }
  ImplPointerType& sink() { … }

  bool Accept(mojo::Message* message) override { … }

  bool AcceptWithResponder(
      mojo::Message* message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) override { … }

 private:
  ImplPointerType sink_;
};
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorProviderRequestValidator : public mojo::MessageReceiver { … };
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorProviderFactoryRequestValidator : public mojo::MessageReceiver { … };
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorRequestValidator : public mojo::MessageReceiver { … };
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorClientRequestValidator : public mojo::MessageReceiver { … };
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorProviderResponseValidator : public mojo::MessageReceiver { … };
class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorResponseValidator : public mojo::MessageReceiver { … };






class BLINK_PLATFORM_EXPORT VariableBitratePeak { … };

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

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

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

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







class BLINK_PLATFORM_EXPORT ConstantBitrate { … };

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

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

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

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





class BLINK_PLATFORM_EXPORT VariableBitrate { … };

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

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

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

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





class BLINK_PLATFORM_EXPORT ExternalBitrate { … };

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

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

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

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






class BLINK_PLATFORM_EXPORT VideoEncodeOptions { … };

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

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

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

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





class BLINK_PLATFORM_EXPORT DropFrameMetadata { … };

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

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

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

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





class BLINK_PLATFORM_EXPORT H264Metadata { … };

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

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

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

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





class BLINK_PLATFORM_EXPORT H265Metadata { … };

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

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

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

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





class BLINK_PLATFORM_EXPORT Vp8Metadata { … };

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

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

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

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






class BLINK_PLATFORM_EXPORT Av1Metadata { … };

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

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

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

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






class BLINK_PLATFORM_EXPORT Bitrate { … };



class BLINK_PLATFORM_EXPORT OptionalMetadata { … };





class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorSupportedProfile { … };

// 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) { … }

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) { … }






class BLINK_PLATFORM_EXPORT VideoBitrateAllocation { … };

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

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

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

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





class BLINK_PLATFORM_EXPORT SpatialLayer { … };

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

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

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

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








class BLINK_PLATFORM_EXPORT VideoEncodeAcceleratorConfig { … };

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

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

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

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










class BLINK_PLATFORM_EXPORT Vp9Metadata { … };

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

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

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

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






class BLINK_PLATFORM_EXPORT BitstreamBufferMetadata { … };

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

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

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

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

template <typename UnionPtrType>
BitratePtr Bitrate::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, Bitrate>::value>::type*>
bool Bitrate::Equals(const T& other) const { … }
template <typename UnionPtrType>
OptionalMetadataPtr OptionalMetadata::Clone() const { … }

template <typename T,
          typename std::enable_if<std::is_same<
              T, OptionalMetadata>::value>::type*>
bool OptionalMetadata::Equals(const T& other) const { … }
template <typename StructPtrType>
VideoEncodeAcceleratorSupportedProfilePtr VideoEncodeAcceleratorSupportedProfile::Clone() const { … }

template <typename T, VideoEncodeAcceleratorSupportedProfile::EnableIfSame<T>*>
bool VideoEncodeAcceleratorSupportedProfile::Equals(const T& other_struct) const { … }

template <typename T, VideoEncodeAcceleratorSupportedProfile::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VariableBitratePeakPtr VariableBitratePeak::Clone() const { … }

template <typename T, VariableBitratePeak::EnableIfSame<T>*>
bool VariableBitratePeak::Equals(const T& other_struct) const { … }

template <typename T, VariableBitratePeak::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VideoBitrateAllocationPtr VideoBitrateAllocation::Clone() const { … }

template <typename T, VideoBitrateAllocation::EnableIfSame<T>*>
bool VideoBitrateAllocation::Equals(const T& other_struct) const { … }

template <typename T, VideoBitrateAllocation::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SpatialLayerPtr SpatialLayer::Clone() const { … }

template <typename T, SpatialLayer::EnableIfSame<T>*>
bool SpatialLayer::Equals(const T& other_struct) const { … }

template <typename T, SpatialLayer::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
ConstantBitratePtr ConstantBitrate::Clone() const { … }

template <typename T, ConstantBitrate::EnableIfSame<T>*>
bool ConstantBitrate::Equals(const T& other_struct) const { … }

template <typename T, ConstantBitrate::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VariableBitratePtr VariableBitrate::Clone() const { … }

template <typename T, VariableBitrate::EnableIfSame<T>*>
bool VariableBitrate::Equals(const T& other_struct) const { … }

template <typename T, VariableBitrate::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
ExternalBitratePtr ExternalBitrate::Clone() const { … }

template <typename T, ExternalBitrate::EnableIfSame<T>*>
bool ExternalBitrate::Equals(const T& other_struct) const { … }

template <typename T, ExternalBitrate::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VideoEncodeAcceleratorConfigPtr VideoEncodeAcceleratorConfig::Clone() const { … }

template <typename T, VideoEncodeAcceleratorConfig::EnableIfSame<T>*>
bool VideoEncodeAcceleratorConfig::Equals(const T& other_struct) const { … }

template <typename T, VideoEncodeAcceleratorConfig::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VideoEncodeOptionsPtr VideoEncodeOptions::Clone() const { … }

template <typename T, VideoEncodeOptions::EnableIfSame<T>*>
bool VideoEncodeOptions::Equals(const T& other_struct) const { … }

template <typename T, VideoEncodeOptions::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
DropFrameMetadataPtr DropFrameMetadata::Clone() const { … }

template <typename T, DropFrameMetadata::EnableIfSame<T>*>
bool DropFrameMetadata::Equals(const T& other_struct) const { … }

template <typename T, DropFrameMetadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
H264MetadataPtr H264Metadata::Clone() const { … }

template <typename T, H264Metadata::EnableIfSame<T>*>
bool H264Metadata::Equals(const T& other_struct) const { … }

template <typename T, H264Metadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
H265MetadataPtr H265Metadata::Clone() const { … }

template <typename T, H265Metadata::EnableIfSame<T>*>
bool H265Metadata::Equals(const T& other_struct) const { … }

template <typename T, H265Metadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
Vp8MetadataPtr Vp8Metadata::Clone() const { … }

template <typename T, Vp8Metadata::EnableIfSame<T>*>
bool Vp8Metadata::Equals(const T& other_struct) const { … }

template <typename T, Vp8Metadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
Vp9MetadataPtr Vp9Metadata::Clone() const { … }

template <typename T, Vp9Metadata::EnableIfSame<T>*>
bool Vp9Metadata::Equals(const T& other_struct) const { … }

template <typename T, Vp9Metadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
Av1MetadataPtr Av1Metadata::Clone() const { … }

template <typename T, Av1Metadata::EnableIfSame<T>*>
bool Av1Metadata::Equals(const T& other_struct) const { … }

template <typename T, Av1Metadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
BitstreamBufferMetadataPtr BitstreamBufferMetadata::Clone() const { … }

template <typename T, BitstreamBufferMetadata::EnableIfSame<T>*>
bool BitstreamBufferMetadata::Equals(const T& other_struct) const { … }

template <typename T, BitstreamBufferMetadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }


}  // media::mojom::blink

namespace mojo {


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::VideoEncodeAcceleratorSupportedProfile::DataView,
                                         ::media::mojom::blink::VideoEncodeAcceleratorSupportedProfilePtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::VariableBitratePeak::DataView,
                                         ::media::mojom::blink::VariableBitratePeakPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::VideoBitrateAllocation::DataView,
                                         ::media::mojom::blink::VideoBitrateAllocationPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::SpatialLayer::DataView,
                                         ::media::mojom::blink::SpatialLayerPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::ConstantBitrate::DataView,
                                         ::media::mojom::blink::ConstantBitratePtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::VariableBitrate::DataView,
                                         ::media::mojom::blink::VariableBitratePtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::ExternalBitrate::DataView,
                                         ::media::mojom::blink::ExternalBitratePtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::VideoEncodeAcceleratorConfig::DataView,
                                         ::media::mojom::blink::VideoEncodeAcceleratorConfigPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::VideoEncodeOptions::DataView,
                                         ::media::mojom::blink::VideoEncodeOptionsPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::DropFrameMetadata::DataView,
                                         ::media::mojom::blink::DropFrameMetadataPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::H264Metadata::DataView,
                                         ::media::mojom::blink::H264MetadataPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::H265Metadata::DataView,
                                         ::media::mojom::blink::H265MetadataPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::Vp8Metadata::DataView,
                                         ::media::mojom::blink::Vp8MetadataPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::Vp9Metadata::DataView,
                                         ::media::mojom::blink::Vp9MetadataPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::Av1Metadata::DataView,
                                         ::media::mojom::blink::Av1MetadataPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT StructTraits<::media::mojom::blink::BitstreamBufferMetadata::DataView,
                                         ::media::mojom::blink::BitstreamBufferMetadataPtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT UnionTraits<::media::mojom::blink::Bitrate::DataView,
                                        ::media::mojom::blink::BitratePtr> { … };


template <>
struct BLINK_PLATFORM_EXPORT UnionTraits<::media::mojom::blink::OptionalMetadata::DataView,
                                        ::media::mojom::blink::OptionalMetadataPtr> { … };

}  // namespace mojo

#endif  // MEDIA_MOJO_MOJOM_VIDEO_ENCODE_ACCELERATOR_MOJOM_BLINK_H_