chromium/out/Default/gen/services/webnn/public/mojom/webnn_graph.mojom-blink.cc

// services/webnn/public/mojom/webnn_graph.mojom-blink.cc 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.

#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

#include "services/webnn/public/mojom/webnn_graph.mojom-blink.h"

#include <math.h>
#include <stdint.h>
#include <utility>

#include "base/debug/alias.h"
#include "base/hash/md5_constexpr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/typed_macros.h"
#include "mojo/public/cpp/bindings/features.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/proxy_to_responder.h"
#include "mojo/public/cpp/bindings/lib/send_message_helper.h"
#include "mojo/public/cpp/bindings/lib/serialization_util.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "mojo/public/cpp/bindings/urgent_message_scope.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "services/webnn/public/mojom/webnn_graph.mojom-params-data.h"
#include "services/webnn/public/mojom/webnn_graph.mojom-shared-message-ids.h"

#include "services/webnn/public/mojom/webnn_graph.mojom-blink-import-headers.h"
#include "services/webnn/public/mojom/webnn_graph.mojom-blink-test-utils.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"


namespace webnn::mojom::blink {
OperandDescriptor::OperandDescriptor()
    : … { … }

OperandDescriptor::OperandDescriptor(
    DataType data_type_in,
    WTF::Vector<uint32_t> shape_in)
    : … { … }

OperandDescriptor::~OperandDescriptor() = default;

void OperandDescriptor::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool OperandDescriptor::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Operand::Operand()
    : … { … }

Operand::Operand(
    Operand::Kind kind_in,
    const ::webnn::OperandDescriptor& descriptor_in,
    const WTF::String& name_in)
    : … { … }

Operand::~Operand() = default;

void Operand::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Operand::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ArgMinMax::ArgMinMax()
    : … { … }

ArgMinMax::ArgMinMax(
    ArgMinMax::Kind kind_in,
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    uint32_t axis_in,
    bool keep_dimensions_in,
    const WTF::String& label_in)
    : … { … }

ArgMinMax::~ArgMinMax() = default;
size_t ArgMinMax::Hash(size_t seed) const { … }

void ArgMinMax::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ArgMinMax::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
BatchNormalization::BatchNormalization()
    : … { … }

BatchNormalization::BatchNormalization(
    uint64_t input_operand_id_in,
    uint64_t mean_operand_id_in,
    uint64_t variance_operand_id_in,
    uint64_t output_operand_id_in,
    std::optional<uint64_t> scale_operand_id_in,
    std::optional<uint64_t> bias_operand_id_in,
    uint32_t axis_in,
    float epsilon_in,
    const WTF::String& label_in)
    : … { … }

BatchNormalization::~BatchNormalization() = default;

void BatchNormalization::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool BatchNormalization::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Clamp::Clamp()
    : … { … }

Clamp::Clamp(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    float min_value_in,
    float max_value_in,
    const WTF::String& label_in)
    : … { … }

Clamp::~Clamp() = default;
size_t Clamp::Hash(size_t seed) const { … }

void Clamp::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Clamp::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Concat::Concat()
    : … { … }

Concat::Concat(
    WTF::Vector<uint64_t> input_operand_ids_in,
    uint64_t output_operand_id_in,
    uint32_t axis_in,
    const WTF::String& label_in)
    : … { … }

Concat::~Concat() = default;

void Concat::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Concat::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Size2d::Size2d()
    : … { … }

Size2d::Size2d(
    uint32_t height_in,
    uint32_t width_in)
    : … { … }

Size2d::~Size2d() = default;
size_t Size2d::Hash(size_t seed) const { … }

void Size2d::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Size2d::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Padding2d::Padding2d()
    : … { … }

Padding2d::Padding2d(
    Size2dPtr beginning_in,
    Size2dPtr ending_in)
    : … { … }

Padding2d::~Padding2d() = default;
size_t Padding2d::Hash(size_t seed) const { … }

void Padding2d::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Padding2d::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Conv2d::Conv2d()
    : … { … }

Conv2d::Conv2d(
    Conv2d::Kind kind_in,
    uint64_t input_operand_id_in,
    uint64_t filter_operand_id_in,
    uint64_t output_operand_id_in,
    Padding2dPtr padding_in,
    Size2dPtr strides_in,
    Size2dPtr dilations_in,
    uint32_t groups_in,
    std::optional<uint64_t> bias_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Conv2d::~Conv2d() = default;

void Conv2d::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Conv2d::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ElementWiseBinary::ElementWiseBinary()
    : … { … }

ElementWiseBinary::ElementWiseBinary(
    ElementWiseBinary::Kind kind_in,
    uint64_t lhs_operand_id_in,
    uint64_t rhs_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

ElementWiseBinary::~ElementWiseBinary() = default;
size_t ElementWiseBinary::Hash(size_t seed) const { … }

void ElementWiseBinary::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ElementWiseBinary::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ElementWiseUnary::ElementWiseUnary()
    : … { … }

ElementWiseUnary::ElementWiseUnary(
    ElementWiseUnary::Kind kind_in,
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

ElementWiseUnary::~ElementWiseUnary() = default;
size_t ElementWiseUnary::Hash(size_t seed) const { … }

void ElementWiseUnary::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ElementWiseUnary::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Expand::Expand()
    : … { … }

Expand::Expand(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Expand::~Expand() = default;
size_t Expand::Hash(size_t seed) const { … }

void Expand::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Expand::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ConstantPadding::ConstantPadding()
    : … { … }

ConstantPadding::ConstantPadding(
    float value_in)
    : … { … }

ConstantPadding::~ConstantPadding() = default;
size_t ConstantPadding::Hash(size_t seed) const { … }

void ConstantPadding::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ConstantPadding::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
EdgePadding::EdgePadding() { … }

EdgePadding::~EdgePadding() = default;
size_t EdgePadding::Hash(size_t seed) const { … }

void EdgePadding::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool EdgePadding::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ReflectionPadding::ReflectionPadding() { … }

ReflectionPadding::~ReflectionPadding() = default;
size_t ReflectionPadding::Hash(size_t seed) const { … }

void ReflectionPadding::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool ReflectionPadding::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
SymmetricPadding::SymmetricPadding() { … }

SymmetricPadding::~SymmetricPadding() = default;
size_t SymmetricPadding::Hash(size_t seed) const { … }

void SymmetricPadding::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool SymmetricPadding::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
InstanceNormalization::InstanceNormalization()
    : … { … }

InstanceNormalization::InstanceNormalization(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    std::optional<uint64_t> scale_operand_id_in,
    std::optional<uint64_t> bias_operand_id_in,
    float epsilon_in,
    ::webnn::mojom::blink::InputOperandLayout layout_in,
    const WTF::String& label_in)
    : … { … }

InstanceNormalization::~InstanceNormalization() = default;

void InstanceNormalization::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool InstanceNormalization::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Matmul::Matmul()
    : … { … }

Matmul::Matmul(
    uint64_t a_operand_id_in,
    uint64_t b_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Matmul::~Matmul() = default;
size_t Matmul::Hash(size_t seed) const { … }

void Matmul::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Matmul::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Pad::Pad()
    : … { … }

Pad::Pad(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    WTF::Vector<uint32_t> beginning_padding_in,
    WTF::Vector<uint32_t> ending_padding_in,
    PaddingModePtr mode_in,
    const WTF::String& label_in)
    : … { … }

Pad::~Pad() = default;

void Pad::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Pad::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Reduce::Reduce()
    : … { … }

Reduce::Reduce(
    Reduce::Kind kind_in,
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    WTF::Vector<uint32_t> axes_in,
    bool keep_dimensions_in,
    const WTF::String& label_in)
    : … { … }

Reduce::~Reduce() = default;

void Reduce::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Reduce::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Pool2d::Pool2d()
    : … { … }

Pool2d::Pool2d(
    Pool2d::Kind kind_in,
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    Size2dPtr window_dimensions_in,
    Padding2dPtr padding_in,
    Size2dPtr strides_in,
    Size2dPtr dilations_in,
    const WTF::String& label_in)
    : … { … }

Pool2d::~Pool2d() = default;
size_t Pool2d::Hash(size_t seed) const { … }

void Pool2d::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Pool2d::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
StartAndSize::StartAndSize()
    : … { … }

StartAndSize::StartAndSize(
    uint32_t start_in,
    uint32_t size_in)
    : … { … }

StartAndSize::~StartAndSize() = default;
size_t StartAndSize::Hash(size_t seed) const { … }

void StartAndSize::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool StartAndSize::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Slice::Slice()
    : … { … }

Slice::Slice(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    WTF::Vector<StartAndSizePtr> starts_and_sizes_in,
    const WTF::String& label_in)
    : … { … }

Slice::~Slice() = default;

void Slice::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Slice::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Elu::Elu()
    : … { … }

Elu::Elu(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    float alpha_in,
    const WTF::String& label_in)
    : … { … }

Elu::~Elu() = default;
size_t Elu::Hash(size_t seed) const { … }

void Elu::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Elu::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Gather::Gather()
    : … { … }

Gather::Gather(
    uint64_t input_operand_id_in,
    uint64_t indices_operand_id_in,
    uint64_t output_operand_id_in,
    uint32_t axis_in,
    const WTF::String& label_in)
    : … { … }

Gather::~Gather() = default;
size_t Gather::Hash(size_t seed) const { … }

void Gather::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Gather::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
GatherElements::GatherElements()
    : … { … }

GatherElements::GatherElements(
    uint64_t input_operand_id_in,
    uint64_t indices_operand_id_in,
    uint64_t output_operand_id_in,
    uint32_t axis_in,
    const WTF::String& label_in)
    : … { … }

GatherElements::~GatherElements() = default;
size_t GatherElements::Hash(size_t seed) const { … }

void GatherElements::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool GatherElements::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Gelu::Gelu()
    : … { … }

Gelu::Gelu(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Gelu::~Gelu() = default;
size_t Gelu::Hash(size_t seed) const { … }

void Gelu::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Gelu::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Gru::Gru()
    : … { … }

Gru::Gru(
    uint64_t input_operand_id_in,
    uint64_t weight_operand_id_in,
    uint64_t recurrent_weight_operand_id_in,
    uint32_t steps_in,
    uint32_t hidden_size_in,
    WTF::Vector<uint64_t> output_operand_ids_in,
    std::optional<uint64_t> bias_operand_id_in,
    std::optional<uint64_t> recurrent_bias_operand_id_in,
    std::optional<uint64_t> initial_hidden_state_operand_id_in,
    bool reset_after_in,
    bool return_sequence_in,
    RecurrentNetworkDirection direction_in,
    GruWeightLayout layout_in,
    WTF::Vector<RecurrentNetworkActivation> activations_in,
    const WTF::String& label_in)
    : … { … }

Gru::~Gru() = default;

void Gru::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Gru::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
GruCell::GruCell()
    : … { … }

GruCell::GruCell(
    uint64_t input_operand_id_in,
    uint64_t weight_operand_id_in,
    uint64_t recurrent_weight_operand_id_in,
    uint64_t hidden_state_operand_id_in,
    uint32_t hidden_size_in,
    uint64_t output_operand_id_in,
    std::optional<uint64_t> bias_operand_id_in,
    std::optional<uint64_t> recurrent_bias_operand_id_in,
    bool reset_after_in,
    GruWeightLayout layout_in,
    WTF::Vector<RecurrentNetworkActivation> activations_in,
    const WTF::String& label_in)
    : … { … }

GruCell::~GruCell() = default;

void GruCell::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool GruCell::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Gemm::Gemm()
    : … { … }

Gemm::Gemm(
    uint64_t a_operand_id_in,
    uint64_t b_operand_id_in,
    uint64_t output_operand_id_in,
    std::optional<uint64_t> c_operand_id_in,
    float alpha_in,
    float beta_in,
    bool a_transpose_in,
    bool b_transpose_in,
    const WTF::String& label_in)
    : … { … }

Gemm::~Gemm() = default;

void Gemm::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Gemm::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
HardSigmoid::HardSigmoid()
    : … { … }

HardSigmoid::HardSigmoid(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    float alpha_in,
    float beta_in,
    const WTF::String& label_in)
    : … { … }

HardSigmoid::~HardSigmoid() = default;
size_t HardSigmoid::Hash(size_t seed) const { … }

void HardSigmoid::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool HardSigmoid::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
HardSwish::HardSwish()
    : … { … }

HardSwish::HardSwish(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

HardSwish::~HardSwish() = default;
size_t HardSwish::Hash(size_t seed) const { … }

void HardSwish::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool HardSwish::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
LayerNormalization::LayerNormalization()
    : … { … }

LayerNormalization::LayerNormalization(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    std::optional<uint64_t> scale_operand_id_in,
    std::optional<uint64_t> bias_operand_id_in,
    WTF::Vector<uint32_t> axes_in,
    float epsilon_in,
    const WTF::String& label_in)
    : … { … }

LayerNormalization::~LayerNormalization() = default;

void LayerNormalization::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool LayerNormalization::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
LeakyRelu::LeakyRelu()
    : … { … }

LeakyRelu::LeakyRelu(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    float alpha_in,
    const WTF::String& label_in)
    : … { … }

LeakyRelu::~LeakyRelu() = default;
size_t LeakyRelu::Hash(size_t seed) const { … }

void LeakyRelu::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool LeakyRelu::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Linear::Linear()
    : … { … }

Linear::Linear(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    float alpha_in,
    float beta_in,
    const WTF::String& label_in)
    : … { … }

Linear::~Linear() = default;
size_t Linear::Hash(size_t seed) const { … }

void Linear::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Linear::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Lstm::Lstm()
    : … { … }

Lstm::Lstm(
    uint64_t input_operand_id_in,
    uint64_t weight_operand_id_in,
    uint64_t recurrent_weight_operand_id_in,
    WTF::Vector<uint64_t> output_operand_ids_in,
    uint32_t steps_in,
    uint32_t hidden_size_in,
    std::optional<uint64_t> bias_operand_id_in,
    std::optional<uint64_t> recurrent_bias_operand_id_in,
    std::optional<uint64_t> peephole_weight_operand_id_in,
    std::optional<uint64_t> initial_hidden_state_operand_id_in,
    std::optional<uint64_t> initial_cell_state_operand_id_in,
    bool return_sequence_in,
    RecurrentNetworkDirection direction_in,
    LstmWeightLayout layout_in,
    WTF::Vector<RecurrentNetworkActivation> activations_in,
    const WTF::String& label_in)
    : … { … }

Lstm::~Lstm() = default;

void Lstm::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Lstm::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
LstmCell::LstmCell()
    : … { … }

LstmCell::LstmCell(
    uint64_t input_operand_id_in,
    uint64_t weight_operand_id_in,
    uint64_t recurrent_weight_operand_id_in,
    uint64_t hidden_state_operand_id_in,
    uint64_t cell_state_operand_id_in,
    WTF::Vector<uint64_t> output_operand_ids_in,
    uint32_t hidden_size_in,
    std::optional<uint64_t> bias_operand_id_in,
    std::optional<uint64_t> recurrent_bias_operand_id_in,
    std::optional<uint64_t> peephole_weight_operand_id_in,
    LstmWeightLayout layout_in,
    WTF::Vector<RecurrentNetworkActivation> activations_in,
    const WTF::String& label_in)
    : … { … }

LstmCell::~LstmCell() = default;

void LstmCell::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool LstmCell::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Prelu::Prelu()
    : … { … }

Prelu::Prelu(
    uint64_t input_operand_id_in,
    uint64_t slope_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Prelu::~Prelu() = default;
size_t Prelu::Hash(size_t seed) const { … }

void Prelu::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Prelu::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Relu::Relu()
    : … { … }

Relu::Relu(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Relu::~Relu() = default;
size_t Relu::Hash(size_t seed) const { … }

void Relu::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Relu::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Reshape::Reshape()
    : … { … }

Reshape::Reshape(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Reshape::~Reshape() = default;
size_t Reshape::Hash(size_t seed) const { … }

void Reshape::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Reshape::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Sigmoid::Sigmoid()
    : … { … }

Sigmoid::Sigmoid(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Sigmoid::~Sigmoid() = default;
size_t Sigmoid::Hash(size_t seed) const { … }

void Sigmoid::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Sigmoid::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Softmax::Softmax()
    : … { … }

Softmax::Softmax(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    uint32_t axis_in,
    const WTF::String& label_in)
    : … { … }

Softmax::~Softmax() = default;
size_t Softmax::Hash(size_t seed) const { … }

void Softmax::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Softmax::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Softplus::Softplus()
    : … { … }

Softplus::Softplus(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Softplus::~Softplus() = default;
size_t Softplus::Hash(size_t seed) const { … }

void Softplus::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Softplus::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Softsign::Softsign()
    : … { … }

Softsign::Softsign(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Softsign::~Softsign() = default;
size_t Softsign::Hash(size_t seed) const { … }

void Softsign::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Softsign::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Split::Split()
    : … { … }

Split::Split(
    uint64_t input_operand_id_in,
    WTF::Vector<uint64_t> output_operand_ids_in,
    uint32_t axis_in,
    const WTF::String& label_in)
    : … { … }

Split::~Split() = default;

void Split::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Split::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Tanh::Tanh()
    : … { … }

Tanh::Tanh(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Tanh::~Tanh() = default;
size_t Tanh::Hash(size_t seed) const { … }

void Tanh::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Tanh::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Transpose::Transpose()
    : … { … }

Transpose::Transpose(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    WTF::Vector<uint32_t> permutation_in,
    const WTF::String& label_in)
    : … { … }

Transpose::~Transpose() = default;

void Transpose::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Transpose::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Triangular::Triangular()
    : … { … }

Triangular::Triangular(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    bool upper_in,
    int32_t diagonal_in,
    const WTF::String& label_in)
    : … { … }

Triangular::~Triangular() = default;
size_t Triangular::Hash(size_t seed) const { … }

void Triangular::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Triangular::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Resample2d::Resample2d()
    : … { … }

Resample2d::Resample2d(
    uint64_t input_operand_id_in,
    uint64_t output_operand_id_in,
    Resample2d::InterpolationMode mode_in,
    std::optional<WTF::Vector<float>> scales_in,
    WTF::Vector<uint32_t> axes_in,
    const WTF::String& label_in)
    : … { … }

Resample2d::~Resample2d() = default;

void Resample2d::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Resample2d::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Where::Where()
    : … { … }

Where::Where(
    uint64_t condition_operand_id_in,
    uint64_t true_value_operand_id_in,
    uint64_t false_value_operand_id_in,
    uint64_t output_operand_id_in,
    const WTF::String& label_in)
    : … { … }

Where::~Where() = default;
size_t Where::Hash(size_t seed) const { … }

void Where::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool Where::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
GraphInfo::GraphInfo()
    : … { … }

GraphInfo::GraphInfo(
    WTF::HashMap<uint64_t, OperandPtr> id_to_operand_map_in,
    WTF::Vector<uint64_t> input_operands_in,
    WTF::Vector<uint64_t> output_operands_in,
    WTF::Vector<OperationPtr> operations_in,
    WTF::HashMap<uint64_t, ::mojo_base::BigBuffer> constant_id_to_buffer_map_in)
    : … { … }

GraphInfo::~GraphInfo() = default;

void GraphInfo::WriteIntoTrace(
    perfetto::TracedValue traced_context) const { … }

bool GraphInfo::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
PaddingMode::PaddingMode() : … { … }

PaddingMode::~PaddingMode() { … }


void PaddingMode::set_constant(
    ConstantPaddingPtr constant) { … }
void PaddingMode::set_edge(
    EdgePaddingPtr edge) { … }
void PaddingMode::set_reflection(
    ReflectionPaddingPtr reflection) { … }
void PaddingMode::set_symmetric(
    SymmetricPaddingPtr symmetric) { … }

void PaddingMode::DestroyActive() { … }
size_t PaddingMode::Hash(size_t seed) const { … }

bool PaddingMode::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
Operation::Operation() : … { … }

Operation::~Operation() { … }


void Operation::set_arg_min_max(
    ArgMinMaxPtr arg_min_max) { … }
void Operation::set_batch_normalization(
    BatchNormalizationPtr batch_normalization) { … }
void Operation::set_clamp(
    ClampPtr clamp) { … }
void Operation::set_concat(
    ConcatPtr concat) { … }
void Operation::set_conv2d(
    Conv2dPtr conv2d) { … }
void Operation::set_element_wise_binary(
    ElementWiseBinaryPtr element_wise_binary) { … }
void Operation::set_elu(
    EluPtr elu) { … }
void Operation::set_element_wise_unary(
    ElementWiseUnaryPtr element_wise_unary) { … }
void Operation::set_expand(
    ExpandPtr expand) { … }
void Operation::set_gather(
    GatherPtr gather) { … }
void Operation::set_gather_elements(
    GatherElementsPtr gather_elements) { … }
void Operation::set_gelu(
    GeluPtr gelu) { … }
void Operation::set_gemm(
    GemmPtr gemm) { … }
void Operation::set_gru(
    GruPtr gru) { … }
void Operation::set_gru_cell(
    GruCellPtr gru_cell) { … }
void Operation::set_hard_sigmoid(
    HardSigmoidPtr hard_sigmoid) { … }
void Operation::set_hard_swish(
    HardSwishPtr hard_swish) { … }
void Operation::set_layer_normalization(
    LayerNormalizationPtr layer_normalization) { … }
void Operation::set_instance_normalization(
    InstanceNormalizationPtr instance_normalization) { … }
void Operation::set_leaky_relu(
    LeakyReluPtr leaky_relu) { … }
void Operation::set_linear(
    LinearPtr linear) { … }
void Operation::set_lstm(
    LstmPtr lstm) { … }
void Operation::set_lstm_cell(
    LstmCellPtr lstm_cell) { … }
void Operation::set_matmul(
    MatmulPtr matmul) { … }
void Operation::set_pad(
    PadPtr pad) { … }
void Operation::set_pool2d(
    Pool2dPtr pool2d) { … }
void Operation::set_prelu(
    PreluPtr prelu) { … }
void Operation::set_reduce(
    ReducePtr reduce) { … }
void Operation::set_relu(
    ReluPtr relu) { … }
void Operation::set_resample2d(
    Resample2dPtr resample2d) { … }
void Operation::set_reshape(
    ReshapePtr reshape) { … }
void Operation::set_sigmoid(
    SigmoidPtr sigmoid) { … }
void Operation::set_slice(
    SlicePtr slice) { … }
void Operation::set_softmax(
    SoftmaxPtr softmax) { … }
void Operation::set_softplus(
    SoftplusPtr softplus) { … }
void Operation::set_softsign(
    SoftsignPtr softsign) { … }
void Operation::set_split(
    SplitPtr split) { … }
void Operation::set_tanh(
    TanhPtr tanh) { … }
void Operation::set_transpose(
    TransposePtr transpose) { … }
void Operation::set_triangular(
    TriangularPtr triangular) { … }
void Operation::set_where(
    WherePtr where) { … }

void Operation::DestroyActive() { … }

bool Operation::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
ComputeResult::ComputeResult() : … { … }

ComputeResult::~ComputeResult() { … }


void ComputeResult::set_named_outputs(
    WTF::HashMap<WTF::String, ::mojo_base::BigBuffer> named_outputs) { … }
void ComputeResult::set_error(
    ::webnn::mojom::blink::ErrorPtr error) { … }

void ComputeResult::DestroyActive() { … }

bool ComputeResult::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) { … }
const char WebNNGraph::Name_[] = …;

WebNNGraph::IPCStableHashFunction WebNNGraph::MessageToMethodInfo_(mojo::Message& message) { … }


const char* WebNNGraph::MessageToMethodName_(mojo::Message& message) { … }

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t WebNNGraph::Compute_Sym::IPCStableHash() { … }
uint32_t WebNNGraph::Dispatch_Sym::IPCStableHash() { … }
# endif // !BUILDFLAG(IS_FUCHSIA)

class WebNNGraph_Compute_ForwardToCallback
    : public mojo::MessageReceiver { … };

WebNNGraphProxy::WebNNGraphProxy(mojo::MessageReceiverWithResponder* receiver)
    : … { … }

void WebNNGraphProxy::Compute(
    WTF::HashMap<WTF::String, ::mojo_base::BigBuffer> in_named_inputs, ComputeCallback callback) { … }

void WebNNGraphProxy::Dispatch(
    const WTF::HashMap<WTF::String, ::blink::WebNNBufferToken>& in_named_inputs, const WTF::HashMap<WTF::String, ::blink::WebNNBufferToken>& in_named_outputs) { … }
class WebNNGraph_Compute_ProxyToResponder : public ::mojo::internal::ProxyToResponder { … };

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

void WebNNGraph_Compute_ProxyToResponder::Run(
    ComputeResultPtr in_result) { … }

// static
bool WebNNGraphStubDispatch::Accept(
    WebNNGraph* impl,
    mojo::Message* message) { … }

// static
bool WebNNGraphStubDispatch::AcceptWithResponder(
    WebNNGraph* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) { … }
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kWebNNGraphValidationInfo[] = …;

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

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


}  // webnn::mojom::blink


namespace mojo {


// static
bool StructTraits<::webnn::mojom::blink::OperandDescriptor::DataView, ::webnn::mojom::blink::OperandDescriptorPtr>::Read(
    ::webnn::mojom::blink::OperandDescriptor::DataView input,
    ::webnn::mojom::blink::OperandDescriptorPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Operand::DataView, ::webnn::mojom::blink::OperandPtr>::Read(
    ::webnn::mojom::blink::Operand::DataView input,
    ::webnn::mojom::blink::OperandPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::ArgMinMax::DataView, ::webnn::mojom::blink::ArgMinMaxPtr>::Read(
    ::webnn::mojom::blink::ArgMinMax::DataView input,
    ::webnn::mojom::blink::ArgMinMaxPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::BatchNormalization::DataView, ::webnn::mojom::blink::BatchNormalizationPtr>::Read(
    ::webnn::mojom::blink::BatchNormalization::DataView input,
    ::webnn::mojom::blink::BatchNormalizationPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Clamp::DataView, ::webnn::mojom::blink::ClampPtr>::Read(
    ::webnn::mojom::blink::Clamp::DataView input,
    ::webnn::mojom::blink::ClampPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Concat::DataView, ::webnn::mojom::blink::ConcatPtr>::Read(
    ::webnn::mojom::blink::Concat::DataView input,
    ::webnn::mojom::blink::ConcatPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Size2d::DataView, ::webnn::mojom::blink::Size2dPtr>::Read(
    ::webnn::mojom::blink::Size2d::DataView input,
    ::webnn::mojom::blink::Size2dPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Padding2d::DataView, ::webnn::mojom::blink::Padding2dPtr>::Read(
    ::webnn::mojom::blink::Padding2d::DataView input,
    ::webnn::mojom::blink::Padding2dPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Conv2d::DataView, ::webnn::mojom::blink::Conv2dPtr>::Read(
    ::webnn::mojom::blink::Conv2d::DataView input,
    ::webnn::mojom::blink::Conv2dPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::ElementWiseBinary::DataView, ::webnn::mojom::blink::ElementWiseBinaryPtr>::Read(
    ::webnn::mojom::blink::ElementWiseBinary::DataView input,
    ::webnn::mojom::blink::ElementWiseBinaryPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::ElementWiseUnary::DataView, ::webnn::mojom::blink::ElementWiseUnaryPtr>::Read(
    ::webnn::mojom::blink::ElementWiseUnary::DataView input,
    ::webnn::mojom::blink::ElementWiseUnaryPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Expand::DataView, ::webnn::mojom::blink::ExpandPtr>::Read(
    ::webnn::mojom::blink::Expand::DataView input,
    ::webnn::mojom::blink::ExpandPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::ConstantPadding::DataView, ::webnn::mojom::blink::ConstantPaddingPtr>::Read(
    ::webnn::mojom::blink::ConstantPadding::DataView input,
    ::webnn::mojom::blink::ConstantPaddingPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::EdgePadding::DataView, ::webnn::mojom::blink::EdgePaddingPtr>::Read(
    ::webnn::mojom::blink::EdgePadding::DataView input,
    ::webnn::mojom::blink::EdgePaddingPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::ReflectionPadding::DataView, ::webnn::mojom::blink::ReflectionPaddingPtr>::Read(
    ::webnn::mojom::blink::ReflectionPadding::DataView input,
    ::webnn::mojom::blink::ReflectionPaddingPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::SymmetricPadding::DataView, ::webnn::mojom::blink::SymmetricPaddingPtr>::Read(
    ::webnn::mojom::blink::SymmetricPadding::DataView input,
    ::webnn::mojom::blink::SymmetricPaddingPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::InstanceNormalization::DataView, ::webnn::mojom::blink::InstanceNormalizationPtr>::Read(
    ::webnn::mojom::blink::InstanceNormalization::DataView input,
    ::webnn::mojom::blink::InstanceNormalizationPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Matmul::DataView, ::webnn::mojom::blink::MatmulPtr>::Read(
    ::webnn::mojom::blink::Matmul::DataView input,
    ::webnn::mojom::blink::MatmulPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Pad::DataView, ::webnn::mojom::blink::PadPtr>::Read(
    ::webnn::mojom::blink::Pad::DataView input,
    ::webnn::mojom::blink::PadPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Reduce::DataView, ::webnn::mojom::blink::ReducePtr>::Read(
    ::webnn::mojom::blink::Reduce::DataView input,
    ::webnn::mojom::blink::ReducePtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Pool2d::DataView, ::webnn::mojom::blink::Pool2dPtr>::Read(
    ::webnn::mojom::blink::Pool2d::DataView input,
    ::webnn::mojom::blink::Pool2dPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::StartAndSize::DataView, ::webnn::mojom::blink::StartAndSizePtr>::Read(
    ::webnn::mojom::blink::StartAndSize::DataView input,
    ::webnn::mojom::blink::StartAndSizePtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Slice::DataView, ::webnn::mojom::blink::SlicePtr>::Read(
    ::webnn::mojom::blink::Slice::DataView input,
    ::webnn::mojom::blink::SlicePtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Elu::DataView, ::webnn::mojom::blink::EluPtr>::Read(
    ::webnn::mojom::blink::Elu::DataView input,
    ::webnn::mojom::blink::EluPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Gather::DataView, ::webnn::mojom::blink::GatherPtr>::Read(
    ::webnn::mojom::blink::Gather::DataView input,
    ::webnn::mojom::blink::GatherPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::GatherElements::DataView, ::webnn::mojom::blink::GatherElementsPtr>::Read(
    ::webnn::mojom::blink::GatherElements::DataView input,
    ::webnn::mojom::blink::GatherElementsPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Gelu::DataView, ::webnn::mojom::blink::GeluPtr>::Read(
    ::webnn::mojom::blink::Gelu::DataView input,
    ::webnn::mojom::blink::GeluPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Gru::DataView, ::webnn::mojom::blink::GruPtr>::Read(
    ::webnn::mojom::blink::Gru::DataView input,
    ::webnn::mojom::blink::GruPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::GruCell::DataView, ::webnn::mojom::blink::GruCellPtr>::Read(
    ::webnn::mojom::blink::GruCell::DataView input,
    ::webnn::mojom::blink::GruCellPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Gemm::DataView, ::webnn::mojom::blink::GemmPtr>::Read(
    ::webnn::mojom::blink::Gemm::DataView input,
    ::webnn::mojom::blink::GemmPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::HardSigmoid::DataView, ::webnn::mojom::blink::HardSigmoidPtr>::Read(
    ::webnn::mojom::blink::HardSigmoid::DataView input,
    ::webnn::mojom::blink::HardSigmoidPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::HardSwish::DataView, ::webnn::mojom::blink::HardSwishPtr>::Read(
    ::webnn::mojom::blink::HardSwish::DataView input,
    ::webnn::mojom::blink::HardSwishPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::LayerNormalization::DataView, ::webnn::mojom::blink::LayerNormalizationPtr>::Read(
    ::webnn::mojom::blink::LayerNormalization::DataView input,
    ::webnn::mojom::blink::LayerNormalizationPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::LeakyRelu::DataView, ::webnn::mojom::blink::LeakyReluPtr>::Read(
    ::webnn::mojom::blink::LeakyRelu::DataView input,
    ::webnn::mojom::blink::LeakyReluPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Linear::DataView, ::webnn::mojom::blink::LinearPtr>::Read(
    ::webnn::mojom::blink::Linear::DataView input,
    ::webnn::mojom::blink::LinearPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Lstm::DataView, ::webnn::mojom::blink::LstmPtr>::Read(
    ::webnn::mojom::blink::Lstm::DataView input,
    ::webnn::mojom::blink::LstmPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::LstmCell::DataView, ::webnn::mojom::blink::LstmCellPtr>::Read(
    ::webnn::mojom::blink::LstmCell::DataView input,
    ::webnn::mojom::blink::LstmCellPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Prelu::DataView, ::webnn::mojom::blink::PreluPtr>::Read(
    ::webnn::mojom::blink::Prelu::DataView input,
    ::webnn::mojom::blink::PreluPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Relu::DataView, ::webnn::mojom::blink::ReluPtr>::Read(
    ::webnn::mojom::blink::Relu::DataView input,
    ::webnn::mojom::blink::ReluPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Reshape::DataView, ::webnn::mojom::blink::ReshapePtr>::Read(
    ::webnn::mojom::blink::Reshape::DataView input,
    ::webnn::mojom::blink::ReshapePtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Sigmoid::DataView, ::webnn::mojom::blink::SigmoidPtr>::Read(
    ::webnn::mojom::blink::Sigmoid::DataView input,
    ::webnn::mojom::blink::SigmoidPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Softmax::DataView, ::webnn::mojom::blink::SoftmaxPtr>::Read(
    ::webnn::mojom::blink::Softmax::DataView input,
    ::webnn::mojom::blink::SoftmaxPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Softplus::DataView, ::webnn::mojom::blink::SoftplusPtr>::Read(
    ::webnn::mojom::blink::Softplus::DataView input,
    ::webnn::mojom::blink::SoftplusPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Softsign::DataView, ::webnn::mojom::blink::SoftsignPtr>::Read(
    ::webnn::mojom::blink::Softsign::DataView input,
    ::webnn::mojom::blink::SoftsignPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Split::DataView, ::webnn::mojom::blink::SplitPtr>::Read(
    ::webnn::mojom::blink::Split::DataView input,
    ::webnn::mojom::blink::SplitPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Tanh::DataView, ::webnn::mojom::blink::TanhPtr>::Read(
    ::webnn::mojom::blink::Tanh::DataView input,
    ::webnn::mojom::blink::TanhPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Transpose::DataView, ::webnn::mojom::blink::TransposePtr>::Read(
    ::webnn::mojom::blink::Transpose::DataView input,
    ::webnn::mojom::blink::TransposePtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Triangular::DataView, ::webnn::mojom::blink::TriangularPtr>::Read(
    ::webnn::mojom::blink::Triangular::DataView input,
    ::webnn::mojom::blink::TriangularPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Resample2d::DataView, ::webnn::mojom::blink::Resample2dPtr>::Read(
    ::webnn::mojom::blink::Resample2d::DataView input,
    ::webnn::mojom::blink::Resample2dPtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::Where::DataView, ::webnn::mojom::blink::WherePtr>::Read(
    ::webnn::mojom::blink::Where::DataView input,
    ::webnn::mojom::blink::WherePtr* output) { … }


// static
bool StructTraits<::webnn::mojom::blink::GraphInfo::DataView, ::webnn::mojom::blink::GraphInfoPtr>::Read(
    ::webnn::mojom::blink::GraphInfo::DataView input,
    ::webnn::mojom::blink::GraphInfoPtr* output) { … }

// static
bool UnionTraits<::webnn::mojom::blink::PaddingMode::DataView, ::webnn::mojom::blink::PaddingModePtr>::Read(
    ::webnn::mojom::blink::PaddingMode::DataView input,
    ::webnn::mojom::blink::PaddingModePtr* output) { … }

// static
bool UnionTraits<::webnn::mojom::blink::Operation::DataView, ::webnn::mojom::blink::OperationPtr>::Read(
    ::webnn::mojom::blink::Operation::DataView input,
    ::webnn::mojom::blink::OperationPtr* output) { … }

// static
bool UnionTraits<::webnn::mojom::blink::ComputeResult::DataView, ::webnn::mojom::blink::ComputeResultPtr>::Read(
    ::webnn::mojom::blink::ComputeResult::DataView input,
    ::webnn::mojom::blink::ComputeResultPtr* output) { … }

}  // namespace mojo


// Symbols declared in the -test-utils.h header are defined here instead of a
// separate .cc file to save compile time.


namespace webnn::mojom::blink {


void WebNNGraphInterceptorForTesting::Compute(WTF::HashMap<WTF::String, ::mojo_base::BigBuffer> named_inputs, ComputeCallback callback) { … }
void WebNNGraphInterceptorForTesting::Dispatch(const WTF::HashMap<WTF::String, ::blink::WebNNBufferToken>& named_inputs, const WTF::HashMap<WTF::String, ::blink::WebNNBufferToken>& named_outputs) { … }
WebNNGraphAsyncWaiter::WebNNGraphAsyncWaiter(
    WebNNGraph* proxy) : … { … }

WebNNGraphAsyncWaiter::~WebNNGraphAsyncWaiter() = default;

void WebNNGraphAsyncWaiter::Compute(
    WTF::HashMap<WTF::String, ::mojo_base::BigBuffer> named_inputs, ComputeResultPtr* out_result) { … }

ComputeResultPtr WebNNGraphAsyncWaiter::Compute(
    WTF::HashMap<WTF::String, ::mojo_base::BigBuffer> named_inputs) { … }






}  // webnn::mojom::blink


#if defined(__clang__)
#pragma clang diagnostic pop
#endif