chromium/out/Default/gen/gpu/ipc/common/gpu_channel.mojom.h

// gpu/ipc/common/gpu_channel.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 GPU_IPC_COMMON_GPU_CHANNEL_MOJOM_H_
#define GPU_IPC_COMMON_GPU_CHANNEL_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 "gpu/ipc/common/gpu_channel.mojom-features.h"  // IWYU pragma: export
#include "gpu/ipc/common/gpu_channel.mojom-shared.h"  // IWYU pragma: export
#include "gpu/ipc/common/gpu_channel.mojom-forward.h"  // IWYU pragma: export
#include "gpu/ipc/common/capabilities.mojom.h"
#include "gpu/ipc/common/context_result.mojom.h"
#include "gpu/ipc/common/mailbox.mojom.h"
#include "gpu/ipc/common/shared_image_metadata.mojom.h"
#include "gpu/ipc/common/surface_handle.mojom-forward.h"
#include "gpu/ipc/common/sync_token.mojom.h"
#include "gpu/ipc/common/vulkan_ycbcr_info.mojom-forward.h"
#include "mojo/public/mojom/base/shared_memory.mojom.h"
#include "mojo/public/mojom/base/unguessable_token.mojom.h"
#include "services/viz/public/mojom/compositing/shared_image_format.mojom.h"
#include "skia/public/mojom/image_info.mojom-forward.h"
#include "skia/public/mojom/surface_origin.mojom-forward.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/gpu_fence_handle.mojom.h"
#include "ui/gfx/mojom/native_handle_types.mojom-forward.h"
#include "ui/gfx/mojom/presentation_feedback.mojom-forward.h"
#include "ui/gl/mojom/gpu_preference.mojom.h"
#include "url/mojom/url.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 "gpu/ipc/common/command_buffer_mojom_traits.h"
#include "gpu/ipc/common/context_creation_attribs_mojom_traits.h"
#include "gpu/ipc/common/gpu_param_traits_macros.h"
#include "gpu/ipc/common/scheduling_priority_mojom_traits.h"
#include "gpu/gpu_export.h"




namespace gpu::mojom {

class GpuChannelProxy;

template <typename ImplRefTraits>
class GpuChannelStub;

class GpuChannelRequestValidator;
class GpuChannelResponseValidator;


class GPU_EXPORT GpuChannel
    : public GpuChannelInterfaceBase { … };

class CommandBufferProxy;

template <typename ImplRefTraits>
class CommandBufferStub;

class CommandBufferRequestValidator;
class CommandBufferResponseValidator;


class GPU_EXPORT CommandBuffer
    : public CommandBufferInterfaceBase { … };

class CommandBufferClientProxy;

template <typename ImplRefTraits>
class CommandBufferClientStub;

class CommandBufferClientRequestValidator;


class GPU_EXPORT CommandBufferClient
    : public CommandBufferClientInterfaceBase { … };



class GPU_EXPORT GpuChannelProxy
    : public GpuChannel { … };



class GPU_EXPORT CommandBufferProxy
    : public CommandBuffer { … };



class GPU_EXPORT CommandBufferClientProxy
    : public CommandBufferClient { … };
class GPU_EXPORT GpuChannelStubDispatch { … };

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

  GpuChannelStub() = default;
  ~GpuChannelStub() 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 GPU_EXPORT CommandBufferStubDispatch { … };

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

  CommandBufferStub() = default;
  ~CommandBufferStub() 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 GPU_EXPORT CommandBufferClientStubDispatch { … };

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

  CommandBufferClientStub() = default;
  ~CommandBufferClientStub() 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 GPU_EXPORT GpuChannelRequestValidator : public mojo::MessageReceiver { … };
class GPU_EXPORT CommandBufferRequestValidator : public mojo::MessageReceiver { … };
class GPU_EXPORT CommandBufferClientRequestValidator : public mojo::MessageReceiver { … };
class GPU_EXPORT GpuChannelResponseValidator : public mojo::MessageReceiver { … };
class GPU_EXPORT CommandBufferResponseValidator : public mojo::MessageReceiver { … };





















class GPU_EXPORT DeferredRequestParams { … };



class GPU_EXPORT DeferredCommandBufferRequestParams { … };



class GPU_EXPORT DeferredSharedImageRequest { … };





class GPU_EXPORT ContextCreationAttribs { … };

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

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

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

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





class GPU_EXPORT CreateCommandBufferParams { … };

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

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

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

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





class GPU_EXPORT CommandBufferState { … };

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

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

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

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





class GPU_EXPORT ScheduleImageDecodeParams { … };

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

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

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

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






class GPU_EXPORT DeferredRequest { … };

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

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

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

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





class GPU_EXPORT DeferredCommandBufferRequest { … };

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

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

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

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





class GPU_EXPORT AsyncFlushParams { … };

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

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

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

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





class GPU_EXPORT SetDefaultFramebufferSharedImageParams { … };

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

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

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

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





class GPU_EXPORT SharedImageInfo { … };

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

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

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

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





class GPU_EXPORT CreateSharedImageParams { … };

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

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

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

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





class GPU_EXPORT CreateSharedImageWithDataParams { … };

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

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

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

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





class GPU_EXPORT CreateSharedImageWithBufferParams { … };

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

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

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

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





class GPU_EXPORT UpdateSharedImageParams { … };

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

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

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

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





class GPU_EXPORT AddReferenceToSharedImageParams { … };

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

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

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

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





class GPU_EXPORT CopyToGpuMemoryBufferParams { … };

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

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

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

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

template <typename UnionPtrType>
DeferredRequestParamsPtr DeferredRequestParams::Clone() const { … }

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

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

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

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

template <typename T, ContextCreationAttribs::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CreateCommandBufferParamsPtr CreateCommandBufferParams::Clone() const { … }

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

template <typename T, CreateCommandBufferParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CommandBufferStatePtr CommandBufferState::Clone() const { … }

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

template <typename T, CommandBufferState::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
ScheduleImageDecodeParamsPtr ScheduleImageDecodeParams::Clone() const { … }

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

template <typename T, ScheduleImageDecodeParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
DeferredRequestPtr DeferredRequest::Clone() const { … }

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

template <typename T, DeferredRequest::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
DeferredCommandBufferRequestPtr DeferredCommandBufferRequest::Clone() const { … }

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

template <typename T, DeferredCommandBufferRequest::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
AsyncFlushParamsPtr AsyncFlushParams::Clone() const { … }

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

template <typename T, AsyncFlushParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SetDefaultFramebufferSharedImageParamsPtr SetDefaultFramebufferSharedImageParams::Clone() const { … }

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

template <typename T, SetDefaultFramebufferSharedImageParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
SharedImageInfoPtr SharedImageInfo::Clone() const { … }

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

template <typename T, SharedImageInfo::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CreateSharedImageParamsPtr CreateSharedImageParams::Clone() const { … }

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

template <typename T, CreateSharedImageParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CreateSharedImageWithDataParamsPtr CreateSharedImageWithDataParams::Clone() const { … }

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

template <typename T, CreateSharedImageWithDataParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CreateSharedImageWithBufferParamsPtr CreateSharedImageWithBufferParams::Clone() const { … }

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

template <typename T, CreateSharedImageWithBufferParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
UpdateSharedImageParamsPtr UpdateSharedImageParams::Clone() const { … }

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

template <typename T, UpdateSharedImageParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
AddReferenceToSharedImageParamsPtr AddReferenceToSharedImageParams::Clone() const { … }

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

template <typename T, AddReferenceToSharedImageParams::EnableIfSame<T>*>
bool operator<(const T& lhs, const T& rhs) { … }
template <typename StructPtrType>
CopyToGpuMemoryBufferParamsPtr CopyToGpuMemoryBufferParams::Clone() const { … }

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

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


}  // gpu::mojom

namespace mojo {


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::ContextCreationAttribs::DataView,
                                         ::gpu::mojom::ContextCreationAttribsPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::CreateCommandBufferParams::DataView,
                                         ::gpu::mojom::CreateCommandBufferParamsPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::CommandBufferState::DataView,
                                         ::gpu::mojom::CommandBufferStatePtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::ScheduleImageDecodeParams::DataView,
                                         ::gpu::mojom::ScheduleImageDecodeParamsPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::DeferredRequest::DataView,
                                         ::gpu::mojom::DeferredRequestPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::DeferredCommandBufferRequest::DataView,
                                         ::gpu::mojom::DeferredCommandBufferRequestPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::AsyncFlushParams::DataView,
                                         ::gpu::mojom::AsyncFlushParamsPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::SetDefaultFramebufferSharedImageParams::DataView,
                                         ::gpu::mojom::SetDefaultFramebufferSharedImageParamsPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::SharedImageInfo::DataView,
                                         ::gpu::mojom::SharedImageInfoPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::CreateSharedImageParams::DataView,
                                         ::gpu::mojom::CreateSharedImageParamsPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::CreateSharedImageWithDataParams::DataView,
                                         ::gpu::mojom::CreateSharedImageWithDataParamsPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::CreateSharedImageWithBufferParams::DataView,
                                         ::gpu::mojom::CreateSharedImageWithBufferParamsPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::UpdateSharedImageParams::DataView,
                                         ::gpu::mojom::UpdateSharedImageParamsPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::AddReferenceToSharedImageParams::DataView,
                                         ::gpu::mojom::AddReferenceToSharedImageParamsPtr> { … };


template <>
struct GPU_EXPORT StructTraits<::gpu::mojom::CopyToGpuMemoryBufferParams::DataView,
                                         ::gpu::mojom::CopyToGpuMemoryBufferParamsPtr> { … };


template <>
struct GPU_EXPORT UnionTraits<::gpu::mojom::DeferredRequestParams::DataView,
                                        ::gpu::mojom::DeferredRequestParamsPtr> { … };


template <>
struct GPU_EXPORT UnionTraits<::gpu::mojom::DeferredCommandBufferRequestParams::DataView,
                                        ::gpu::mojom::DeferredCommandBufferRequestParamsPtr> { … };


template <>
struct GPU_EXPORT UnionTraits<::gpu::mojom::DeferredSharedImageRequest::DataView,
                                        ::gpu::mojom::DeferredSharedImageRequestPtr> { … };

}  // namespace mojo

#endif  // GPU_IPC_COMMON_GPU_CHANNEL_MOJOM_H_