// third_party/blink/public/mojom/tokens/tokens.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 "third_party/blink/public/mojom/tokens/tokens.mojom-blink.h"
#include <stdint.h>
#include <utility>
#include "base/notreached.h"
#include "mojo/public/cpp/bindings/lib/default_construct_tag_internal.h"
#include "mojo/public/cpp/bindings/lib/serialization.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 "third_party/perfetto/include/perfetto/tracing/traced_value.h"

#include "third_party/blink/public/mojom/tokens/tokens.mojom-params-data.h"
#include "third_party/blink/public/mojom/tokens/tokens.mojom-shared-message-ids.h"

#include "third_party/blink/public/mojom/tokens/tokens.mojom-blink-import-headers.h"
#include "third_party/blink/public/mojom/tokens/tokens.mojom-blink-test-utils.h"
#include "mojo/public/cpp/bindings/lib/wtf_serialization.h"


namespace blink::mojom::blink {
DocumentToken::DocumentToken()
    : value() {}

DocumentToken::DocumentToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

DocumentToken::~DocumentToken() = default;

void DocumentToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DocumentToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
LocalFrameToken::LocalFrameToken()
    : value() {}

LocalFrameToken::LocalFrameToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

LocalFrameToken::~LocalFrameToken() = default;

void LocalFrameToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool LocalFrameToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
RemoteFrameToken::RemoteFrameToken()
    : value() {}

RemoteFrameToken::RemoteFrameToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

RemoteFrameToken::~RemoteFrameToken() = default;

void RemoteFrameToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool RemoteFrameToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DedicatedWorkerToken::DedicatedWorkerToken()
    : value() {}

DedicatedWorkerToken::DedicatedWorkerToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

DedicatedWorkerToken::~DedicatedWorkerToken() = default;

void DedicatedWorkerToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DedicatedWorkerToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ServiceWorkerToken::ServiceWorkerToken()
    : value() {}

ServiceWorkerToken::ServiceWorkerToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

ServiceWorkerToken::~ServiceWorkerToken() = default;

void ServiceWorkerToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ServiceWorkerToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SharedWorkerToken::SharedWorkerToken()
    : value() {}

SharedWorkerToken::SharedWorkerToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

SharedWorkerToken::~SharedWorkerToken() = default;

void SharedWorkerToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool SharedWorkerToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
AnimationWorkletToken::AnimationWorkletToken()
    : value() {}

AnimationWorkletToken::AnimationWorkletToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

AnimationWorkletToken::~AnimationWorkletToken() = default;

void AnimationWorkletToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool AnimationWorkletToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
AudioWorkletToken::AudioWorkletToken()
    : value() {}

AudioWorkletToken::AudioWorkletToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

AudioWorkletToken::~AudioWorkletToken() = default;

void AudioWorkletToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool AudioWorkletToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
LayoutWorkletToken::LayoutWorkletToken()
    : value() {}

LayoutWorkletToken::LayoutWorkletToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

LayoutWorkletToken::~LayoutWorkletToken() = default;

void LayoutWorkletToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool LayoutWorkletToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
PaintWorkletToken::PaintWorkletToken()
    : value() {}

PaintWorkletToken::PaintWorkletToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

PaintWorkletToken::~PaintWorkletToken() = default;

void PaintWorkletToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool PaintWorkletToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SharedStorageWorkletToken::SharedStorageWorkletToken()
    : value() {}

SharedStorageWorkletToken::SharedStorageWorkletToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

SharedStorageWorkletToken::~SharedStorageWorkletToken() = default;

void SharedStorageWorkletToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool SharedStorageWorkletToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ShadowRealmToken::ShadowRealmToken()
    : value() {}

ShadowRealmToken::ShadowRealmToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

ShadowRealmToken::~ShadowRealmToken() = default;

void ShadowRealmToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ShadowRealmToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
SameDocNavigationScreenshotDestinationToken::SameDocNavigationScreenshotDestinationToken()
    : value() {}

SameDocNavigationScreenshotDestinationToken::SameDocNavigationScreenshotDestinationToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

SameDocNavigationScreenshotDestinationToken::~SameDocNavigationScreenshotDestinationToken() = default;

void SameDocNavigationScreenshotDestinationToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool SameDocNavigationScreenshotDestinationToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
V8ContextToken::V8ContextToken()
    : value() {}

V8ContextToken::V8ContextToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

V8ContextToken::~V8ContextToken() = default;

void V8ContextToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool V8ContextToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
ViewTransitionToken::ViewTransitionToken()
    : value() {}

ViewTransitionToken::ViewTransitionToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

ViewTransitionToken::~ViewTransitionToken() = default;

void ViewTransitionToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool ViewTransitionToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
WebNNContextToken::WebNNContextToken()
    : value() {}

WebNNContextToken::WebNNContextToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

WebNNContextToken::~WebNNContextToken() = default;

void WebNNContextToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool WebNNContextToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
WebNNPendingConstantToken::WebNNPendingConstantToken()
    : value() {}

WebNNPendingConstantToken::WebNNPendingConstantToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

WebNNPendingConstantToken::~WebNNPendingConstantToken() = default;

void WebNNPendingConstantToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool WebNNPendingConstantToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
WebNNTensorToken::WebNNTensorToken()
    : value() {}

WebNNTensorToken::WebNNTensorToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

WebNNTensorToken::~WebNNTensorToken() = default;

void WebNNTensorToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool WebNNTensorToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
WebNNGraphToken::WebNNGraphToken()
    : value() {}

WebNNGraphToken::WebNNGraphToken(
    const ::base::UnguessableToken& value_in)
    : value(std::move(value_in)) {}

WebNNGraphToken::~WebNNGraphToken() = default;

void WebNNGraphToken::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "value"), this->value,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool WebNNGraphToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
FrameTokenPtr
FrameToken::NewLocalFrameToken(
    const ::blink::LocalFrameToken& value) {
  return FrameTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kLocalFrameToken)>,
      std::move(value));
}

FrameTokenPtr
FrameToken::NewRemoteFrameToken(
    const ::blink::RemoteFrameToken& value) {
  return FrameTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kRemoteFrameToken)>,
      std::move(value));
}

FrameToken::FrameToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kLocalFrameToken)>,
    const ::blink::LocalFrameToken& value)
    : tag_(Tag::kLocalFrameToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kLocalFrameToken)>,
            std::move(value)) {}

FrameToken::FrameToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kRemoteFrameToken)>,
    const ::blink::RemoteFrameToken& value)
    : tag_(Tag::kRemoteFrameToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kRemoteFrameToken)>,
            std::move(value)) {}
FrameToken::~FrameToken() {
  DestroyActive();
}

void FrameToken::set_local_frame_token(const ::blink::LocalFrameToken& local_frame_token) {
  if (tag_ == Tag::kLocalFrameToken) {
    data_.local_frame_token = std::move(local_frame_token);
  } else {
    DestroyActive();
    tag_ = Tag::kLocalFrameToken;
    new (&data_.local_frame_token) ::blink::LocalFrameToken(
        std::move(local_frame_token));
  }
}

void FrameToken::set_remote_frame_token(const ::blink::RemoteFrameToken& remote_frame_token) {
  if (tag_ == Tag::kRemoteFrameToken) {
    data_.remote_frame_token = std::move(remote_frame_token);
  } else {
    DestroyActive();
    tag_ = Tag::kRemoteFrameToken;
    new (&data_.remote_frame_token) ::blink::RemoteFrameToken(
        std::move(remote_frame_token));
  }
}


FrameToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kLocalFrameToken)>,
    const ::blink::LocalFrameToken& value)
    : local_frame_token(std::move(value)) {}

FrameToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kRemoteFrameToken)>,
    const ::blink::RemoteFrameToken& value)
    : remote_frame_token(std::move(value)) {}

void FrameToken::DestroyActive() {
  switch (tag_) {

    case Tag::kLocalFrameToken:
      std::destroy_at(&data_.local_frame_token);
      break;
    case Tag::kRemoteFrameToken:
      std::destroy_at(&data_.remote_frame_token);
      break;
  }
}

bool FrameToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
WorkerTokenPtr
WorkerToken::NewDedicatedWorkerToken(
    const ::blink::DedicatedWorkerToken& value) {
  return WorkerTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
      std::move(value));
}

WorkerTokenPtr
WorkerToken::NewServiceWorkerToken(
    const ::blink::ServiceWorkerToken& value) {
  return WorkerTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kServiceWorkerToken)>,
      std::move(value));
}

WorkerTokenPtr
WorkerToken::NewSharedWorkerToken(
    const ::blink::SharedWorkerToken& value) {
  return WorkerTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSharedWorkerToken)>,
      std::move(value));
}

WorkerToken::WorkerToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
    const ::blink::DedicatedWorkerToken& value)
    : tag_(Tag::kDedicatedWorkerToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
            std::move(value)) {}

WorkerToken::WorkerToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kServiceWorkerToken)>,
    const ::blink::ServiceWorkerToken& value)
    : tag_(Tag::kServiceWorkerToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kServiceWorkerToken)>,
            std::move(value)) {}

WorkerToken::WorkerToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kSharedWorkerToken)>,
    const ::blink::SharedWorkerToken& value)
    : tag_(Tag::kSharedWorkerToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSharedWorkerToken)>,
            std::move(value)) {}
WorkerToken::~WorkerToken() {
  DestroyActive();
}

void WorkerToken::set_dedicated_worker_token(const ::blink::DedicatedWorkerToken& dedicated_worker_token) {
  if (tag_ == Tag::kDedicatedWorkerToken) {
    data_.dedicated_worker_token = std::move(dedicated_worker_token);
  } else {
    DestroyActive();
    tag_ = Tag::kDedicatedWorkerToken;
    new (&data_.dedicated_worker_token) ::blink::DedicatedWorkerToken(
        std::move(dedicated_worker_token));
  }
}

void WorkerToken::set_service_worker_token(const ::blink::ServiceWorkerToken& service_worker_token) {
  if (tag_ == Tag::kServiceWorkerToken) {
    data_.service_worker_token = std::move(service_worker_token);
  } else {
    DestroyActive();
    tag_ = Tag::kServiceWorkerToken;
    new (&data_.service_worker_token) ::blink::ServiceWorkerToken(
        std::move(service_worker_token));
  }
}

void WorkerToken::set_shared_worker_token(const ::blink::SharedWorkerToken& shared_worker_token) {
  if (tag_ == Tag::kSharedWorkerToken) {
    data_.shared_worker_token = std::move(shared_worker_token);
  } else {
    DestroyActive();
    tag_ = Tag::kSharedWorkerToken;
    new (&data_.shared_worker_token) ::blink::SharedWorkerToken(
        std::move(shared_worker_token));
  }
}


WorkerToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
    const ::blink::DedicatedWorkerToken& value)
    : dedicated_worker_token(std::move(value)) {}

WorkerToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kServiceWorkerToken)>,
    const ::blink::ServiceWorkerToken& value)
    : service_worker_token(std::move(value)) {}

WorkerToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSharedWorkerToken)>,
    const ::blink::SharedWorkerToken& value)
    : shared_worker_token(std::move(value)) {}

void WorkerToken::DestroyActive() {
  switch (tag_) {

    case Tag::kDedicatedWorkerToken:
      std::destroy_at(&data_.dedicated_worker_token);
      break;
    case Tag::kServiceWorkerToken:
      std::destroy_at(&data_.service_worker_token);
      break;
    case Tag::kSharedWorkerToken:
      std::destroy_at(&data_.shared_worker_token);
      break;
  }
}

bool WorkerToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
WorkletTokenPtr
WorkletToken::NewAnimationWorkletToken(
    const ::blink::AnimationWorkletToken& value) {
  return WorkletTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kAnimationWorkletToken)>,
      std::move(value));
}

WorkletTokenPtr
WorkletToken::NewAudioWorkletToken(
    const ::blink::AudioWorkletToken& value) {
  return WorkletTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kAudioWorkletToken)>,
      std::move(value));
}

WorkletTokenPtr
WorkletToken::NewLayoutWorkletToken(
    LayoutWorkletTokenPtr value) {
  return WorkletTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kLayoutWorkletToken)>,
      std::move(value));
}

WorkletTokenPtr
WorkletToken::NewPaintWorkletToken(
    const ::blink::PaintWorkletToken& value) {
  return WorkletTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kPaintWorkletToken)>,
      std::move(value));
}

WorkletTokenPtr
WorkletToken::NewSharedStorageWorkletToken(
    const ::blink::SharedStorageWorkletToken& value) {
  return WorkletTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSharedStorageWorkletToken)>,
      std::move(value));
}

WorkletToken::WorkletToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kAnimationWorkletToken)>,
    const ::blink::AnimationWorkletToken& value)
    : tag_(Tag::kAnimationWorkletToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kAnimationWorkletToken)>,
            std::move(value)) {}

WorkletToken::WorkletToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kAudioWorkletToken)>,
    const ::blink::AudioWorkletToken& value)
    : tag_(Tag::kAudioWorkletToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kAudioWorkletToken)>,
            std::move(value)) {}

WorkletToken::WorkletToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kLayoutWorkletToken)>,
    LayoutWorkletTokenPtr value)
    : tag_(Tag::kLayoutWorkletToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kLayoutWorkletToken)>,
            std::move(value)) {}

WorkletToken::WorkletToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kPaintWorkletToken)>,
    const ::blink::PaintWorkletToken& value)
    : tag_(Tag::kPaintWorkletToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kPaintWorkletToken)>,
            std::move(value)) {}

WorkletToken::WorkletToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kSharedStorageWorkletToken)>,
    const ::blink::SharedStorageWorkletToken& value)
    : tag_(Tag::kSharedStorageWorkletToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSharedStorageWorkletToken)>,
            std::move(value)) {}
WorkletToken::~WorkletToken() {
  DestroyActive();
}

void WorkletToken::set_animation_worklet_token(const ::blink::AnimationWorkletToken& animation_worklet_token) {
  if (tag_ == Tag::kAnimationWorkletToken) {
    data_.animation_worklet_token = std::move(animation_worklet_token);
  } else {
    DestroyActive();
    tag_ = Tag::kAnimationWorkletToken;
    new (&data_.animation_worklet_token) ::blink::AnimationWorkletToken(
        std::move(animation_worklet_token));
  }
}

void WorkletToken::set_audio_worklet_token(const ::blink::AudioWorkletToken& audio_worklet_token) {
  if (tag_ == Tag::kAudioWorkletToken) {
    data_.audio_worklet_token = std::move(audio_worklet_token);
  } else {
    DestroyActive();
    tag_ = Tag::kAudioWorkletToken;
    new (&data_.audio_worklet_token) ::blink::AudioWorkletToken(
        std::move(audio_worklet_token));
  }
}

void WorkletToken::set_layout_worklet_token(LayoutWorkletTokenPtr layout_worklet_token) {
  if (tag_ == Tag::kLayoutWorkletToken) {
    data_.layout_worklet_token = std::move(layout_worklet_token);
  } else {
    DestroyActive();
    tag_ = Tag::kLayoutWorkletToken;
    new (&data_.layout_worklet_token) LayoutWorkletTokenPtr(
        std::move(layout_worklet_token));
  }
}

void WorkletToken::set_paint_worklet_token(const ::blink::PaintWorkletToken& paint_worklet_token) {
  if (tag_ == Tag::kPaintWorkletToken) {
    data_.paint_worklet_token = std::move(paint_worklet_token);
  } else {
    DestroyActive();
    tag_ = Tag::kPaintWorkletToken;
    new (&data_.paint_worklet_token) ::blink::PaintWorkletToken(
        std::move(paint_worklet_token));
  }
}

void WorkletToken::set_shared_storage_worklet_token(const ::blink::SharedStorageWorkletToken& shared_storage_worklet_token) {
  if (tag_ == Tag::kSharedStorageWorkletToken) {
    data_.shared_storage_worklet_token = std::move(shared_storage_worklet_token);
  } else {
    DestroyActive();
    tag_ = Tag::kSharedStorageWorkletToken;
    new (&data_.shared_storage_worklet_token) ::blink::SharedStorageWorkletToken(
        std::move(shared_storage_worklet_token));
  }
}


WorkletToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kAnimationWorkletToken)>,
    const ::blink::AnimationWorkletToken& value)
    : animation_worklet_token(std::move(value)) {}

WorkletToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kAudioWorkletToken)>,
    const ::blink::AudioWorkletToken& value)
    : audio_worklet_token(std::move(value)) {}

WorkletToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kLayoutWorkletToken)>,
    LayoutWorkletTokenPtr value)
    : layout_worklet_token(std::move(value)) {}

WorkletToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kPaintWorkletToken)>,
    const ::blink::PaintWorkletToken& value)
    : paint_worklet_token(std::move(value)) {}

WorkletToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSharedStorageWorkletToken)>,
    const ::blink::SharedStorageWorkletToken& value)
    : shared_storage_worklet_token(std::move(value)) {}

void WorkletToken::DestroyActive() {
  switch (tag_) {

    case Tag::kAnimationWorkletToken:
      std::destroy_at(&data_.animation_worklet_token);
      break;
    case Tag::kAudioWorkletToken:
      std::destroy_at(&data_.audio_worklet_token);
      break;
    case Tag::kLayoutWorkletToken:
      std::destroy_at(&data_.layout_worklet_token);
      break;
    case Tag::kPaintWorkletToken:
      std::destroy_at(&data_.paint_worklet_token);
      break;
    case Tag::kSharedStorageWorkletToken:
      std::destroy_at(&data_.shared_storage_worklet_token);
      break;
  }
}

bool WorkletToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
ExecutionContextTokenPtr
ExecutionContextToken::NewLocalFrameToken(
    const ::blink::LocalFrameToken& value) {
  return ExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kLocalFrameToken)>,
      std::move(value));
}

ExecutionContextTokenPtr
ExecutionContextToken::NewDedicatedWorkerToken(
    const ::blink::DedicatedWorkerToken& value) {
  return ExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
      std::move(value));
}

ExecutionContextTokenPtr
ExecutionContextToken::NewServiceWorkerToken(
    const ::blink::ServiceWorkerToken& value) {
  return ExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kServiceWorkerToken)>,
      std::move(value));
}

ExecutionContextTokenPtr
ExecutionContextToken::NewSharedWorkerToken(
    const ::blink::SharedWorkerToken& value) {
  return ExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSharedWorkerToken)>,
      std::move(value));
}

ExecutionContextTokenPtr
ExecutionContextToken::NewAnimationWorkletToken(
    const ::blink::AnimationWorkletToken& value) {
  return ExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kAnimationWorkletToken)>,
      std::move(value));
}

ExecutionContextTokenPtr
ExecutionContextToken::NewAudioWorkletToken(
    const ::blink::AudioWorkletToken& value) {
  return ExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kAudioWorkletToken)>,
      std::move(value));
}

ExecutionContextTokenPtr
ExecutionContextToken::NewLayoutWorkletToken(
    LayoutWorkletTokenPtr value) {
  return ExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kLayoutWorkletToken)>,
      std::move(value));
}

ExecutionContextTokenPtr
ExecutionContextToken::NewPaintWorkletToken(
    const ::blink::PaintWorkletToken& value) {
  return ExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kPaintWorkletToken)>,
      std::move(value));
}

ExecutionContextTokenPtr
ExecutionContextToken::NewSharedStorageWorkletToken(
    const ::blink::SharedStorageWorkletToken& value) {
  return ExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSharedStorageWorkletToken)>,
      std::move(value));
}

ExecutionContextTokenPtr
ExecutionContextToken::NewShadowRealmToken(
    const ::blink::ShadowRealmToken& value) {
  return ExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kShadowRealmToken)>,
      std::move(value));
}

ExecutionContextToken::ExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kLocalFrameToken)>,
    const ::blink::LocalFrameToken& value)
    : tag_(Tag::kLocalFrameToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kLocalFrameToken)>,
            std::move(value)) {}

ExecutionContextToken::ExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
    const ::blink::DedicatedWorkerToken& value)
    : tag_(Tag::kDedicatedWorkerToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
            std::move(value)) {}

ExecutionContextToken::ExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kServiceWorkerToken)>,
    const ::blink::ServiceWorkerToken& value)
    : tag_(Tag::kServiceWorkerToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kServiceWorkerToken)>,
            std::move(value)) {}

ExecutionContextToken::ExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kSharedWorkerToken)>,
    const ::blink::SharedWorkerToken& value)
    : tag_(Tag::kSharedWorkerToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSharedWorkerToken)>,
            std::move(value)) {}

ExecutionContextToken::ExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kAnimationWorkletToken)>,
    const ::blink::AnimationWorkletToken& value)
    : tag_(Tag::kAnimationWorkletToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kAnimationWorkletToken)>,
            std::move(value)) {}

ExecutionContextToken::ExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kAudioWorkletToken)>,
    const ::blink::AudioWorkletToken& value)
    : tag_(Tag::kAudioWorkletToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kAudioWorkletToken)>,
            std::move(value)) {}

ExecutionContextToken::ExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kLayoutWorkletToken)>,
    LayoutWorkletTokenPtr value)
    : tag_(Tag::kLayoutWorkletToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kLayoutWorkletToken)>,
            std::move(value)) {}

ExecutionContextToken::ExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kPaintWorkletToken)>,
    const ::blink::PaintWorkletToken& value)
    : tag_(Tag::kPaintWorkletToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kPaintWorkletToken)>,
            std::move(value)) {}

ExecutionContextToken::ExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kSharedStorageWorkletToken)>,
    const ::blink::SharedStorageWorkletToken& value)
    : tag_(Tag::kSharedStorageWorkletToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSharedStorageWorkletToken)>,
            std::move(value)) {}

ExecutionContextToken::ExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kShadowRealmToken)>,
    const ::blink::ShadowRealmToken& value)
    : tag_(Tag::kShadowRealmToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kShadowRealmToken)>,
            std::move(value)) {}
ExecutionContextToken::~ExecutionContextToken() {
  DestroyActive();
}

void ExecutionContextToken::set_local_frame_token(const ::blink::LocalFrameToken& local_frame_token) {
  if (tag_ == Tag::kLocalFrameToken) {
    data_.local_frame_token = std::move(local_frame_token);
  } else {
    DestroyActive();
    tag_ = Tag::kLocalFrameToken;
    new (&data_.local_frame_token) ::blink::LocalFrameToken(
        std::move(local_frame_token));
  }
}

void ExecutionContextToken::set_dedicated_worker_token(const ::blink::DedicatedWorkerToken& dedicated_worker_token) {
  if (tag_ == Tag::kDedicatedWorkerToken) {
    data_.dedicated_worker_token = std::move(dedicated_worker_token);
  } else {
    DestroyActive();
    tag_ = Tag::kDedicatedWorkerToken;
    new (&data_.dedicated_worker_token) ::blink::DedicatedWorkerToken(
        std::move(dedicated_worker_token));
  }
}

void ExecutionContextToken::set_service_worker_token(const ::blink::ServiceWorkerToken& service_worker_token) {
  if (tag_ == Tag::kServiceWorkerToken) {
    data_.service_worker_token = std::move(service_worker_token);
  } else {
    DestroyActive();
    tag_ = Tag::kServiceWorkerToken;
    new (&data_.service_worker_token) ::blink::ServiceWorkerToken(
        std::move(service_worker_token));
  }
}

void ExecutionContextToken::set_shared_worker_token(const ::blink::SharedWorkerToken& shared_worker_token) {
  if (tag_ == Tag::kSharedWorkerToken) {
    data_.shared_worker_token = std::move(shared_worker_token);
  } else {
    DestroyActive();
    tag_ = Tag::kSharedWorkerToken;
    new (&data_.shared_worker_token) ::blink::SharedWorkerToken(
        std::move(shared_worker_token));
  }
}

void ExecutionContextToken::set_animation_worklet_token(const ::blink::AnimationWorkletToken& animation_worklet_token) {
  if (tag_ == Tag::kAnimationWorkletToken) {
    data_.animation_worklet_token = std::move(animation_worklet_token);
  } else {
    DestroyActive();
    tag_ = Tag::kAnimationWorkletToken;
    new (&data_.animation_worklet_token) ::blink::AnimationWorkletToken(
        std::move(animation_worklet_token));
  }
}

void ExecutionContextToken::set_audio_worklet_token(const ::blink::AudioWorkletToken& audio_worklet_token) {
  if (tag_ == Tag::kAudioWorkletToken) {
    data_.audio_worklet_token = std::move(audio_worklet_token);
  } else {
    DestroyActive();
    tag_ = Tag::kAudioWorkletToken;
    new (&data_.audio_worklet_token) ::blink::AudioWorkletToken(
        std::move(audio_worklet_token));
  }
}

void ExecutionContextToken::set_layout_worklet_token(LayoutWorkletTokenPtr layout_worklet_token) {
  if (tag_ == Tag::kLayoutWorkletToken) {
    data_.layout_worklet_token = std::move(layout_worklet_token);
  } else {
    DestroyActive();
    tag_ = Tag::kLayoutWorkletToken;
    new (&data_.layout_worklet_token) LayoutWorkletTokenPtr(
        std::move(layout_worklet_token));
  }
}

void ExecutionContextToken::set_paint_worklet_token(const ::blink::PaintWorkletToken& paint_worklet_token) {
  if (tag_ == Tag::kPaintWorkletToken) {
    data_.paint_worklet_token = std::move(paint_worklet_token);
  } else {
    DestroyActive();
    tag_ = Tag::kPaintWorkletToken;
    new (&data_.paint_worklet_token) ::blink::PaintWorkletToken(
        std::move(paint_worklet_token));
  }
}

void ExecutionContextToken::set_shared_storage_worklet_token(const ::blink::SharedStorageWorkletToken& shared_storage_worklet_token) {
  if (tag_ == Tag::kSharedStorageWorkletToken) {
    data_.shared_storage_worklet_token = std::move(shared_storage_worklet_token);
  } else {
    DestroyActive();
    tag_ = Tag::kSharedStorageWorkletToken;
    new (&data_.shared_storage_worklet_token) ::blink::SharedStorageWorkletToken(
        std::move(shared_storage_worklet_token));
  }
}

void ExecutionContextToken::set_shadow_realm_token(const ::blink::ShadowRealmToken& shadow_realm_token) {
  if (tag_ == Tag::kShadowRealmToken) {
    data_.shadow_realm_token = std::move(shadow_realm_token);
  } else {
    DestroyActive();
    tag_ = Tag::kShadowRealmToken;
    new (&data_.shadow_realm_token) ::blink::ShadowRealmToken(
        std::move(shadow_realm_token));
  }
}


ExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kLocalFrameToken)>,
    const ::blink::LocalFrameToken& value)
    : local_frame_token(std::move(value)) {}

ExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
    const ::blink::DedicatedWorkerToken& value)
    : dedicated_worker_token(std::move(value)) {}

ExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kServiceWorkerToken)>,
    const ::blink::ServiceWorkerToken& value)
    : service_worker_token(std::move(value)) {}

ExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSharedWorkerToken)>,
    const ::blink::SharedWorkerToken& value)
    : shared_worker_token(std::move(value)) {}

ExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kAnimationWorkletToken)>,
    const ::blink::AnimationWorkletToken& value)
    : animation_worklet_token(std::move(value)) {}

ExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kAudioWorkletToken)>,
    const ::blink::AudioWorkletToken& value)
    : audio_worklet_token(std::move(value)) {}

ExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kLayoutWorkletToken)>,
    LayoutWorkletTokenPtr value)
    : layout_worklet_token(std::move(value)) {}

ExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kPaintWorkletToken)>,
    const ::blink::PaintWorkletToken& value)
    : paint_worklet_token(std::move(value)) {}

ExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSharedStorageWorkletToken)>,
    const ::blink::SharedStorageWorkletToken& value)
    : shared_storage_worklet_token(std::move(value)) {}

ExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kShadowRealmToken)>,
    const ::blink::ShadowRealmToken& value)
    : shadow_realm_token(std::move(value)) {}

void ExecutionContextToken::DestroyActive() {
  switch (tag_) {

    case Tag::kLocalFrameToken:
      std::destroy_at(&data_.local_frame_token);
      break;
    case Tag::kDedicatedWorkerToken:
      std::destroy_at(&data_.dedicated_worker_token);
      break;
    case Tag::kServiceWorkerToken:
      std::destroy_at(&data_.service_worker_token);
      break;
    case Tag::kSharedWorkerToken:
      std::destroy_at(&data_.shared_worker_token);
      break;
    case Tag::kAnimationWorkletToken:
      std::destroy_at(&data_.animation_worklet_token);
      break;
    case Tag::kAudioWorkletToken:
      std::destroy_at(&data_.audio_worklet_token);
      break;
    case Tag::kLayoutWorkletToken:
      std::destroy_at(&data_.layout_worklet_token);
      break;
    case Tag::kPaintWorkletToken:
      std::destroy_at(&data_.paint_worklet_token);
      break;
    case Tag::kSharedStorageWorkletToken:
      std::destroy_at(&data_.shared_storage_worklet_token);
      break;
    case Tag::kShadowRealmToken:
      std::destroy_at(&data_.shadow_realm_token);
      break;
  }
}

bool ExecutionContextToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
WebGPUExecutionContextTokenPtr
WebGPUExecutionContextToken::NewDocumentToken(
    const ::blink::DocumentToken& value) {
  return WebGPUExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kDocumentToken)>,
      std::move(value));
}

WebGPUExecutionContextTokenPtr
WebGPUExecutionContextToken::NewDedicatedWorkerToken(
    const ::blink::DedicatedWorkerToken& value) {
  return WebGPUExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
      std::move(value));
}

WebGPUExecutionContextTokenPtr
WebGPUExecutionContextToken::NewSharedWorkerToken(
    const ::blink::SharedWorkerToken& value) {
  return WebGPUExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kSharedWorkerToken)>,
      std::move(value));
}

WebGPUExecutionContextTokenPtr
WebGPUExecutionContextToken::NewServiceWorkerToken(
    const ::blink::ServiceWorkerToken& value) {
  return WebGPUExecutionContextTokenPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kServiceWorkerToken)>,
      std::move(value));
}

WebGPUExecutionContextToken::WebGPUExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kDocumentToken)>,
    const ::blink::DocumentToken& value)
    : tag_(Tag::kDocumentToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kDocumentToken)>,
            std::move(value)) {}

WebGPUExecutionContextToken::WebGPUExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
    const ::blink::DedicatedWorkerToken& value)
    : tag_(Tag::kDedicatedWorkerToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
            std::move(value)) {}

WebGPUExecutionContextToken::WebGPUExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kSharedWorkerToken)>,
    const ::blink::SharedWorkerToken& value)
    : tag_(Tag::kSharedWorkerToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kSharedWorkerToken)>,
            std::move(value)) {}

WebGPUExecutionContextToken::WebGPUExecutionContextToken(
    std::in_place_index_t<static_cast<size_t>(Tag::kServiceWorkerToken)>,
    const ::blink::ServiceWorkerToken& value)
    : tag_(Tag::kServiceWorkerToken),
      data_(std::in_place_index<static_cast<size_t>(Tag::kServiceWorkerToken)>,
            std::move(value)) {}
WebGPUExecutionContextToken::~WebGPUExecutionContextToken() {
  DestroyActive();
}

void WebGPUExecutionContextToken::set_document_token(const ::blink::DocumentToken& document_token) {
  if (tag_ == Tag::kDocumentToken) {
    data_.document_token = std::move(document_token);
  } else {
    DestroyActive();
    tag_ = Tag::kDocumentToken;
    new (&data_.document_token) ::blink::DocumentToken(
        std::move(document_token));
  }
}

void WebGPUExecutionContextToken::set_dedicated_worker_token(const ::blink::DedicatedWorkerToken& dedicated_worker_token) {
  if (tag_ == Tag::kDedicatedWorkerToken) {
    data_.dedicated_worker_token = std::move(dedicated_worker_token);
  } else {
    DestroyActive();
    tag_ = Tag::kDedicatedWorkerToken;
    new (&data_.dedicated_worker_token) ::blink::DedicatedWorkerToken(
        std::move(dedicated_worker_token));
  }
}

void WebGPUExecutionContextToken::set_shared_worker_token(const ::blink::SharedWorkerToken& shared_worker_token) {
  if (tag_ == Tag::kSharedWorkerToken) {
    data_.shared_worker_token = std::move(shared_worker_token);
  } else {
    DestroyActive();
    tag_ = Tag::kSharedWorkerToken;
    new (&data_.shared_worker_token) ::blink::SharedWorkerToken(
        std::move(shared_worker_token));
  }
}

void WebGPUExecutionContextToken::set_service_worker_token(const ::blink::ServiceWorkerToken& service_worker_token) {
  if (tag_ == Tag::kServiceWorkerToken) {
    data_.service_worker_token = std::move(service_worker_token);
  } else {
    DestroyActive();
    tag_ = Tag::kServiceWorkerToken;
    new (&data_.service_worker_token) ::blink::ServiceWorkerToken(
        std::move(service_worker_token));
  }
}


WebGPUExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kDocumentToken)>,
    const ::blink::DocumentToken& value)
    : document_token(std::move(value)) {}

WebGPUExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kDedicatedWorkerToken)>,
    const ::blink::DedicatedWorkerToken& value)
    : dedicated_worker_token(std::move(value)) {}

WebGPUExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kSharedWorkerToken)>,
    const ::blink::SharedWorkerToken& value)
    : shared_worker_token(std::move(value)) {}

WebGPUExecutionContextToken::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kServiceWorkerToken)>,
    const ::blink::ServiceWorkerToken& value)
    : service_worker_token(std::move(value)) {}

void WebGPUExecutionContextToken::DestroyActive() {
  switch (tag_) {

    case Tag::kDocumentToken:
      std::destroy_at(&data_.document_token);
      break;
    case Tag::kDedicatedWorkerToken:
      std::destroy_at(&data_.dedicated_worker_token);
      break;
    case Tag::kSharedWorkerToken:
      std::destroy_at(&data_.shared_worker_token);
      break;
    case Tag::kServiceWorkerToken:
      std::destroy_at(&data_.service_worker_token);
      break;
  }
}

bool WebGPUExecutionContextToken::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}


}  // blink::mojom::blink


namespace mojo {


// static
bool StructTraits<::blink::mojom::blink::DocumentToken::DataView, ::blink::mojom::blink::DocumentTokenPtr>::Read(
    ::blink::mojom::blink::DocumentToken::DataView input,
    ::blink::mojom::blink::DocumentTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::DocumentTokenPtr result(::blink::mojom::blink::DocumentToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::LocalFrameToken::DataView, ::blink::mojom::blink::LocalFrameTokenPtr>::Read(
    ::blink::mojom::blink::LocalFrameToken::DataView input,
    ::blink::mojom::blink::LocalFrameTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::LocalFrameTokenPtr result(::blink::mojom::blink::LocalFrameToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::RemoteFrameToken::DataView, ::blink::mojom::blink::RemoteFrameTokenPtr>::Read(
    ::blink::mojom::blink::RemoteFrameToken::DataView input,
    ::blink::mojom::blink::RemoteFrameTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::RemoteFrameTokenPtr result(::blink::mojom::blink::RemoteFrameToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::DedicatedWorkerToken::DataView, ::blink::mojom::blink::DedicatedWorkerTokenPtr>::Read(
    ::blink::mojom::blink::DedicatedWorkerToken::DataView input,
    ::blink::mojom::blink::DedicatedWorkerTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::DedicatedWorkerTokenPtr result(::blink::mojom::blink::DedicatedWorkerToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::ServiceWorkerToken::DataView, ::blink::mojom::blink::ServiceWorkerTokenPtr>::Read(
    ::blink::mojom::blink::ServiceWorkerToken::DataView input,
    ::blink::mojom::blink::ServiceWorkerTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::ServiceWorkerTokenPtr result(::blink::mojom::blink::ServiceWorkerToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::SharedWorkerToken::DataView, ::blink::mojom::blink::SharedWorkerTokenPtr>::Read(
    ::blink::mojom::blink::SharedWorkerToken::DataView input,
    ::blink::mojom::blink::SharedWorkerTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::SharedWorkerTokenPtr result(::blink::mojom::blink::SharedWorkerToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::AnimationWorkletToken::DataView, ::blink::mojom::blink::AnimationWorkletTokenPtr>::Read(
    ::blink::mojom::blink::AnimationWorkletToken::DataView input,
    ::blink::mojom::blink::AnimationWorkletTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::AnimationWorkletTokenPtr result(::blink::mojom::blink::AnimationWorkletToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::AudioWorkletToken::DataView, ::blink::mojom::blink::AudioWorkletTokenPtr>::Read(
    ::blink::mojom::blink::AudioWorkletToken::DataView input,
    ::blink::mojom::blink::AudioWorkletTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::AudioWorkletTokenPtr result(::blink::mojom::blink::AudioWorkletToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::LayoutWorkletToken::DataView, ::blink::mojom::blink::LayoutWorkletTokenPtr>::Read(
    ::blink::mojom::blink::LayoutWorkletToken::DataView input,
    ::blink::mojom::blink::LayoutWorkletTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::LayoutWorkletTokenPtr result(::blink::mojom::blink::LayoutWorkletToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::PaintWorkletToken::DataView, ::blink::mojom::blink::PaintWorkletTokenPtr>::Read(
    ::blink::mojom::blink::PaintWorkletToken::DataView input,
    ::blink::mojom::blink::PaintWorkletTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::PaintWorkletTokenPtr result(::blink::mojom::blink::PaintWorkletToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::SharedStorageWorkletToken::DataView, ::blink::mojom::blink::SharedStorageWorkletTokenPtr>::Read(
    ::blink::mojom::blink::SharedStorageWorkletToken::DataView input,
    ::blink::mojom::blink::SharedStorageWorkletTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::SharedStorageWorkletTokenPtr result(::blink::mojom::blink::SharedStorageWorkletToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::ShadowRealmToken::DataView, ::blink::mojom::blink::ShadowRealmTokenPtr>::Read(
    ::blink::mojom::blink::ShadowRealmToken::DataView input,
    ::blink::mojom::blink::ShadowRealmTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::ShadowRealmTokenPtr result(::blink::mojom::blink::ShadowRealmToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::SameDocNavigationScreenshotDestinationToken::DataView, ::blink::mojom::blink::SameDocNavigationScreenshotDestinationTokenPtr>::Read(
    ::blink::mojom::blink::SameDocNavigationScreenshotDestinationToken::DataView input,
    ::blink::mojom::blink::SameDocNavigationScreenshotDestinationTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::SameDocNavigationScreenshotDestinationTokenPtr result(::blink::mojom::blink::SameDocNavigationScreenshotDestinationToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::V8ContextToken::DataView, ::blink::mojom::blink::V8ContextTokenPtr>::Read(
    ::blink::mojom::blink::V8ContextToken::DataView input,
    ::blink::mojom::blink::V8ContextTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::V8ContextTokenPtr result(::blink::mojom::blink::V8ContextToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::ViewTransitionToken::DataView, ::blink::mojom::blink::ViewTransitionTokenPtr>::Read(
    ::blink::mojom::blink::ViewTransitionToken::DataView input,
    ::blink::mojom::blink::ViewTransitionTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::ViewTransitionTokenPtr result(::blink::mojom::blink::ViewTransitionToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::WebNNContextToken::DataView, ::blink::mojom::blink::WebNNContextTokenPtr>::Read(
    ::blink::mojom::blink::WebNNContextToken::DataView input,
    ::blink::mojom::blink::WebNNContextTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::WebNNContextTokenPtr result(::blink::mojom::blink::WebNNContextToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::WebNNPendingConstantToken::DataView, ::blink::mojom::blink::WebNNPendingConstantTokenPtr>::Read(
    ::blink::mojom::blink::WebNNPendingConstantToken::DataView input,
    ::blink::mojom::blink::WebNNPendingConstantTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::WebNNPendingConstantTokenPtr result(::blink::mojom::blink::WebNNPendingConstantToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::WebNNTensorToken::DataView, ::blink::mojom::blink::WebNNTensorTokenPtr>::Read(
    ::blink::mojom::blink::WebNNTensorToken::DataView input,
    ::blink::mojom::blink::WebNNTensorTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::WebNNTensorTokenPtr result(::blink::mojom::blink::WebNNTensorToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::blink::mojom::blink::WebNNGraphToken::DataView, ::blink::mojom::blink::WebNNGraphTokenPtr>::Read(
    ::blink::mojom::blink::WebNNGraphToken::DataView input,
    ::blink::mojom::blink::WebNNGraphTokenPtr* output) {
  bool success = true;
  ::blink::mojom::blink::WebNNGraphTokenPtr result(::blink::mojom::blink::WebNNGraphToken::New());
  
      if (success && !input.ReadValue(&result->value))
        success = false;
  *output = std::move(result);
  return success;
}

// static
bool UnionTraits<::blink::mojom::blink::FrameToken::DataView, ::blink::mojom::blink::FrameTokenPtr>::Read(
    ::blink::mojom::blink::FrameToken::DataView input,
    ::blink::mojom::blink::FrameTokenPtr* output) {
  using UnionType = ::blink::mojom::blink::FrameToken;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kLocalFrameToken: {
      ::blink::LocalFrameToken result_local_frame_token{};
      if (!input.ReadLocalFrameToken(&result_local_frame_token))
        return false;

      *output = UnionType::NewLocalFrameToken(
          std::move(result_local_frame_token));
      break;
    }
    case Tag::kRemoteFrameToken: {
      ::blink::RemoteFrameToken result_remote_frame_token{};
      if (!input.ReadRemoteFrameToken(&result_remote_frame_token))
        return false;

      *output = UnionType::NewRemoteFrameToken(
          std::move(result_remote_frame_token));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::blink::mojom::blink::WorkerToken::DataView, ::blink::mojom::blink::WorkerTokenPtr>::Read(
    ::blink::mojom::blink::WorkerToken::DataView input,
    ::blink::mojom::blink::WorkerTokenPtr* output) {
  using UnionType = ::blink::mojom::blink::WorkerToken;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kDedicatedWorkerToken: {
      ::blink::DedicatedWorkerToken result_dedicated_worker_token{};
      if (!input.ReadDedicatedWorkerToken(&result_dedicated_worker_token))
        return false;

      *output = UnionType::NewDedicatedWorkerToken(
          std::move(result_dedicated_worker_token));
      break;
    }
    case Tag::kServiceWorkerToken: {
      ::blink::ServiceWorkerToken result_service_worker_token{};
      if (!input.ReadServiceWorkerToken(&result_service_worker_token))
        return false;

      *output = UnionType::NewServiceWorkerToken(
          std::move(result_service_worker_token));
      break;
    }
    case Tag::kSharedWorkerToken: {
      ::blink::SharedWorkerToken result_shared_worker_token{};
      if (!input.ReadSharedWorkerToken(&result_shared_worker_token))
        return false;

      *output = UnionType::NewSharedWorkerToken(
          std::move(result_shared_worker_token));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::blink::mojom::blink::WorkletToken::DataView, ::blink::mojom::blink::WorkletTokenPtr>::Read(
    ::blink::mojom::blink::WorkletToken::DataView input,
    ::blink::mojom::blink::WorkletTokenPtr* output) {
  using UnionType = ::blink::mojom::blink::WorkletToken;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kAnimationWorkletToken: {
      ::blink::AnimationWorkletToken result_animation_worklet_token{};
      if (!input.ReadAnimationWorkletToken(&result_animation_worklet_token))
        return false;

      *output = UnionType::NewAnimationWorkletToken(
          std::move(result_animation_worklet_token));
      break;
    }
    case Tag::kAudioWorkletToken: {
      ::blink::AudioWorkletToken result_audio_worklet_token{};
      if (!input.ReadAudioWorkletToken(&result_audio_worklet_token))
        return false;

      *output = UnionType::NewAudioWorkletToken(
          std::move(result_audio_worklet_token));
      break;
    }
    case Tag::kLayoutWorkletToken: {
      ::blink::mojom::blink::LayoutWorkletTokenPtr result_layout_worklet_token{};
      if (!input.ReadLayoutWorkletToken(&result_layout_worklet_token))
        return false;

      *output = UnionType::NewLayoutWorkletToken(
          std::move(result_layout_worklet_token));
      break;
    }
    case Tag::kPaintWorkletToken: {
      ::blink::PaintWorkletToken result_paint_worklet_token{};
      if (!input.ReadPaintWorkletToken(&result_paint_worklet_token))
        return false;

      *output = UnionType::NewPaintWorkletToken(
          std::move(result_paint_worklet_token));
      break;
    }
    case Tag::kSharedStorageWorkletToken: {
      ::blink::SharedStorageWorkletToken result_shared_storage_worklet_token{};
      if (!input.ReadSharedStorageWorkletToken(&result_shared_storage_worklet_token))
        return false;

      *output = UnionType::NewSharedStorageWorkletToken(
          std::move(result_shared_storage_worklet_token));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::blink::mojom::blink::ExecutionContextToken::DataView, ::blink::mojom::blink::ExecutionContextTokenPtr>::Read(
    ::blink::mojom::blink::ExecutionContextToken::DataView input,
    ::blink::mojom::blink::ExecutionContextTokenPtr* output) {
  using UnionType = ::blink::mojom::blink::ExecutionContextToken;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kLocalFrameToken: {
      ::blink::LocalFrameToken result_local_frame_token{};
      if (!input.ReadLocalFrameToken(&result_local_frame_token))
        return false;

      *output = UnionType::NewLocalFrameToken(
          std::move(result_local_frame_token));
      break;
    }
    case Tag::kDedicatedWorkerToken: {
      ::blink::DedicatedWorkerToken result_dedicated_worker_token{};
      if (!input.ReadDedicatedWorkerToken(&result_dedicated_worker_token))
        return false;

      *output = UnionType::NewDedicatedWorkerToken(
          std::move(result_dedicated_worker_token));
      break;
    }
    case Tag::kServiceWorkerToken: {
      ::blink::ServiceWorkerToken result_service_worker_token{};
      if (!input.ReadServiceWorkerToken(&result_service_worker_token))
        return false;

      *output = UnionType::NewServiceWorkerToken(
          std::move(result_service_worker_token));
      break;
    }
    case Tag::kSharedWorkerToken: {
      ::blink::SharedWorkerToken result_shared_worker_token{};
      if (!input.ReadSharedWorkerToken(&result_shared_worker_token))
        return false;

      *output = UnionType::NewSharedWorkerToken(
          std::move(result_shared_worker_token));
      break;
    }
    case Tag::kAnimationWorkletToken: {
      ::blink::AnimationWorkletToken result_animation_worklet_token{};
      if (!input.ReadAnimationWorkletToken(&result_animation_worklet_token))
        return false;

      *output = UnionType::NewAnimationWorkletToken(
          std::move(result_animation_worklet_token));
      break;
    }
    case Tag::kAudioWorkletToken: {
      ::blink::AudioWorkletToken result_audio_worklet_token{};
      if (!input.ReadAudioWorkletToken(&result_audio_worklet_token))
        return false;

      *output = UnionType::NewAudioWorkletToken(
          std::move(result_audio_worklet_token));
      break;
    }
    case Tag::kLayoutWorkletToken: {
      ::blink::mojom::blink::LayoutWorkletTokenPtr result_layout_worklet_token{};
      if (!input.ReadLayoutWorkletToken(&result_layout_worklet_token))
        return false;

      *output = UnionType::NewLayoutWorkletToken(
          std::move(result_layout_worklet_token));
      break;
    }
    case Tag::kPaintWorkletToken: {
      ::blink::PaintWorkletToken result_paint_worklet_token{};
      if (!input.ReadPaintWorkletToken(&result_paint_worklet_token))
        return false;

      *output = UnionType::NewPaintWorkletToken(
          std::move(result_paint_worklet_token));
      break;
    }
    case Tag::kSharedStorageWorkletToken: {
      ::blink::SharedStorageWorkletToken result_shared_storage_worklet_token{};
      if (!input.ReadSharedStorageWorkletToken(&result_shared_storage_worklet_token))
        return false;

      *output = UnionType::NewSharedStorageWorkletToken(
          std::move(result_shared_storage_worklet_token));
      break;
    }
    case Tag::kShadowRealmToken: {
      ::blink::ShadowRealmToken result_shadow_realm_token{};
      if (!input.ReadShadowRealmToken(&result_shadow_realm_token))
        return false;

      *output = UnionType::NewShadowRealmToken(
          std::move(result_shadow_realm_token));
      break;
    }
    default:

      return false;
  }
  return true;
}

// static
bool UnionTraits<::blink::mojom::blink::WebGPUExecutionContextToken::DataView, ::blink::mojom::blink::WebGPUExecutionContextTokenPtr>::Read(
    ::blink::mojom::blink::WebGPUExecutionContextToken::DataView input,
    ::blink::mojom::blink::WebGPUExecutionContextTokenPtr* output) {
  using UnionType = ::blink::mojom::blink::WebGPUExecutionContextToken;
  using Tag = UnionType::Tag;

  switch (input.tag()) {
    case Tag::kDocumentToken: {
      ::blink::DocumentToken result_document_token{};
      if (!input.ReadDocumentToken(&result_document_token))
        return false;

      *output = UnionType::NewDocumentToken(
          std::move(result_document_token));
      break;
    }
    case Tag::kDedicatedWorkerToken: {
      ::blink::DedicatedWorkerToken result_dedicated_worker_token{};
      if (!input.ReadDedicatedWorkerToken(&result_dedicated_worker_token))
        return false;

      *output = UnionType::NewDedicatedWorkerToken(
          std::move(result_dedicated_worker_token));
      break;
    }
    case Tag::kSharedWorkerToken: {
      ::blink::SharedWorkerToken result_shared_worker_token{};
      if (!input.ReadSharedWorkerToken(&result_shared_worker_token))
        return false;

      *output = UnionType::NewSharedWorkerToken(
          std::move(result_shared_worker_token));
      break;
    }
    case Tag::kServiceWorkerToken: {
      ::blink::ServiceWorkerToken result_service_worker_token{};
      if (!input.ReadServiceWorkerToken(&result_service_worker_token))
        return false;

      *output = UnionType::NewServiceWorkerToken(
          std::move(result_service_worker_token));
      break;
    }
    default:

      return false;
  }
  return true;
}

}  // namespace mojo


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


namespace blink::mojom::blink {




}  // blink::mojom::blink


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