chromium/out/Default/gen/media/mojo/mojom/media_types.mojom.h

// media/mojo/mojom/media_types.mojom.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_MEDIA_TYPES_MOJOM_H_
#define MEDIA_MOJO_MOJOM_MEDIA_TYPES_MOJOM_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/media_types.mojom-features.h"  // IWYU pragma: export
#include "media/mojo/mojom/media_types.mojom-shared.h"  // IWYU pragma: export
#include "media/mojo/mojom/media_types.mojom-forward.h"  // IWYU pragma: export
#include "gpu/ipc/common/exported_shared_image.mojom.h"
#include "gpu/ipc/common/mailbox_holder.mojom.h"
#include "gpu/ipc/common/sync_token.mojom.h"
#include "gpu/ipc/common/vulkan_ycbcr_info.mojom.h"
#include "media/mojo/mojom/audio_data.mojom-forward.h"
#include "media/mojo/mojom/encryption_pattern.mojom.h"
#include "mojo/public/mojom/base/byte_string.mojom.h"
#include "mojo/public/mojom/base/shared_memory.mojom.h"
#include "mojo/public/mojom/base/time.mojom.h"
#include "mojo/public/mojom/base/values.mojom.h"
#include "mojo/public/mojom/base/unguessable_token.mojom.h"
#include "ui/gfx/geometry/mojom/geometry.mojom.h"
#include "ui/gfx/mojom/buffer_types.mojom.h"
#include "ui/gfx/mojom/color_space.mojom.h"
#include "ui/gfx/mojom/hdr_metadata.mojom.h"
#include <string>
#include <vector>

#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 "media/base/ipc/media_param_traits_macros.h"
#include "media/base/video_decoder_config.h"
#include "media/mojo/mojom/audio_decoder_config_mojom_traits.h"
#include "media/mojo/mojom/media_types_enum_mojom_traits.h"
#include "media/mojo/mojom/pipeline_status_mojom_traits.h"
#include "media/mojo/mojom/status_mojom_traits.h"
#include "media/mojo/mojom/supported_video_decoder_config_mojom_traits.h"
#include "media/mojo/mojom/video_aspect_ratio_mojom_traits.h"
#include "media/mojo/mojom/video_color_space_mojom_traits.h"
#include "media/mojo/mojom/video_encode_accelerator_mojom_traits.h"
#include "media/mojo/mojom/video_frame_metadata_mojom_traits.h"
#include "media/mojo/mojom/video_frame_mojom_traits.h"
#include "media/mojo/mojom/video_transformation_mojom_traits.h"




namespace media::mojom {






class  VideoTransformation { … };

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

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

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

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





class  VideoAspectRatio { … };

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

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

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

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





class  VideoColorSpace { … };

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

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

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

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














class  EosVideoFrameData { … };

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

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

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

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











class  PredictionTargets { … };

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

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

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

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





class  AudioPipelineInfo { … };

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

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

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

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





class  VideoPipelineInfo { … };

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

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

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

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









class  VideoFrameData { … };









class  AudioDecoderConfig { … };

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

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

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

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





class  VideoDecoderConfig { … };

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

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

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

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






class  DecryptConfig { … };

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

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

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

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





class  DecoderBufferSideData { … };

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

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

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

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





class  DecoderBuffer { … };

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

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

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

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





class  AudioBuffer { … };

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

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

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

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





class  VideoFrameMetadata { … };

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

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

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

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





class  VideoFrame { … };

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

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

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

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






class  SharedMemoryVideoFrameData { … };

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

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

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

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





class  GpuMemoryBufferSharedImageVideoFrameData { … };

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

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

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

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





class  MailboxVideoFrameData { … };

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

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

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

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





class  SharedImageVideoFrameData { … };

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

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

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

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





class  PipelineStatistics { … };

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

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

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

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





class  PredictionFeatures { … };

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

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

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

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








class  StatusData { … };

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

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

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

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





class  EncoderStatus { … };

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

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

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

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





class  DecoderStatus { … };

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

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

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

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





class  PipelineStatus { … };

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

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

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

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

template <typename UnionPtrType>
VideoFrameDataPtr VideoFrameData::Clone() const { … }

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

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

template <typename T, VideoTransformation::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VideoAspectRatioPtr VideoAspectRatio::Clone() const { … }

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

template <typename T, VideoAspectRatio::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VideoColorSpacePtr VideoColorSpace::Clone() const { … }

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

template <typename T, VideoColorSpace::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
AudioDecoderConfigPtr AudioDecoderConfig::Clone() const { … }

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

template <typename T, AudioDecoderConfig::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VideoDecoderConfigPtr VideoDecoderConfig::Clone() const { … }

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

template <typename T, VideoDecoderConfig::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
DecryptConfigPtr DecryptConfig::Clone() const { … }

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

template <typename T, DecryptConfig::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
DecoderBufferSideDataPtr DecoderBufferSideData::Clone() const { … }

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

template <typename T, DecoderBufferSideData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
DecoderBufferPtr DecoderBuffer::Clone() const { … }

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

template <typename T, DecoderBuffer::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
AudioBufferPtr AudioBuffer::Clone() const { … }

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

template <typename T, AudioBuffer::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VideoFrameMetadataPtr VideoFrameMetadata::Clone() const { … }

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

template <typename T, VideoFrameMetadata::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VideoFramePtr VideoFrame::Clone() const { … }

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

template <typename T, VideoFrame::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
EosVideoFrameDataPtr EosVideoFrameData::Clone() const { … }

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

template <typename T, EosVideoFrameData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SharedMemoryVideoFrameDataPtr SharedMemoryVideoFrameData::Clone() const { … }

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

template <typename T, SharedMemoryVideoFrameData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
GpuMemoryBufferSharedImageVideoFrameDataPtr GpuMemoryBufferSharedImageVideoFrameData::Clone() const { … }

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

template <typename T, GpuMemoryBufferSharedImageVideoFrameData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
MailboxVideoFrameDataPtr MailboxVideoFrameData::Clone() const { … }

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

template <typename T, MailboxVideoFrameData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SharedImageVideoFrameDataPtr SharedImageVideoFrameData::Clone() const { … }

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

template <typename T, SharedImageVideoFrameData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
PipelineStatisticsPtr PipelineStatistics::Clone() const { … }

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

template <typename T, PipelineStatistics::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
PredictionFeaturesPtr PredictionFeatures::Clone() const { … }

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

template <typename T, PredictionFeatures::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
PredictionTargetsPtr PredictionTargets::Clone() const { … }

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

template <typename T, PredictionTargets::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
AudioPipelineInfoPtr AudioPipelineInfo::Clone() const { … }

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

template <typename T, AudioPipelineInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
VideoPipelineInfoPtr VideoPipelineInfo::Clone() const { … }

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

template <typename T, VideoPipelineInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
StatusDataPtr StatusData::Clone() const { … }

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

template <typename T, StatusData::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
EncoderStatusPtr EncoderStatus::Clone() const { … }

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

template <typename T, EncoderStatus::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
DecoderStatusPtr DecoderStatus::Clone() const { … }

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

template <typename T, DecoderStatus::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
PipelineStatusPtr PipelineStatus::Clone() const { … }

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

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


}  // media::mojom

namespace mojo {


template <>
struct  StructTraits<::media::mojom::VideoTransformation::DataView,
                                         ::media::mojom::VideoTransformationPtr> { … };


template <>
struct  StructTraits<::media::mojom::VideoAspectRatio::DataView,
                                         ::media::mojom::VideoAspectRatioPtr> { … };


template <>
struct  StructTraits<::media::mojom::VideoColorSpace::DataView,
                                         ::media::mojom::VideoColorSpacePtr> { … };


template <>
struct  StructTraits<::media::mojom::AudioDecoderConfig::DataView,
                                         ::media::mojom::AudioDecoderConfigPtr> { … };


template <>
struct  StructTraits<::media::mojom::VideoDecoderConfig::DataView,
                                         ::media::mojom::VideoDecoderConfigPtr> { … };


template <>
struct  StructTraits<::media::mojom::DecryptConfig::DataView,
                                         ::media::mojom::DecryptConfigPtr> { … };


template <>
struct  StructTraits<::media::mojom::DecoderBufferSideData::DataView,
                                         ::media::mojom::DecoderBufferSideDataPtr> { … };


template <>
struct  StructTraits<::media::mojom::DecoderBuffer::DataView,
                                         ::media::mojom::DecoderBufferPtr> { … };


template <>
struct  StructTraits<::media::mojom::AudioBuffer::DataView,
                                         ::media::mojom::AudioBufferPtr> { … };


template <>
struct  StructTraits<::media::mojom::VideoFrameMetadata::DataView,
                                         ::media::mojom::VideoFrameMetadataPtr> { … };


template <>
struct  StructTraits<::media::mojom::VideoFrame::DataView,
                                         ::media::mojom::VideoFramePtr> { … };


template <>
struct  StructTraits<::media::mojom::EosVideoFrameData::DataView,
                                         ::media::mojom::EosVideoFrameDataPtr> { … };


template <>
struct  StructTraits<::media::mojom::SharedMemoryVideoFrameData::DataView,
                                         ::media::mojom::SharedMemoryVideoFrameDataPtr> { … };


template <>
struct  StructTraits<::media::mojom::GpuMemoryBufferSharedImageVideoFrameData::DataView,
                                         ::media::mojom::GpuMemoryBufferSharedImageVideoFrameDataPtr> { … };


template <>
struct  StructTraits<::media::mojom::MailboxVideoFrameData::DataView,
                                         ::media::mojom::MailboxVideoFrameDataPtr> { … };


template <>
struct  StructTraits<::media::mojom::SharedImageVideoFrameData::DataView,
                                         ::media::mojom::SharedImageVideoFrameDataPtr> { … };


template <>
struct  StructTraits<::media::mojom::PipelineStatistics::DataView,
                                         ::media::mojom::PipelineStatisticsPtr> { … };


template <>
struct  StructTraits<::media::mojom::PredictionFeatures::DataView,
                                         ::media::mojom::PredictionFeaturesPtr> { … };


template <>
struct  StructTraits<::media::mojom::PredictionTargets::DataView,
                                         ::media::mojom::PredictionTargetsPtr> { … };


template <>
struct  StructTraits<::media::mojom::AudioPipelineInfo::DataView,
                                         ::media::mojom::AudioPipelineInfoPtr> { … };


template <>
struct  StructTraits<::media::mojom::VideoPipelineInfo::DataView,
                                         ::media::mojom::VideoPipelineInfoPtr> { … };


template <>
struct  StructTraits<::media::mojom::StatusData::DataView,
                                         ::media::mojom::StatusDataPtr> { … };


template <>
struct  StructTraits<::media::mojom::EncoderStatus::DataView,
                                         ::media::mojom::EncoderStatusPtr> { … };


template <>
struct  StructTraits<::media::mojom::DecoderStatus::DataView,
                                         ::media::mojom::DecoderStatusPtr> { … };


template <>
struct  StructTraits<::media::mojom::PipelineStatus::DataView,
                                         ::media::mojom::PipelineStatusPtr> { … };


template <>
struct  UnionTraits<::media::mojom::VideoFrameData::DataView,
                                        ::media::mojom::VideoFrameDataPtr> { … };

}  // namespace mojo

#endif  // MEDIA_MOJO_MOJOM_MEDIA_TYPES_MOJOM_H_