// services/network/public/mojom/device_bound_sessions.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/network/public/mojom/device_bound_sessions.mojom-blink.h"
#include <math.h>
#include <stdint.h>
#include <utility>
#include "base/debug/alias.h"
#include "base/notreached.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/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.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/network/public/mojom/device_bound_sessions.mojom-params-data.h"
#include "services/network/public/mojom/device_bound_sessions.mojom-shared-message-ids.h"

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


namespace network::mojom::blink {
DeviceBoundSessionKey::DeviceBoundSessionKey()
    : site(),
      id() {}

DeviceBoundSessionKey::DeviceBoundSessionKey(
    const ::blink::BlinkSchemefulSite& site_in,
    const ::blink::String& id_in)
    : site(std::move(site_in)),
      id(std::move(id_in)) {}

DeviceBoundSessionKey::~DeviceBoundSessionKey() = default;

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

bool DeviceBoundSessionKey::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionAccess::DeviceBoundSessionAccess()
    : access_type(),
      session_key(),
      cookies() {}

DeviceBoundSessionAccess::DeviceBoundSessionAccess(
    DeviceBoundSessionAccessType access_type_in,
    DeviceBoundSessionKeyPtr session_key_in,
    ::blink::Vector<::blink::String> cookies_in)
    : access_type(std::move(access_type_in)),
      session_key(std::move(session_key_in)),
      cookies(std::move(cookies_in)) {}

DeviceBoundSessionAccess::~DeviceBoundSessionAccess() = default;

void DeviceBoundSessionAccess::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "access_type"), this->access_type,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionAccessType>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "session_key"), this->session_key,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionKeyPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "cookies"), this->cookies,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::Vector<::blink::String>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DeviceBoundSessionAccess::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionWithUsage::DeviceBoundSessionWithUsage()
    : session_key(),
      usage() {}

DeviceBoundSessionWithUsage::DeviceBoundSessionWithUsage(
    DeviceBoundSessionKeyPtr session_key_in,
    DeviceBoundSessionUsage usage_in)
    : session_key(std::move(session_key_in)),
      usage(std::move(usage_in)) {}

DeviceBoundSessionWithUsage::~DeviceBoundSessionWithUsage() = default;

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

bool DeviceBoundSessionWithUsage::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionScopeSpecification::DeviceBoundSessionScopeSpecification()
    : type(),
      domain(),
      path() {}

DeviceBoundSessionScopeSpecification::DeviceBoundSessionScopeSpecification(
    DeviceBoundSessionScopeSpecificationType type_in,
    const ::blink::String& domain_in,
    const ::blink::String& path_in)
    : type(std::move(type_in)),
      domain(std::move(domain_in)),
      path(std::move(path_in)) {}

DeviceBoundSessionScopeSpecification::~DeviceBoundSessionScopeSpecification() = default;
size_t DeviceBoundSessionScopeSpecification::Hash(size_t seed) const {
  seed = mojo::internal::WTFHash(seed, this->type);
  seed = mojo::internal::WTFHash(seed, this->domain);
  seed = mojo::internal::WTFHash(seed, this->path);
  return seed;
}

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

bool DeviceBoundSessionScopeSpecification::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionScope::DeviceBoundSessionScope()
    : include_site(),
      specifications(),
      origin() {}

DeviceBoundSessionScope::DeviceBoundSessionScope(
    bool include_site_in,
    ::blink::Vector<DeviceBoundSessionScopeSpecificationPtr> specifications_in,
    const ::blink::String& origin_in)
    : include_site(std::move(include_site_in)),
      specifications(std::move(specifications_in)),
      origin(std::move(origin_in)) {}

DeviceBoundSessionScope::~DeviceBoundSessionScope() = default;

void DeviceBoundSessionScope::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "include_site"), this->include_site,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "specifications"), this->specifications,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::blink::Vector<DeviceBoundSessionScopeSpecificationPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "origin"), this->origin,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::String&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DeviceBoundSessionScope::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionCredential::DeviceBoundSessionCredential()
    : name(),
      attributes() {}

DeviceBoundSessionCredential::DeviceBoundSessionCredential(
    const ::blink::String& name_in,
    const ::blink::String& attributes_in)
    : name(std::move(name_in)),
      attributes(std::move(attributes_in)) {}

DeviceBoundSessionCredential::~DeviceBoundSessionCredential() = default;
size_t DeviceBoundSessionCredential::Hash(size_t seed) const {
  seed = mojo::internal::WTFHash(seed, this->name);
  seed = mojo::internal::WTFHash(seed, this->attributes);
  return seed;
}

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

bool DeviceBoundSessionCredential::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionParams::DeviceBoundSessionParams()
    : session_id(),
      fetcher_url(),
      refresh_url(),
      scope(),
      credentials(),
      allowed_refresh_initiators() {}

DeviceBoundSessionParams::DeviceBoundSessionParams(
    const ::blink::String& session_id_in,
    const ::blink::KURL& fetcher_url_in,
    const ::blink::String& refresh_url_in,
    DeviceBoundSessionScopePtr scope_in,
    ::blink::Vector<DeviceBoundSessionCredentialPtr> credentials_in,
    ::blink::Vector<::blink::String> allowed_refresh_initiators_in)
    : session_id(std::move(session_id_in)),
      fetcher_url(std::move(fetcher_url_in)),
      refresh_url(std::move(refresh_url_in)),
      scope(std::move(scope_in)),
      credentials(std::move(credentials_in)),
      allowed_refresh_initiators(std::move(allowed_refresh_initiators_in)) {}

DeviceBoundSessionParams::~DeviceBoundSessionParams() = default;

void DeviceBoundSessionParams::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "session_id"), this->session_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::String&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "fetcher_url"), this->fetcher_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::KURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "refresh_url"), this->refresh_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::String&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "scope"), this->scope,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionScopePtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "credentials"), this->credentials,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::blink::Vector<DeviceBoundSessionCredentialPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "allowed_refresh_initiators"), this->allowed_refresh_initiators,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::Vector<::blink::String>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DeviceBoundSessionParams::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionCookieCravingDisplay::DeviceBoundSessionCookieCravingDisplay()
    : name(),
      domain(),
      path(),
      secure(),
      http_only(),
      same_site() {}

DeviceBoundSessionCookieCravingDisplay::DeviceBoundSessionCookieCravingDisplay(
    const ::blink::String& name_in,
    const ::blink::String& domain_in,
    const ::blink::String& path_in,
    bool secure_in,
    bool http_only_in,
    ::network::mojom::blink::CookieSameSite same_site_in)
    : name(std::move(name_in)),
      domain(std::move(domain_in)),
      path(std::move(path_in)),
      secure(std::move(secure_in)),
      http_only(std::move(http_only_in)),
      same_site(std::move(same_site_in)) {}

DeviceBoundSessionCookieCravingDisplay::~DeviceBoundSessionCookieCravingDisplay() = default;
size_t DeviceBoundSessionCookieCravingDisplay::Hash(size_t seed) const {
  seed = mojo::internal::WTFHash(seed, this->name);
  seed = mojo::internal::WTFHash(seed, this->domain);
  seed = mojo::internal::WTFHash(seed, this->path);
  seed = mojo::internal::WTFHash(seed, this->secure);
  seed = mojo::internal::WTFHash(seed, this->http_only);
  seed = mojo::internal::WTFHash(seed, this->same_site);
  return seed;
}

void DeviceBoundSessionCookieCravingDisplay::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "name"), this->name,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::String&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "domain"), this->domain,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::String&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "path"), this->path,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::String&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "secure"), this->secure,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "http_only"), this->http_only,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "same_site"), this->same_site,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::network::mojom::blink::CookieSameSite>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DeviceBoundSessionCookieCravingDisplay::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionUrlRuleDisplay::DeviceBoundSessionUrlRuleDisplay()
    : rule_type(),
      host_pattern(),
      path_prefix() {}

DeviceBoundSessionUrlRuleDisplay::DeviceBoundSessionUrlRuleDisplay(
    DeviceBoundSessionInclusionResult rule_type_in,
    const ::blink::String& host_pattern_in,
    const ::blink::String& path_prefix_in)
    : rule_type(std::move(rule_type_in)),
      host_pattern(std::move(host_pattern_in)),
      path_prefix(std::move(path_prefix_in)) {}

DeviceBoundSessionUrlRuleDisplay::~DeviceBoundSessionUrlRuleDisplay() = default;
size_t DeviceBoundSessionUrlRuleDisplay::Hash(size_t seed) const {
  seed = mojo::internal::WTFHash(seed, this->rule_type);
  seed = mojo::internal::WTFHash(seed, this->host_pattern);
  seed = mojo::internal::WTFHash(seed, this->path_prefix);
  return seed;
}

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

bool DeviceBoundSessionUrlRuleDisplay::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionInclusionRulesDisplay::DeviceBoundSessionInclusionRulesDisplay()
    : origin(),
      include_site(),
      url_rules() {}

DeviceBoundSessionInclusionRulesDisplay::DeviceBoundSessionInclusionRulesDisplay(
    const ::blink::String& origin_in,
    bool include_site_in,
    ::blink::Vector<DeviceBoundSessionUrlRuleDisplayPtr> url_rules_in)
    : origin(std::move(origin_in)),
      include_site(std::move(include_site_in)),
      url_rules(std::move(url_rules_in)) {}

DeviceBoundSessionInclusionRulesDisplay::~DeviceBoundSessionInclusionRulesDisplay() = default;

void DeviceBoundSessionInclusionRulesDisplay::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "origin"), this->origin,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::String&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "include_site"), this->include_site,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "url_rules"), this->url_rules,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::blink::Vector<DeviceBoundSessionUrlRuleDisplayPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DeviceBoundSessionInclusionRulesDisplay::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionDisplay::DeviceBoundSessionDisplay()
    : key(),
      refresh_url(),
      inclusion_rules(),
      cookie_cravings(),
      expiry_date(),
      cached_challenge(),
      allowed_refresh_initiators() {}

DeviceBoundSessionDisplay::DeviceBoundSessionDisplay(
    DeviceBoundSessionKeyPtr key_in,
    const ::blink::KURL& refresh_url_in,
    DeviceBoundSessionInclusionRulesDisplayPtr inclusion_rules_in,
    ::blink::Vector<DeviceBoundSessionCookieCravingDisplayPtr> cookie_cravings_in,
    ::base::Time expiry_date_in,
    const ::blink::String& cached_challenge_in,
    ::blink::Vector<::blink::String> allowed_refresh_initiators_in)
    : key(std::move(key_in)),
      refresh_url(std::move(refresh_url_in)),
      inclusion_rules(std::move(inclusion_rules_in)),
      cookie_cravings(std::move(cookie_cravings_in)),
      expiry_date(std::move(expiry_date_in)),
      cached_challenge(std::move(cached_challenge_in)),
      allowed_refresh_initiators(std::move(allowed_refresh_initiators_in)) {}

DeviceBoundSessionDisplay::~DeviceBoundSessionDisplay() = default;

void DeviceBoundSessionDisplay::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "key"), this->key,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionKeyPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "refresh_url"), this->refresh_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::KURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "inclusion_rules"), this->inclusion_rules,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionInclusionRulesDisplayPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "cookie_cravings"), this->cookie_cravings,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::blink::Vector<DeviceBoundSessionCookieCravingDisplayPtr>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "expiry_date"), this->expiry_date,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type ::base::Time>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "cached_challenge"), this->cached_challenge,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::String&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "allowed_refresh_initiators"), this->allowed_refresh_initiators,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::Vector<::blink::String>&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DeviceBoundSessionDisplay::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequest()
    : request_url(),
      net_error(),
      response_error(),
      response_error_body() {}

DeviceBoundSessionFailedRequest::DeviceBoundSessionFailedRequest(
    const ::blink::KURL& request_url_in,
    std::optional<int32_t> net_error_in,
    std::optional<int32_t> response_error_in,
    const ::blink::String& response_error_body_in)
    : request_url(std::move(request_url_in)),
      net_error(std::move(net_error_in)),
      response_error(std::move(response_error_in)),
      response_error_body(std::move(response_error_body_in)) {}

DeviceBoundSessionFailedRequest::~DeviceBoundSessionFailedRequest() = default;

void DeviceBoundSessionFailedRequest::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "request_url"), this->request_url,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::KURL&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "net_error"), this->net_error,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<int32_t>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "response_error"), this->response_error,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<int32_t>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "response_error_body"), this->response_error_body,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::String&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DeviceBoundSessionFailedRequest::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionCreationDetails::DeviceBoundSessionCreationDetails()
    : fetch_error(),
      new_session_display(),
      failed_request() {}

DeviceBoundSessionCreationDetails::DeviceBoundSessionCreationDetails(
    DeviceBoundSessionError fetch_error_in,
    DeviceBoundSessionDisplayPtr new_session_display_in,
    DeviceBoundSessionFailedRequestPtr failed_request_in)
    : fetch_error(std::move(fetch_error_in)),
      new_session_display(std::move(new_session_display_in)),
      failed_request(std::move(failed_request_in)) {}

DeviceBoundSessionCreationDetails::~DeviceBoundSessionCreationDetails() = default;

void DeviceBoundSessionCreationDetails::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "fetch_error"), this->fetch_error,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionError>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "new_session_display"), this->new_session_display,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionDisplayPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "failed_request"), this->failed_request,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionFailedRequestPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DeviceBoundSessionCreationDetails::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionRefreshDetails::DeviceBoundSessionRefreshDetails()
    : refresh_result(),
      fetch_error(),
      new_session_display(),
      was_fully_proactive_refresh(),
      failed_request() {}

DeviceBoundSessionRefreshDetails::DeviceBoundSessionRefreshDetails(
    DeviceBoundSessionRefreshResult refresh_result_in,
    std::optional<DeviceBoundSessionError> fetch_error_in,
    DeviceBoundSessionDisplayPtr new_session_display_in,
    bool was_fully_proactive_refresh_in,
    DeviceBoundSessionFailedRequestPtr failed_request_in)
    : refresh_result(std::move(refresh_result_in)),
      fetch_error(std::move(fetch_error_in)),
      new_session_display(std::move(new_session_display_in)),
      was_fully_proactive_refresh(std::move(was_fully_proactive_refresh_in)),
      failed_request(std::move(failed_request_in)) {}

DeviceBoundSessionRefreshDetails::~DeviceBoundSessionRefreshDetails() = default;

void DeviceBoundSessionRefreshDetails::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "refresh_result"), this->refresh_result,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionRefreshResult>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "fetch_error"), this->fetch_error,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type std::optional<DeviceBoundSessionError>>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "new_session_display"), this->new_session_display,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionDisplayPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "was_fully_proactive_refresh"), this->was_fully_proactive_refresh,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "failed_request"), this->failed_request,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionFailedRequestPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DeviceBoundSessionRefreshDetails::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionTerminationDetails::DeviceBoundSessionTerminationDetails()
    : deletion_reason() {}

DeviceBoundSessionTerminationDetails::DeviceBoundSessionTerminationDetails(
    DeviceBoundSessionDeletionReason deletion_reason_in)
    : deletion_reason(std::move(deletion_reason_in)) {}

DeviceBoundSessionTerminationDetails::~DeviceBoundSessionTerminationDetails() = default;
size_t DeviceBoundSessionTerminationDetails::Hash(size_t seed) const {
  seed = mojo::internal::WTFHash(seed, this->deletion_reason);
  return seed;
}

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

bool DeviceBoundSessionTerminationDetails::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionChallengeDetails::DeviceBoundSessionChallengeDetails()
    : challenge_result(),
      challenge() {}

DeviceBoundSessionChallengeDetails::DeviceBoundSessionChallengeDetails(
    DeviceBoundSessionChallengeResult challenge_result_in,
    const ::blink::String& challenge_in)
    : challenge_result(std::move(challenge_result_in)),
      challenge(std::move(challenge_in)) {}

DeviceBoundSessionChallengeDetails::~DeviceBoundSessionChallengeDetails() = default;
size_t DeviceBoundSessionChallengeDetails::Hash(size_t seed) const {
  seed = mojo::internal::WTFHash(seed, this->challenge_result);
  seed = mojo::internal::WTFHash(seed, this->challenge);
  return seed;
}

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

bool DeviceBoundSessionChallengeDetails::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionEvent::DeviceBoundSessionEvent()
    : event_id(),
      site(),
      session_id(),
      succeeded(),
      event_type_details() {}

DeviceBoundSessionEvent::DeviceBoundSessionEvent(
    const ::base::UnguessableToken& event_id_in,
    const ::blink::BlinkSchemefulSite& site_in,
    const ::blink::String& session_id_in,
    bool succeeded_in,
    DeviceBoundSessionEventTypeDetailsPtr event_type_details_in)
    : event_id(std::move(event_id_in)),
      site(std::move(site_in)),
      session_id(std::move(session_id_in)),
      succeeded(std::move(succeeded_in)),
      event_type_details(std::move(event_type_details_in)) {}

DeviceBoundSessionEvent::~DeviceBoundSessionEvent() = default;

void DeviceBoundSessionEvent::WriteIntoTrace(
    perfetto::TracedValue traced_context) const {
  [[maybe_unused]] auto dict = std::move(traced_context).WriteDictionary();
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "event_id"), this->event_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::base::UnguessableToken&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "site"), this->site,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::BlinkSchemefulSite&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "session_id"), this->session_id,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type const ::blink::String&>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "succeeded"), this->succeeded,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type bool>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
  perfetto::WriteIntoTracedValueWithFallback(
    dict.AddItem(
      "event_type_details"), this->event_type_details,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
      "<value of type DeviceBoundSessionEventTypeDetailsPtr>"
#else
      "<value>"
#endif  // BUILDFLAG(MOJO_TRACE_ENABLED)
    );
}

bool DeviceBoundSessionEvent::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context);
}
DeviceBoundSessionEventTypeDetailsPtr
DeviceBoundSessionEventTypeDetails::NewCreation(
    DeviceBoundSessionCreationDetailsPtr value) {
  return DeviceBoundSessionEventTypeDetailsPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kCreation)>,
      std::move(value));
}

DeviceBoundSessionEventTypeDetailsPtr
DeviceBoundSessionEventTypeDetails::NewRefresh(
    DeviceBoundSessionRefreshDetailsPtr value) {
  return DeviceBoundSessionEventTypeDetailsPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kRefresh)>,
      std::move(value));
}

DeviceBoundSessionEventTypeDetailsPtr
DeviceBoundSessionEventTypeDetails::NewTermination(
    DeviceBoundSessionTerminationDetailsPtr value) {
  return DeviceBoundSessionEventTypeDetailsPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kTermination)>,
      std::move(value));
}

DeviceBoundSessionEventTypeDetailsPtr
DeviceBoundSessionEventTypeDetails::NewChallenge(
    DeviceBoundSessionChallengeDetailsPtr value) {
  return DeviceBoundSessionEventTypeDetailsPtr(
      std::in_place,
      std::in_place_index<static_cast<size_t>(Tag::kChallenge)>,
      std::move(value));
}

DeviceBoundSessionEventTypeDetails::DeviceBoundSessionEventTypeDetails(
    std::in_place_index_t<static_cast<size_t>(Tag::kCreation)>,
    DeviceBoundSessionCreationDetailsPtr value)
    : tag_(Tag::kCreation),
      data_(std::in_place_index<static_cast<size_t>(Tag::kCreation)>,
            std::move(value)) {}

DeviceBoundSessionEventTypeDetails::DeviceBoundSessionEventTypeDetails(
    std::in_place_index_t<static_cast<size_t>(Tag::kRefresh)>,
    DeviceBoundSessionRefreshDetailsPtr value)
    : tag_(Tag::kRefresh),
      data_(std::in_place_index<static_cast<size_t>(Tag::kRefresh)>,
            std::move(value)) {}

DeviceBoundSessionEventTypeDetails::DeviceBoundSessionEventTypeDetails(
    std::in_place_index_t<static_cast<size_t>(Tag::kTermination)>,
    DeviceBoundSessionTerminationDetailsPtr value)
    : tag_(Tag::kTermination),
      data_(std::in_place_index<static_cast<size_t>(Tag::kTermination)>,
            std::move(value)) {}

DeviceBoundSessionEventTypeDetails::DeviceBoundSessionEventTypeDetails(
    std::in_place_index_t<static_cast<size_t>(Tag::kChallenge)>,
    DeviceBoundSessionChallengeDetailsPtr value)
    : tag_(Tag::kChallenge),
      data_(std::in_place_index<static_cast<size_t>(Tag::kChallenge)>,
            std::move(value)) {}
DeviceBoundSessionEventTypeDetails::~DeviceBoundSessionEventTypeDetails() {
  DestroyActive();
}

void DeviceBoundSessionEventTypeDetails::set_creation(DeviceBoundSessionCreationDetailsPtr creation) {
  if (tag_ == Tag::kCreation) {
    data_.creation = std::move(creation);
  } else {
    DestroyActive();
    tag_ = Tag::kCreation;
    new (&data_.creation) DeviceBoundSessionCreationDetailsPtr(
        std::move(creation));
  }
}

void DeviceBoundSessionEventTypeDetails::set_refresh(DeviceBoundSessionRefreshDetailsPtr refresh) {
  if (tag_ == Tag::kRefresh) {
    data_.refresh = std::move(refresh);
  } else {
    DestroyActive();
    tag_ = Tag::kRefresh;
    new (&data_.refresh) DeviceBoundSessionRefreshDetailsPtr(
        std::move(refresh));
  }
}

void DeviceBoundSessionEventTypeDetails::set_termination(DeviceBoundSessionTerminationDetailsPtr termination) {
  if (tag_ == Tag::kTermination) {
    data_.termination = std::move(termination);
  } else {
    DestroyActive();
    tag_ = Tag::kTermination;
    new (&data_.termination) DeviceBoundSessionTerminationDetailsPtr(
        std::move(termination));
  }
}

void DeviceBoundSessionEventTypeDetails::set_challenge(DeviceBoundSessionChallengeDetailsPtr challenge) {
  if (tag_ == Tag::kChallenge) {
    data_.challenge = std::move(challenge);
  } else {
    DestroyActive();
    tag_ = Tag::kChallenge;
    new (&data_.challenge) DeviceBoundSessionChallengeDetailsPtr(
        std::move(challenge));
  }
}


DeviceBoundSessionEventTypeDetails::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kCreation)>,
    DeviceBoundSessionCreationDetailsPtr value)
    : creation(std::move(value)) {}

DeviceBoundSessionEventTypeDetails::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kRefresh)>,
    DeviceBoundSessionRefreshDetailsPtr value)
    : refresh(std::move(value)) {}

DeviceBoundSessionEventTypeDetails::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kTermination)>,
    DeviceBoundSessionTerminationDetailsPtr value)
    : termination(std::move(value)) {}

DeviceBoundSessionEventTypeDetails::Union_::Union_(
    std::in_place_index_t<static_cast<size_t>(Tag::kChallenge)>,
    DeviceBoundSessionChallengeDetailsPtr value)
    : challenge(std::move(value)) {}

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

    case Tag::kCreation:
      std::destroy_at(&data_.creation);
      break;
    case Tag::kRefresh:
      std::destroy_at(&data_.refresh);
      break;
    case Tag::kTermination:
      std::destroy_at(&data_.termination);
      break;
    case Tag::kChallenge:
      std::destroy_at(&data_.challenge);
      break;
  }
}

bool DeviceBoundSessionEventTypeDetails::Validate(
    const void* data,
    mojo::internal::ValidationContext* validation_context) {
  return Data_::Validate(data, validation_context, false);
}
// The declaration includes the definition on other builds.

DeviceBoundSessionManager::IPCStableHashFunction DeviceBoundSessionManager::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::DeviceBoundSessionManager>(message.name())) {
    case messages::DeviceBoundSessionManager::kGetAllSessions: {
      return &DeviceBoundSessionManager::GetAllSessions_Sym::IPCStableHash;
    }
    case messages::DeviceBoundSessionManager::kDeleteSession: {
      return &DeviceBoundSessionManager::DeleteSession_Sym::IPCStableHash;
    }
    case messages::DeviceBoundSessionManager::kDeleteAllSessions: {
      return &DeviceBoundSessionManager::DeleteAllSessions_Sym::IPCStableHash;
    }
    case messages::DeviceBoundSessionManager::kAddObserver: {
      return &DeviceBoundSessionManager::AddObserver_Sym::IPCStableHash;
    }
    case messages::DeviceBoundSessionManager::kAddEventObserver: {
      return &DeviceBoundSessionManager::AddEventObserver_Sym::IPCStableHash;
    }
    case messages::DeviceBoundSessionManager::kCreateBoundSessions: {
      return &DeviceBoundSessionManager::CreateBoundSessions_Sym::IPCStableHash;
    }
    case messages::DeviceBoundSessionManager::kPrewarmSessionsForUrl: {
      return &DeviceBoundSessionManager::PrewarmSessionsForUrl_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* DeviceBoundSessionManager::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::DeviceBoundSessionManager>(message.name())) {
      case messages::DeviceBoundSessionManager::kGetAllSessions:
            return "Receive network::mojom::DeviceBoundSessionManager::GetAllSessions";
      case messages::DeviceBoundSessionManager::kDeleteSession:
            return "Receive network::mojom::DeviceBoundSessionManager::DeleteSession";
      case messages::DeviceBoundSessionManager::kDeleteAllSessions:
            return "Receive network::mojom::DeviceBoundSessionManager::DeleteAllSessions";
      case messages::DeviceBoundSessionManager::kAddObserver:
            return "Receive network::mojom::DeviceBoundSessionManager::AddObserver";
      case messages::DeviceBoundSessionManager::kAddEventObserver:
            return "Receive network::mojom::DeviceBoundSessionManager::AddEventObserver";
      case messages::DeviceBoundSessionManager::kCreateBoundSessions:
            return "Receive network::mojom::DeviceBoundSessionManager::CreateBoundSessions";
      case messages::DeviceBoundSessionManager::kPrewarmSessionsForUrl:
            return "Receive network::mojom::DeviceBoundSessionManager::PrewarmSessionsForUrl";
    }
  } else {
    switch (static_cast<messages::DeviceBoundSessionManager>(message.name())) {
      case messages::DeviceBoundSessionManager::kGetAllSessions:
            return "Receive reply network::mojom::DeviceBoundSessionManager::GetAllSessions";
      case messages::DeviceBoundSessionManager::kDeleteSession:
            return "Receive reply network::mojom::DeviceBoundSessionManager::DeleteSession";
      case messages::DeviceBoundSessionManager::kDeleteAllSessions:
            return "Receive reply network::mojom::DeviceBoundSessionManager::DeleteAllSessions";
      case messages::DeviceBoundSessionManager::kAddObserver:
            return "Receive reply network::mojom::DeviceBoundSessionManager::AddObserver";
      case messages::DeviceBoundSessionManager::kAddEventObserver:
            return "Receive reply network::mojom::DeviceBoundSessionManager::AddEventObserver";
      case messages::DeviceBoundSessionManager::kCreateBoundSessions:
            return "Receive reply network::mojom::DeviceBoundSessionManager::CreateBoundSessions";
      case messages::DeviceBoundSessionManager::kPrewarmSessionsForUrl:
            return "Receive reply network::mojom::DeviceBoundSessionManager::PrewarmSessionsForUrl";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DeviceBoundSessionManager::GetAllSessions_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x3d7d9505;  // IPCStableHash for network::mojom::DeviceBoundSessionManager::GetAllSessions
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t DeviceBoundSessionManager::DeleteSession_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x60cb2fca;  // IPCStableHash for network::mojom::DeviceBoundSessionManager::DeleteSession
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t DeviceBoundSessionManager::DeleteAllSessions_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xd3a61cf4;  // IPCStableHash for network::mojom::DeviceBoundSessionManager::DeleteAllSessions
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t DeviceBoundSessionManager::AddObserver_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x3896b2b9;  // IPCStableHash for network::mojom::DeviceBoundSessionManager::AddObserver
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t DeviceBoundSessionManager::AddEventObserver_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xd47eff98;  // IPCStableHash for network::mojom::DeviceBoundSessionManager::AddEventObserver
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t DeviceBoundSessionManager::CreateBoundSessions_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x98a0546b;  // IPCStableHash for network::mojom::DeviceBoundSessionManager::CreateBoundSessions
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t DeviceBoundSessionManager::PrewarmSessionsForUrl_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x19d92fb2;  // IPCStableHash for network::mojom::DeviceBoundSessionManager::PrewarmSessionsForUrl
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

class DeviceBoundSessionManager_GetAllSessions_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  DeviceBoundSessionManager_GetAllSessions_ForwardToCallback(
      DeviceBoundSessionManager::GetAllSessionsCallback callback
      ) : callback_(std::move(callback)) {
  }

  DeviceBoundSessionManager_GetAllSessions_ForwardToCallback(const DeviceBoundSessionManager_GetAllSessions_ForwardToCallback&) = delete;
  DeviceBoundSessionManager_GetAllSessions_ForwardToCallback& operator=(const DeviceBoundSessionManager_GetAllSessions_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  DeviceBoundSessionManager::GetAllSessionsCallback callback_;
};

class DeviceBoundSessionManager_DeleteAllSessions_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  DeviceBoundSessionManager_DeleteAllSessions_ForwardToCallback(
      DeviceBoundSessionManager::DeleteAllSessionsCallback callback
      ) : callback_(std::move(callback)) {
  }

  DeviceBoundSessionManager_DeleteAllSessions_ForwardToCallback(const DeviceBoundSessionManager_DeleteAllSessions_ForwardToCallback&) = delete;
  DeviceBoundSessionManager_DeleteAllSessions_ForwardToCallback& operator=(const DeviceBoundSessionManager_DeleteAllSessions_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  DeviceBoundSessionManager::DeleteAllSessionsCallback callback_;
};

class DeviceBoundSessionManager_CreateBoundSessions_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  DeviceBoundSessionManager_CreateBoundSessions_ForwardToCallback(
      DeviceBoundSessionManager::CreateBoundSessionsCallback callback
      ) : callback_(std::move(callback)) {
  }

  DeviceBoundSessionManager_CreateBoundSessions_ForwardToCallback(const DeviceBoundSessionManager_CreateBoundSessions_ForwardToCallback&) = delete;
  DeviceBoundSessionManager_CreateBoundSessions_ForwardToCallback& operator=(const DeviceBoundSessionManager_CreateBoundSessions_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  DeviceBoundSessionManager::CreateBoundSessionsCallback callback_;
};

class DeviceBoundSessionManager_PrewarmSessionsForUrl_ForwardToCallback
    : public mojo::MessageReceiver {
 public:
  DeviceBoundSessionManager_PrewarmSessionsForUrl_ForwardToCallback(
      DeviceBoundSessionManager::PrewarmSessionsForUrlCallback callback
      ) : callback_(std::move(callback)) {
  }

  DeviceBoundSessionManager_PrewarmSessionsForUrl_ForwardToCallback(const DeviceBoundSessionManager_PrewarmSessionsForUrl_ForwardToCallback&) = delete;
  DeviceBoundSessionManager_PrewarmSessionsForUrl_ForwardToCallback& operator=(const DeviceBoundSessionManager_PrewarmSessionsForUrl_ForwardToCallback&) = delete;

  bool Accept(mojo::Message* message) override;
 private:
  DeviceBoundSessionManager::PrewarmSessionsForUrlCallback callback_;
};

DeviceBoundSessionManagerProxy::DeviceBoundSessionManagerProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void DeviceBoundSessionManagerProxy::GetAllSessions(
    GetAllSessionsCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send network::mojom::DeviceBoundSessionManager::GetAllSessions");
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kGetAllSessions), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_GetAllSessions_Params_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("GetAllSessions");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new DeviceBoundSessionManager_GetAllSessions_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void DeviceBoundSessionManagerProxy::DeleteSession(
    DeviceBoundSessionDeletionReason in_reason, DeviceBoundSessionKeyPtr in_session) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send network::mojom::DeviceBoundSessionManager::DeleteSession", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("reason"), in_reason,
                        "<value of type DeviceBoundSessionDeletionReason>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("session"), in_session,
                        "<value of type DeviceBoundSessionKeyPtr>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kDeleteSession), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_DeleteSession_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::network::mojom::DeviceBoundSessionDeletionReason>(
    in_reason,
    &params->reason);
  mojo::internal::MessageFragment<
      typename decltype(params->session)::BaseType> session_fragment(
          params.message());
  
  mojo::internal::Serialize<::network::mojom::DeviceBoundSessionKeyDataView>(
    in_session,
    session_fragment);

  params->session.Set(
      session_fragment.is_null() ? nullptr : session_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->session.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null session in DeviceBoundSessionManager.DeleteSession request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("DeleteSession");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void DeviceBoundSessionManagerProxy::DeleteAllSessions(
    DeviceBoundSessionDeletionReason in_reason, std::optional<::base::Time> in_created_after_time, std::optional<::base::Time> in_created_before_time, ::network::mojom::blink::ClearDataFilterPtr in_filter, DeleteAllSessionsCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send network::mojom::DeviceBoundSessionManager::DeleteAllSessions", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("reason"), in_reason,
                        "<value of type DeviceBoundSessionDeletionReason>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("created_after_time"), in_created_after_time,
                        "<value of type std::optional<::base::Time>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("created_before_time"), in_created_before_time,
                        "<value of type std::optional<::base::Time>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("filter"), in_filter,
                        "<value of type ::network::mojom::blink::ClearDataFilterPtr>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kDeleteAllSessions), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_DeleteAllSessions_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<::network::mojom::DeviceBoundSessionDeletionReason>(
    in_reason,
    &params->reason);
  mojo::internal::MessageFragment<
      typename decltype(params->created_after_time)::BaseType> created_after_time_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::TimeDataView>(
    in_created_after_time,
    created_after_time_fragment);

  params->created_after_time.Set(
      created_after_time_fragment.is_null() ? nullptr : created_after_time_fragment.data());
  mojo::internal::MessageFragment<
      typename decltype(params->created_before_time)::BaseType> created_before_time_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::TimeDataView>(
    in_created_before_time,
    created_before_time_fragment);

  params->created_before_time.Set(
      created_before_time_fragment.is_null() ? nullptr : created_before_time_fragment.data());
  mojo::internal::MessageFragment<
      typename decltype(params->filter)::BaseType> filter_fragment(
          params.message());
  
  mojo::internal::Serialize<::network::mojom::ClearDataFilterDataView>(
    in_filter,
    filter_fragment);

  params->filter.Set(
      filter_fragment.is_null() ? nullptr : filter_fragment.data());

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("DeleteAllSessions");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new DeviceBoundSessionManager_DeleteAllSessions_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void DeviceBoundSessionManagerProxy::AddObserver(
    const ::blink::KURL& in_url, ::mojo::PendingRemote<DeviceBoundSessionAccessObserver> in_observer) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send network::mojom::DeviceBoundSessionManager::AddObserver", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::blink::KURL&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("observer"), in_observer,
                        "<value of type ::mojo::PendingRemote<DeviceBoundSessionAccessObserver>>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kAddObserver), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_AddObserver_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

  params->url.Set(
      url_fragment.is_null() ? nullptr : url_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->url.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null url in DeviceBoundSessionManager.AddObserver request");

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::network::mojom::DeviceBoundSessionAccessObserverInterfaceBase>>(
    in_observer,
    &params->observer,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->observer)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid observer in DeviceBoundSessionManager.AddObserver request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("AddObserver");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void DeviceBoundSessionManagerProxy::AddEventObserver(
    ::mojo::PendingRemote<DeviceBoundSessionEventObserver> in_observer) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send network::mojom::DeviceBoundSessionManager::AddEventObserver", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("observer"), in_observer,
                        "<value of type ::mojo::PendingRemote<DeviceBoundSessionEventObserver>>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kAddEventObserver), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_AddEventObserver_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfacePtrDataView<::network::mojom::DeviceBoundSessionEventObserverInterfaceBase>>(
    in_observer,
    &params->observer,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->observer)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid observer in DeviceBoundSessionManager.AddEventObserver request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("AddEventObserver");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void DeviceBoundSessionManagerProxy::CreateBoundSessions(
    ::blink::Vector<DeviceBoundSessionParamsPtr> in_params, const ::blink::Vector<uint8_t>& in_wrapped_key, const ::blink::Vector<::net::CanonicalCookie>& in_cookies_to_set, ::network::mojom::blink::CookieOptionsPtr in_cookie_options, CreateBoundSessionsCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send network::mojom::DeviceBoundSessionManager::CreateBoundSessions", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("params"), in_params,
                        "<value of type ::blink::Vector<DeviceBoundSessionParamsPtr>>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("wrapped_key"), in_wrapped_key,
                        "<value of type const ::blink::Vector<uint8_t>&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("cookies_to_set"), in_cookies_to_set,
                        "<value of type const ::blink::Vector<::net::CanonicalCookie>&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("cookie_options"), in_cookie_options,
                        "<value of type ::network::mojom::blink::CookieOptionsPtr>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kCreateBoundSessions), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_CreateBoundSessions_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->params)::BaseType>
      params_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& params_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionParamsDataView>>(
    in_params,
    params_fragment,
    &params_validate_params);

  params->params.Set(
      params_fragment.is_null() ? nullptr : params_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->params.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null params in DeviceBoundSessionManager.CreateBoundSessions request");
  mojo::internal::MessageFragment<
      typename decltype(params->wrapped_key)::BaseType>
      wrapped_key_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& wrapped_key_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<uint8_t>>(
    in_wrapped_key,
    wrapped_key_fragment,
    &wrapped_key_validate_params);

  params->wrapped_key.Set(
      wrapped_key_fragment.is_null() ? nullptr : wrapped_key_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->wrapped_key.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null wrapped_key in DeviceBoundSessionManager.CreateBoundSessions request");
  mojo::internal::MessageFragment<
      typename decltype(params->cookies_to_set)::BaseType>
      cookies_to_set_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& cookies_to_set_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::CanonicalCookieDataView>>(
    in_cookies_to_set,
    cookies_to_set_fragment,
    &cookies_to_set_validate_params);

  params->cookies_to_set.Set(
      cookies_to_set_fragment.is_null() ? nullptr : cookies_to_set_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->cookies_to_set.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null cookies_to_set in DeviceBoundSessionManager.CreateBoundSessions request");
  mojo::internal::MessageFragment<
      typename decltype(params->cookie_options)::BaseType> cookie_options_fragment(
          params.message());
  
  mojo::internal::Serialize<::network::mojom::CookieOptionsDataView>(
    in_cookie_options,
    cookie_options_fragment);

  params->cookie_options.Set(
      cookie_options_fragment.is_null() ? nullptr : cookie_options_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->cookie_options.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null cookie_options in DeviceBoundSessionManager.CreateBoundSessions request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("CreateBoundSessions");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new DeviceBoundSessionManager_CreateBoundSessions_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}

void DeviceBoundSessionManagerProxy::PrewarmSessionsForUrl(
    const ::blink::KURL& in_url, PrewarmSessionsForUrlCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send network::mojom::DeviceBoundSessionManager::PrewarmSessionsForUrl", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("url"), in_url,
                        "<value of type const ::blink::KURL&>");
   });
#endif

  const bool kExpectsResponse = true;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kPrewarmSessionsForUrl), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_PrewarmSessionsForUrl_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->url)::BaseType> url_fragment(
          params.message());
  
  mojo::internal::Serialize<::url::mojom::UrlDataView>(
    in_url,
    url_fragment);

  params->url.Set(
      url_fragment.is_null() ? nullptr : url_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->url.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null url in DeviceBoundSessionManager.PrewarmSessionsForUrl request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("PrewarmSessionsForUrl");
#endif
  std::unique_ptr<mojo::MessageReceiver> responder(
      new DeviceBoundSessionManager_PrewarmSessionsForUrl_ForwardToCallback(
          std::move(callback)));
  ::mojo::internal::SendMojoMessage(*receiver_, message, std::move(responder));
}
class DeviceBoundSessionManager_GetAllSessions_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static DeviceBoundSessionManager::GetAllSessionsCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<DeviceBoundSessionManager_GetAllSessions_ProxyToResponder> proxy(
        new DeviceBoundSessionManager_GetAllSessions_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&DeviceBoundSessionManager_GetAllSessions_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~DeviceBoundSessionManager_GetAllSessions_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  DeviceBoundSessionManager_GetAllSessions_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "DeviceBoundSessionManager::GetAllSessionsCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      ::blink::Vector<DeviceBoundSessionKeyPtr> in_sessions);
};

bool DeviceBoundSessionManager_GetAllSessions_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::DeviceBoundSessionManager_GetAllSessions_ResponseParams_Data* params =
      reinterpret_cast<
          internal::DeviceBoundSessionManager_GetAllSessions_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for DeviceBoundSessionManager.0
  bool success = true;
  ::blink::Vector<DeviceBoundSessionKeyPtr> p_sessions{};
  DeviceBoundSessionManager_GetAllSessions_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadSessions(&p_sessions))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        DeviceBoundSessionManager::Name_, 0, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_sessions));
  }
  return true;
}

void DeviceBoundSessionManager_GetAllSessions_ProxyToResponder::Run(
    ::blink::Vector<DeviceBoundSessionKeyPtr> in_sessions) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply network::mojom::DeviceBoundSessionManager::GetAllSessions", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("sessions"), in_sessions,
                        "<value of type ::blink::Vector<DeviceBoundSessionKeyPtr>>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kGetAllSessions), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_GetAllSessions_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->sessions)::BaseType>
      sessions_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& sessions_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionKeyDataView>>(
    in_sessions,
    sessions_fragment,
    &sessions_validate_params);

  params->sessions.Set(
      sessions_fragment.is_null() ? nullptr : sessions_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->sessions.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null sessions in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("GetAllSessions");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class DeviceBoundSessionManager_DeleteAllSessions_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static DeviceBoundSessionManager::DeleteAllSessionsCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<DeviceBoundSessionManager_DeleteAllSessions_ProxyToResponder> proxy(
        new DeviceBoundSessionManager_DeleteAllSessions_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&DeviceBoundSessionManager_DeleteAllSessions_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~DeviceBoundSessionManager_DeleteAllSessions_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  DeviceBoundSessionManager_DeleteAllSessions_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "DeviceBoundSessionManager::DeleteAllSessionsCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      );
};

bool DeviceBoundSessionManager_DeleteAllSessions_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::DeviceBoundSessionManager_DeleteAllSessions_ResponseParams_Data* params =
      reinterpret_cast<
          internal::DeviceBoundSessionManager_DeleteAllSessions_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for DeviceBoundSessionManager.2
  bool success = true;
  DeviceBoundSessionManager_DeleteAllSessions_ResponseParamsDataView input_data_view(params, message);
  
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        DeviceBoundSessionManager::Name_, 2, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run();
  }
  return true;
}

void DeviceBoundSessionManager_DeleteAllSessions_ProxyToResponder::Run(
    ) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT0("mojom", "Send reply network::mojom::DeviceBoundSessionManager::DeleteAllSessions");
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kDeleteAllSessions), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_DeleteAllSessions_ResponseParams_Data> params(
          message);
  params.Allocate();

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("DeleteAllSessions");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class DeviceBoundSessionManager_CreateBoundSessions_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static DeviceBoundSessionManager::CreateBoundSessionsCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<DeviceBoundSessionManager_CreateBoundSessions_ProxyToResponder> proxy(
        new DeviceBoundSessionManager_CreateBoundSessions_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&DeviceBoundSessionManager_CreateBoundSessions_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~DeviceBoundSessionManager_CreateBoundSessions_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  DeviceBoundSessionManager_CreateBoundSessions_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "DeviceBoundSessionManager::CreateBoundSessionsCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      const ::blink::Vector<DeviceBoundSessionError>& in_session_results, ::blink::Vector<::net::CookieInclusionStatus> in_cookie_results);
};

bool DeviceBoundSessionManager_CreateBoundSessions_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::DeviceBoundSessionManager_CreateBoundSessions_ResponseParams_Data* params =
      reinterpret_cast<
          internal::DeviceBoundSessionManager_CreateBoundSessions_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for DeviceBoundSessionManager.5
  bool success = true;
  ::blink::Vector<DeviceBoundSessionError> p_session_results{};
  ::blink::Vector<::net::CookieInclusionStatus> p_cookie_results{};
  DeviceBoundSessionManager_CreateBoundSessions_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadSessionResults(&p_session_results))
    success = false;
  if (success && !input_data_view.ReadCookieResults(&p_cookie_results))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        DeviceBoundSessionManager::Name_, 5, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_session_results), 
std::move(p_cookie_results));
  }
  return true;
}

void DeviceBoundSessionManager_CreateBoundSessions_ProxyToResponder::Run(
    const ::blink::Vector<DeviceBoundSessionError>& in_session_results, ::blink::Vector<::net::CookieInclusionStatus> in_cookie_results) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply network::mojom::DeviceBoundSessionManager::CreateBoundSessions", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("session_results"), in_session_results,
                        "<value of type const ::blink::Vector<DeviceBoundSessionError>&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("cookie_results"), in_cookie_results,
                        "<value of type ::blink::Vector<::net::CookieInclusionStatus>>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kCreateBoundSessions), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_CreateBoundSessions_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->session_results)::BaseType>
      session_results_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& session_results_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::network::mojom::internal::DeviceBoundSessionError_Data::Validate>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionError>>(
    in_session_results,
    session_results_fragment,
    &session_results_validate_params);

  params->session_results.Set(
      session_results_fragment.is_null() ? nullptr : session_results_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->session_results.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null session_results in ");
  mojo::internal::MessageFragment<
      typename decltype(params->cookie_results)::BaseType>
      cookie_results_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& cookie_results_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::CookieInclusionStatusDataView>>(
    in_cookie_results,
    cookie_results_fragment,
    &cookie_results_validate_params);

  params->cookie_results.Set(
      cookie_results_fragment.is_null() ? nullptr : cookie_results_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->cookie_results.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null cookie_results in ");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("CreateBoundSessions");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}
class DeviceBoundSessionManager_PrewarmSessionsForUrl_ProxyToResponder : public ::mojo::internal::ProxyToResponder {
 public:
  static DeviceBoundSessionManager::PrewarmSessionsForUrlCallback CreateCallback(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
    std::unique_ptr<DeviceBoundSessionManager_PrewarmSessionsForUrl_ProxyToResponder> proxy(
        new DeviceBoundSessionManager_PrewarmSessionsForUrl_ProxyToResponder(
            message, std::move(responder)));
    return base::BindOnce(&DeviceBoundSessionManager_PrewarmSessionsForUrl_ProxyToResponder::Run,
                          std::move(proxy));
  }

  ~DeviceBoundSessionManager_PrewarmSessionsForUrl_ProxyToResponder() {
#if DCHECK_IS_ON()
    if (responder_) {
      // If we're being destroyed without being run, we want to ensure the
      // binding endpoint has been closed. This checks for that asynchronously.
      // We pass a bound generated callback to handle the response so that any
      // resulting DCHECK stack will have useful interface type information.
      // Instantiate a ScopedFizzleBlockShutdownTasks to allow this request to
      // fizzle if this happens after shutdown and the endpoint is bound to a
      // BLOCK_SHUTDOWN sequence.
      base::ThreadPoolInstance::ScopedFizzleBlockShutdownTasks fizzler;
      responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
    }
#endif
  }

 private:
  DeviceBoundSessionManager_PrewarmSessionsForUrl_ProxyToResponder(
      ::mojo::Message& message,
      std::unique_ptr<mojo::MessageReceiverWithStatus> responder)
      : ::mojo::internal::ProxyToResponder(message, std::move(responder)) {
  }

#if DCHECK_IS_ON()
  static void OnIsConnectedComplete(bool connected) {
    DCHECK(!connected)
        << "DeviceBoundSessionManager::PrewarmSessionsForUrlCallback was destroyed without "
        << "first either being run or its corresponding binding being closed. "
        << "It is an error to drop response callbacks which still correspond "
        << "to an open interface pipe.";
  }
#endif

  void Run(
      const ::blink::Vector<DeviceBoundSessionRefreshResult>& in_results, std::optional<::base::Time> in_earliest_next_refresh_time);
};

bool DeviceBoundSessionManager_PrewarmSessionsForUrl_ForwardToCallback::Accept(
    mojo::Message* message) {
  DCHECK(message->is_serialized());
  internal::DeviceBoundSessionManager_PrewarmSessionsForUrl_ResponseParams_Data* params =
      reinterpret_cast<
          internal::DeviceBoundSessionManager_PrewarmSessionsForUrl_ResponseParams_Data*>(
              message->mutable_payload());
  

  // Validation for DeviceBoundSessionManager.6
  bool success = true;
  ::blink::Vector<DeviceBoundSessionRefreshResult> p_results{};
  std::optional<::base::Time> p_earliest_next_refresh_time{};
  DeviceBoundSessionManager_PrewarmSessionsForUrl_ResponseParamsDataView input_data_view(params, message);
  
  if (success && !input_data_view.ReadResults(&p_results))
    success = false;
  if (success && !input_data_view.ReadEarliestNextRefreshTime(&p_earliest_next_refresh_time))
    success = false;
  if (!success) {
    ReportValidationErrorForMessage(
        message,
        mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
        DeviceBoundSessionManager::Name_, 6, true);
    return false;
  }
  if (!callback_.is_null()) {
    std::move(callback_).Run(
std::move(p_results), 
std::move(p_earliest_next_refresh_time));
  }
  return true;
}

void DeviceBoundSessionManager_PrewarmSessionsForUrl_ProxyToResponder::Run(
    const ::blink::Vector<DeviceBoundSessionRefreshResult>& in_results, std::optional<::base::Time> in_earliest_next_refresh_time) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send reply network::mojom::DeviceBoundSessionManager::PrewarmSessionsForUrl", "async_response_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("results"), in_results,
                        "<value of type const ::blink::Vector<DeviceBoundSessionRefreshResult>&>");
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("earliest_next_refresh_time"), in_earliest_next_refresh_time,
                        "<value of type std::optional<::base::Time>>");
   });
#endif

  const uint32_t kFlags = mojo::Message::kFlagIsResponse |
      ((is_sync_) ? mojo::Message::kFlagIsSync : 0) |
      ((true) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((false) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionManager::kPrewarmSessionsForUrl), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionManager_PrewarmSessionsForUrl_ResponseParams_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->results)::BaseType>
      results_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& results_validate_params =
      mojo::internal::GetArrayOfEnumsValidator<0, false, ::network::mojom::internal::DeviceBoundSessionRefreshResult_Data::Validate>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionRefreshResult>>(
    in_results,
    results_fragment,
    &results_validate_params);

  params->results.Set(
      results_fragment.is_null() ? nullptr : results_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->results.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null results in ");
  mojo::internal::MessageFragment<
      typename decltype(params->earliest_next_refresh_time)::BaseType> earliest_next_refresh_time_fragment(
          params.message());
  
  mojo::internal::Serialize<::mojo_base::mojom::TimeDataView>(
    in_earliest_next_refresh_time,
    earliest_next_refresh_time_fragment);

  params->earliest_next_refresh_time.Set(
      earliest_next_refresh_time_fragment.is_null() ? nullptr : earliest_next_refresh_time_fragment.data());

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionManager::Name_);
  message.set_method_name("PrewarmSessionsForUrl");
#endif

  message.set_request_id(request_id_);
  message.set_trace_nonce(trace_nonce_);
  ::mojo::internal::SendMojoMessage(*responder_, message);
  // SendMojoMessage() fails silently if the responder connection is closed,
  // or if the message is malformed.
  //
  // TODO(darin): If Accept() returns false due to a malformed message, that
  // may be good reason to close the connection. However, we don't have a
  // way to do that from here. We should add a way.
  responder_ = nullptr;
}

// static
bool DeviceBoundSessionManagerStubDispatch::Accept(
    DeviceBoundSessionManager* impl,
    mojo::Message* message) {
  switch (static_cast<messages::DeviceBoundSessionManager>(message->header()->name)) {
    case messages::DeviceBoundSessionManager::kGetAllSessions: {
      break;
    }
    case messages::DeviceBoundSessionManager::kDeleteSession: {
      DCHECK(message->is_serialized());
      internal::DeviceBoundSessionManager_DeleteSession_Params_Data* params =
          reinterpret_cast<internal::DeviceBoundSessionManager_DeleteSession_Params_Data*>(
              message->mutable_payload());
      

      // Validation for DeviceBoundSessionManager.1
      bool success = true;
      DeviceBoundSessionDeletionReason p_reason{};
      DeviceBoundSessionKeyPtr p_session{};
      DeviceBoundSessionManager_DeleteSession_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadReason(&p_reason))
        success = false;
      if (success && !input_data_view.ReadSession(&p_session))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionManager::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->DeleteSession(        
        std::move(p_reason), 
        std::move(p_session));
      return true;
    }
    case messages::DeviceBoundSessionManager::kDeleteAllSessions: {
      break;
    }
    case messages::DeviceBoundSessionManager::kAddObserver: {
      DCHECK(message->is_serialized());
      internal::DeviceBoundSessionManager_AddObserver_Params_Data* params =
          reinterpret_cast<internal::DeviceBoundSessionManager_AddObserver_Params_Data*>(
              message->mutable_payload());
      

      // Validation for DeviceBoundSessionManager.3
      bool success = true;
      ::blink::KURL p_url{};
      ::mojo::PendingRemote<DeviceBoundSessionAccessObserver> p_observer{};
      DeviceBoundSessionManager_AddObserver_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (success) {
        p_observer =
            input_data_view.TakeObserver<decltype(p_observer)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionManager::Name_, 3, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->AddObserver(        
        std::move(p_url), 
        std::move(p_observer));
      return true;
    }
    case messages::DeviceBoundSessionManager::kAddEventObserver: {
      DCHECK(message->is_serialized());
      internal::DeviceBoundSessionManager_AddEventObserver_Params_Data* params =
          reinterpret_cast<internal::DeviceBoundSessionManager_AddEventObserver_Params_Data*>(
              message->mutable_payload());
      

      // Validation for DeviceBoundSessionManager.4
      bool success = true;
      ::mojo::PendingRemote<DeviceBoundSessionEventObserver> p_observer{};
      DeviceBoundSessionManager_AddEventObserver_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_observer =
            input_data_view.TakeObserver<decltype(p_observer)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionManager::Name_, 4, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->AddEventObserver(        
        std::move(p_observer));
      return true;
    }
    case messages::DeviceBoundSessionManager::kCreateBoundSessions: {
      break;
    }
    case messages::DeviceBoundSessionManager::kPrewarmSessionsForUrl: {
      break;
    }
  }
  return false;
}

// static
bool DeviceBoundSessionManagerStubDispatch::AcceptWithResponder(
    DeviceBoundSessionManager* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::DeviceBoundSessionManager>(message->header()->name)) {
    case messages::DeviceBoundSessionManager::kGetAllSessions: {
      internal::DeviceBoundSessionManager_GetAllSessions_Params_Data* params =
          reinterpret_cast<
              internal::DeviceBoundSessionManager_GetAllSessions_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for DeviceBoundSessionManager.0
      bool success = true;
      DeviceBoundSessionManager_GetAllSessions_ParamsDataView input_data_view(params, message);
      
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionManager::Name_, 0, false);
        return false;
      }
      auto callback =
          DeviceBoundSessionManager_GetAllSessions_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->GetAllSessions(std::move(callback));
      return true;
    }
    case messages::DeviceBoundSessionManager::kDeleteSession: {
      break;
    }
    case messages::DeviceBoundSessionManager::kDeleteAllSessions: {
      internal::DeviceBoundSessionManager_DeleteAllSessions_Params_Data* params =
          reinterpret_cast<
              internal::DeviceBoundSessionManager_DeleteAllSessions_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for DeviceBoundSessionManager.2
      bool success = true;
      DeviceBoundSessionDeletionReason p_reason{};
      std::optional<::base::Time> p_created_after_time{};
      std::optional<::base::Time> p_created_before_time{};
      ::network::mojom::blink::ClearDataFilterPtr p_filter{};
      DeviceBoundSessionManager_DeleteAllSessions_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadReason(&p_reason))
        success = false;
      if (success && !input_data_view.ReadCreatedAfterTime(&p_created_after_time))
        success = false;
      if (success && !input_data_view.ReadCreatedBeforeTime(&p_created_before_time))
        success = false;
      if (success && !input_data_view.ReadFilter(&p_filter))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionManager::Name_, 2, false);
        return false;
      }
      auto callback =
          DeviceBoundSessionManager_DeleteAllSessions_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->DeleteAllSessions(        
        std::move(p_reason), 
        std::move(p_created_after_time), 
        std::move(p_created_before_time), 
        std::move(p_filter), std::move(callback));
      return true;
    }
    case messages::DeviceBoundSessionManager::kAddObserver: {
      break;
    }
    case messages::DeviceBoundSessionManager::kAddEventObserver: {
      break;
    }
    case messages::DeviceBoundSessionManager::kCreateBoundSessions: {
      internal::DeviceBoundSessionManager_CreateBoundSessions_Params_Data* params =
          reinterpret_cast<
              internal::DeviceBoundSessionManager_CreateBoundSessions_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for DeviceBoundSessionManager.5
      bool success = true;
      ::blink::Vector<DeviceBoundSessionParamsPtr> p_params{};
      ::blink::Vector<uint8_t> p_wrapped_key{};
      ::blink::Vector<::net::CanonicalCookie> p_cookies_to_set{};
      ::network::mojom::blink::CookieOptionsPtr p_cookie_options{};
      DeviceBoundSessionManager_CreateBoundSessions_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadParams(&p_params))
        success = false;
      if (success && !input_data_view.ReadWrappedKey(&p_wrapped_key))
        success = false;
      if (success && !input_data_view.ReadCookiesToSet(&p_cookies_to_set))
        success = false;
      if (success && !input_data_view.ReadCookieOptions(&p_cookie_options))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionManager::Name_, 5, false);
        return false;
      }
      auto callback =
          DeviceBoundSessionManager_CreateBoundSessions_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->CreateBoundSessions(        
        std::move(p_params), 
        std::move(p_wrapped_key), 
        std::move(p_cookies_to_set), 
        std::move(p_cookie_options), std::move(callback));
      return true;
    }
    case messages::DeviceBoundSessionManager::kPrewarmSessionsForUrl: {
      internal::DeviceBoundSessionManager_PrewarmSessionsForUrl_Params_Data* params =
          reinterpret_cast<
              internal::DeviceBoundSessionManager_PrewarmSessionsForUrl_Params_Data*>(
                  message->mutable_payload());
      

      // Validation for DeviceBoundSessionManager.6
      bool success = true;
      ::blink::KURL p_url{};
      DeviceBoundSessionManager_PrewarmSessionsForUrl_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadUrl(&p_url))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionManager::Name_, 6, false);
        return false;
      }
      auto callback =
          DeviceBoundSessionManager_PrewarmSessionsForUrl_ProxyToResponder::CreateCallback(
              *message, std::move(responder));
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->PrewarmSessionsForUrl(        
        std::move(p_url), std::move(callback));
      return true;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kDeviceBoundSessionManagerValidationInfo[] = {
    { &internal::DeviceBoundSessionManager_GetAllSessions_Params_Data::Validate,
     &internal::DeviceBoundSessionManager_GetAllSessions_ResponseParams_Data::Validate},
    { &internal::DeviceBoundSessionManager_DeleteSession_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::DeviceBoundSessionManager_DeleteAllSessions_Params_Data::Validate,
     &internal::DeviceBoundSessionManager_DeleteAllSessions_ResponseParams_Data::Validate},
    { &internal::DeviceBoundSessionManager_AddObserver_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::DeviceBoundSessionManager_AddEventObserver_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::DeviceBoundSessionManager_CreateBoundSessions_Params_Data::Validate,
     &internal::DeviceBoundSessionManager_CreateBoundSessions_ResponseParams_Data::Validate},
    { &internal::DeviceBoundSessionManager_PrewarmSessionsForUrl_Params_Data::Validate,
     &internal::DeviceBoundSessionManager_PrewarmSessionsForUrl_ResponseParams_Data::Validate},
};

bool DeviceBoundSessionManagerRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::network::mojom::blink::DeviceBoundSessionManager::Name_,
    kDeviceBoundSessionManagerValidationInfo);
}

bool DeviceBoundSessionManagerResponseValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateResponseGenericPacked(
    message,
    ::network::mojom::blink::DeviceBoundSessionManager::Name_,
    kDeviceBoundSessionManagerValidationInfo);
}
// The declaration includes the definition on other builds.

DeviceBoundSessionAccessObserver::IPCStableHashFunction DeviceBoundSessionAccessObserver::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::DeviceBoundSessionAccessObserver>(message.name())) {
    case messages::DeviceBoundSessionAccessObserver::kOnDeviceBoundSessionAccessed: {
      return &DeviceBoundSessionAccessObserver::OnDeviceBoundSessionAccessed_Sym::IPCStableHash;
    }
    case messages::DeviceBoundSessionAccessObserver::kClone: {
      return &DeviceBoundSessionAccessObserver::Clone_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* DeviceBoundSessionAccessObserver::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::DeviceBoundSessionAccessObserver>(message.name())) {
      case messages::DeviceBoundSessionAccessObserver::kOnDeviceBoundSessionAccessed:
            return "Receive network::mojom::DeviceBoundSessionAccessObserver::OnDeviceBoundSessionAccessed";
      case messages::DeviceBoundSessionAccessObserver::kClone:
            return "Receive network::mojom::DeviceBoundSessionAccessObserver::Clone";
    }
  } else {
    switch (static_cast<messages::DeviceBoundSessionAccessObserver>(message.name())) {
      case messages::DeviceBoundSessionAccessObserver::kOnDeviceBoundSessionAccessed:
            return "Receive reply network::mojom::DeviceBoundSessionAccessObserver::OnDeviceBoundSessionAccessed";
      case messages::DeviceBoundSessionAccessObserver::kClone:
            return "Receive reply network::mojom::DeviceBoundSessionAccessObserver::Clone";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DeviceBoundSessionAccessObserver::OnDeviceBoundSessionAccessed_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0xffb37d73;  // IPCStableHash for network::mojom::DeviceBoundSessionAccessObserver::OnDeviceBoundSessionAccessed
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t DeviceBoundSessionAccessObserver::Clone_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x84ad5d4a;  // IPCStableHash for network::mojom::DeviceBoundSessionAccessObserver::Clone
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

DeviceBoundSessionAccessObserverProxy::DeviceBoundSessionAccessObserverProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void DeviceBoundSessionAccessObserverProxy::OnDeviceBoundSessionAccessed(
    DeviceBoundSessionAccessPtr in_access) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send network::mojom::DeviceBoundSessionAccessObserver::OnDeviceBoundSessionAccessed", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("access"), in_access,
                        "<value of type DeviceBoundSessionAccessPtr>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionAccessObserver::kOnDeviceBoundSessionAccessed), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionAccessObserver_OnDeviceBoundSessionAccessed_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->access)::BaseType> access_fragment(
          params.message());
  
  mojo::internal::Serialize<::network::mojom::DeviceBoundSessionAccessDataView>(
    in_access,
    access_fragment);

  params->access.Set(
      access_fragment.is_null() ? nullptr : access_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->access.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null access in DeviceBoundSessionAccessObserver.OnDeviceBoundSessionAccessed request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionAccessObserver::Name_);
  message.set_method_name("OnDeviceBoundSessionAccessed");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void DeviceBoundSessionAccessObserverProxy::Clone(
    ::mojo::PendingReceiver<DeviceBoundSessionAccessObserver> in_observer) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send network::mojom::DeviceBoundSessionAccessObserver::Clone", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("observer"), in_observer,
                        "<value of type ::mojo::PendingReceiver<DeviceBoundSessionAccessObserver>>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionAccessObserver::kClone), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionAccessObserver_Clone_Params_Data> params(
          message);
  params.Allocate();

  
  mojo::internal::Serialize<mojo::InterfaceRequestDataView<::network::mojom::DeviceBoundSessionAccessObserverInterfaceBase>>(
    in_observer,
    &params->observer,
    &params.message());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(!mojo::internal::IsHandleOrInterfaceValid(params->observer)),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
    "invalid observer in DeviceBoundSessionAccessObserver.Clone request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionAccessObserver::Name_);
  message.set_method_name("Clone");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

// static
bool DeviceBoundSessionAccessObserverStubDispatch::Accept(
    DeviceBoundSessionAccessObserver* impl,
    mojo::Message* message) {
  switch (static_cast<messages::DeviceBoundSessionAccessObserver>(message->header()->name)) {
    case messages::DeviceBoundSessionAccessObserver::kOnDeviceBoundSessionAccessed: {
      DCHECK(message->is_serialized());
      internal::DeviceBoundSessionAccessObserver_OnDeviceBoundSessionAccessed_Params_Data* params =
          reinterpret_cast<internal::DeviceBoundSessionAccessObserver_OnDeviceBoundSessionAccessed_Params_Data*>(
              message->mutable_payload());
      

      // Validation for DeviceBoundSessionAccessObserver.0
      bool success = true;
      DeviceBoundSessionAccessPtr p_access{};
      DeviceBoundSessionAccessObserver_OnDeviceBoundSessionAccessed_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadAccess(&p_access))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionAccessObserver::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnDeviceBoundSessionAccessed(        
        std::move(p_access));
      return true;
    }
    case messages::DeviceBoundSessionAccessObserver::kClone: {
      DCHECK(message->is_serialized());
      internal::DeviceBoundSessionAccessObserver_Clone_Params_Data* params =
          reinterpret_cast<internal::DeviceBoundSessionAccessObserver_Clone_Params_Data*>(
              message->mutable_payload());
      

      // Validation for DeviceBoundSessionAccessObserver.1
      bool success = true;
      ::mojo::PendingReceiver<DeviceBoundSessionAccessObserver> p_observer{};
      DeviceBoundSessionAccessObserver_Clone_ParamsDataView input_data_view(params, message);
      
      if (success) {
        p_observer =
            input_data_view.TakeObserver<decltype(p_observer)>();
      }
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionAccessObserver::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->Clone(        
        std::move(p_observer));
      return true;
    }
  }
  return false;
}

// static
bool DeviceBoundSessionAccessObserverStubDispatch::AcceptWithResponder(
    DeviceBoundSessionAccessObserver* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::DeviceBoundSessionAccessObserver>(message->header()->name)) {
    case messages::DeviceBoundSessionAccessObserver::kOnDeviceBoundSessionAccessed: {
      break;
    }
    case messages::DeviceBoundSessionAccessObserver::kClone: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kDeviceBoundSessionAccessObserverValidationInfo[] = {
    { &internal::DeviceBoundSessionAccessObserver_OnDeviceBoundSessionAccessed_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::DeviceBoundSessionAccessObserver_Clone_Params_Data::Validate,
     nullptr /* no response */},
};

bool DeviceBoundSessionAccessObserverRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::network::mojom::blink::DeviceBoundSessionAccessObserver::Name_,
    kDeviceBoundSessionAccessObserverValidationInfo);
}

// The declaration includes the definition on other builds.

DeviceBoundSessionEventObserver::IPCStableHashFunction DeviceBoundSessionEventObserver::MessageToMethodInfo_(mojo::Message& message) {
#if !BUILDFLAG(IS_FUCHSIA)
  switch (static_cast<messages::DeviceBoundSessionEventObserver>(message.name())) {
    case messages::DeviceBoundSessionEventObserver::kOnDeviceBoundSessionEventReceived: {
      return &DeviceBoundSessionEventObserver::OnDeviceBoundSessionEventReceived_Sym::IPCStableHash;
    }
    case messages::DeviceBoundSessionEventObserver::kAddDeviceBoundSessionDisplays: {
      return &DeviceBoundSessionEventObserver::AddDeviceBoundSessionDisplays_Sym::IPCStableHash;
    }
  }
#endif  // !BUILDFLAG(IS_FUCHSIA)
  return nullptr;
}


const char* DeviceBoundSessionEventObserver::MessageToMethodName_(mojo::Message& message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (!is_response) {
    switch (static_cast<messages::DeviceBoundSessionEventObserver>(message.name())) {
      case messages::DeviceBoundSessionEventObserver::kOnDeviceBoundSessionEventReceived:
            return "Receive network::mojom::DeviceBoundSessionEventObserver::OnDeviceBoundSessionEventReceived";
      case messages::DeviceBoundSessionEventObserver::kAddDeviceBoundSessionDisplays:
            return "Receive network::mojom::DeviceBoundSessionEventObserver::AddDeviceBoundSessionDisplays";
    }
  } else {
    switch (static_cast<messages::DeviceBoundSessionEventObserver>(message.name())) {
      case messages::DeviceBoundSessionEventObserver::kOnDeviceBoundSessionEventReceived:
            return "Receive reply network::mojom::DeviceBoundSessionEventObserver::OnDeviceBoundSessionEventReceived";
      case messages::DeviceBoundSessionEventObserver::kAddDeviceBoundSessionDisplays:
            return "Receive reply network::mojom::DeviceBoundSessionEventObserver::AddDeviceBoundSessionDisplays";
    }
  }
  return "Receive unknown mojo message";
#else
  bool is_response = message.has_flag(mojo::Message::kFlagIsResponse);
  if (is_response) {
    return "Receive mojo reply";
  } else {
    return "Receive mojo message";
  }
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
}

#if !BUILDFLAG(IS_FUCHSIA)
uint32_t DeviceBoundSessionEventObserver::OnDeviceBoundSessionEventReceived_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x117fed81;  // IPCStableHash for network::mojom::DeviceBoundSessionEventObserver::OnDeviceBoundSessionEventReceived
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
uint32_t DeviceBoundSessionEventObserver::AddDeviceBoundSessionDisplays_Sym::IPCStableHash() {
  // This method's address is used for identifying the mojo method name after
  // symbolization. So each IPCStableHash should have a unique address.
  // We cannot use NO_CODE_FOLDING() here - it relies on the uniqueness of
  // __LINE__ value, which is not unique across different mojo modules.
  // The code below is very similar to NO_CODE_FOLDING, but it uses a unique
  // hash instead of __LINE__.
  static constexpr uint32_t kHash = 0x5df4a2da;  // IPCStableHash for network::mojom::DeviceBoundSessionEventObserver::AddDeviceBoundSessionDisplays
  const uint32_t hash = kHash;
  base::debug::Alias(&hash);
  return hash;
}
# endif // !BUILDFLAG(IS_FUCHSIA)

DeviceBoundSessionEventObserverProxy::DeviceBoundSessionEventObserverProxy(mojo::MessageReceiverWithResponder* receiver)
    : receiver_(receiver) {
}

void DeviceBoundSessionEventObserverProxy::OnDeviceBoundSessionEventReceived(
    DeviceBoundSessionEventPtr in_event) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send network::mojom::DeviceBoundSessionEventObserver::OnDeviceBoundSessionEventReceived", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("event"), in_event,
                        "<value of type DeviceBoundSessionEventPtr>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionEventObserver::kOnDeviceBoundSessionEventReceived), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionEventObserver_OnDeviceBoundSessionEventReceived_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->event)::BaseType> event_fragment(
          params.message());
  
  mojo::internal::Serialize<::network::mojom::DeviceBoundSessionEventDataView>(
    in_event,
    event_fragment);

  params->event.Set(
      event_fragment.is_null() ? nullptr : event_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->event.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null event in DeviceBoundSessionEventObserver.OnDeviceBoundSessionEventReceived request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionEventObserver::Name_);
  message.set_method_name("OnDeviceBoundSessionEventReceived");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

void DeviceBoundSessionEventObserverProxy::AddDeviceBoundSessionDisplays(
    ::blink::Vector<DeviceBoundSessionDisplayPtr> in_session_displays) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
  TRACE_EVENT1(
    "mojom", "Send network::mojom::DeviceBoundSessionEventObserver::AddDeviceBoundSessionDisplays", "input_parameters",
    [&](perfetto::TracedValue context){
      auto dict = std::move(context).WriteDictionary();
      perfetto::WriteIntoTracedValueWithFallback(
           dict.AddItem("session_displays"), in_session_displays,
                        "<value of type ::blink::Vector<DeviceBoundSessionDisplayPtr>>");
   });
#endif

  const bool kExpectsResponse = false;
  const bool kIsSync = false;
  const bool kAllowInterrupt = true;
  const bool is_urgent = false;

  const uint32_t kFlags =
      ((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
      ((kIsSync) ? mojo::Message::kFlagIsSync : 0) |
      ((kAllowInterrupt) ? 0 : mojo::Message::kFlagNoInterrupt) |
      ((is_urgent) ? mojo::Message::kFlagIsUrgent : 0);

  const size_t estimated_payload_size =
    0;
  mojo::Message message(
      std::to_underlying(messages::DeviceBoundSessionEventObserver::kAddDeviceBoundSessionDisplays), kFlags, estimated_payload_size);
  mojo::internal::MessageFragment<
      ::network::mojom::internal::DeviceBoundSessionEventObserver_AddDeviceBoundSessionDisplays_Params_Data> params(
          message);
  params.Allocate();
  mojo::internal::MessageFragment<
      typename decltype(params->session_displays)::BaseType>
      session_displays_fragment(params.message());
  constexpr const mojo::internal::ContainerValidateParams& session_displays_validate_params =
      mojo::internal::GetArrayValidator<0, false, nullptr>();
  
  mojo::internal::Serialize<mojo::ArrayDataView<::network::mojom::DeviceBoundSessionDisplayDataView>>(
    in_session_displays,
    session_displays_fragment,
    &session_displays_validate_params);

  params->session_displays.Set(
      session_displays_fragment.is_null() ? nullptr : session_displays_fragment.data());

  
  MOJO_INTERNAL_CHECK_SERIALIZATION(
    mojo::internal::SendValidation::kDefault,
    !(params->session_displays.is_null()),
    mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
    "null session_displays in DeviceBoundSessionEventObserver.AddDeviceBoundSessionDisplays request");

#if defined(ENABLE_IPC_FUZZER)
  message.set_interface_name(DeviceBoundSessionEventObserver::Name_);
  message.set_method_name("AddDeviceBoundSessionDisplays");
#endif
  // This return value may be ignored as false implies the Connector has
  // encountered an error, which will be visible through other means.
  ::mojo::internal::SendMojoMessage(*receiver_, message);
}

// static
bool DeviceBoundSessionEventObserverStubDispatch::Accept(
    DeviceBoundSessionEventObserver* impl,
    mojo::Message* message) {
  switch (static_cast<messages::DeviceBoundSessionEventObserver>(message->header()->name)) {
    case messages::DeviceBoundSessionEventObserver::kOnDeviceBoundSessionEventReceived: {
      DCHECK(message->is_serialized());
      internal::DeviceBoundSessionEventObserver_OnDeviceBoundSessionEventReceived_Params_Data* params =
          reinterpret_cast<internal::DeviceBoundSessionEventObserver_OnDeviceBoundSessionEventReceived_Params_Data*>(
              message->mutable_payload());
      

      // Validation for DeviceBoundSessionEventObserver.0
      bool success = true;
      DeviceBoundSessionEventPtr p_event{};
      DeviceBoundSessionEventObserver_OnDeviceBoundSessionEventReceived_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadEvent(&p_event))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionEventObserver::Name_, 0, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->OnDeviceBoundSessionEventReceived(        
        std::move(p_event));
      return true;
    }
    case messages::DeviceBoundSessionEventObserver::kAddDeviceBoundSessionDisplays: {
      DCHECK(message->is_serialized());
      internal::DeviceBoundSessionEventObserver_AddDeviceBoundSessionDisplays_Params_Data* params =
          reinterpret_cast<internal::DeviceBoundSessionEventObserver_AddDeviceBoundSessionDisplays_Params_Data*>(
              message->mutable_payload());
      

      // Validation for DeviceBoundSessionEventObserver.1
      bool success = true;
      ::blink::Vector<DeviceBoundSessionDisplayPtr> p_session_displays{};
      DeviceBoundSessionEventObserver_AddDeviceBoundSessionDisplays_ParamsDataView input_data_view(params, message);
      
      if (success && !input_data_view.ReadSessionDisplays(&p_session_displays))
        success = false;
      if (!success) {
        ReportValidationErrorForMessage(
            message,
            mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
            DeviceBoundSessionEventObserver::Name_, 1, false);
        return false;
      }
      // A null |impl| means no implementation was bound.
      DCHECK(impl);
      impl->AddDeviceBoundSessionDisplays(        
        std::move(p_session_displays));
      return true;
    }
  }
  return false;
}

// static
bool DeviceBoundSessionEventObserverStubDispatch::AcceptWithResponder(
    DeviceBoundSessionEventObserver* impl,
    mojo::Message* message,
    std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
  [[maybe_unused]] const bool message_is_sync =
      message->has_flag(mojo::Message::kFlagIsSync);
  [[maybe_unused]] const uint64_t request_id = message->request_id();
  switch (static_cast<messages::DeviceBoundSessionEventObserver>(message->header()->name)) {
    case messages::DeviceBoundSessionEventObserver::kOnDeviceBoundSessionEventReceived: {
      break;
    }
    case messages::DeviceBoundSessionEventObserver::kAddDeviceBoundSessionDisplays: {
      break;
    }
  }
  return false;
}
namespace {
}  // namespace
static const mojo::internal::GenericValidationInfo kDeviceBoundSessionEventObserverValidationInfo[] = {
    { &internal::DeviceBoundSessionEventObserver_OnDeviceBoundSessionEventReceived_Params_Data::Validate,
     nullptr /* no response */},
    { &internal::DeviceBoundSessionEventObserver_AddDeviceBoundSessionDisplays_Params_Data::Validate,
     nullptr /* no response */},
};

bool DeviceBoundSessionEventObserverRequestValidator::Accept(mojo::Message* message) {
  return mojo::internal::ValidateRequestGenericPacked(
    message,
    ::network::mojom::blink::DeviceBoundSessionEventObserver::Name_,
    kDeviceBoundSessionEventObserverValidationInfo);
}



}  // network::mojom::blink


namespace mojo {


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionKey::DataView, ::network::mojom::blink::DeviceBoundSessionKeyPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionKey::DataView input,
    ::network::mojom::blink::DeviceBoundSessionKeyPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionKeyPtr result(::network::mojom::blink::DeviceBoundSessionKey::New());
  
      if (success && !input.ReadSite(&result->site))
        success = false;
      if (success && !input.ReadId(&result->id))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionAccess::DataView, ::network::mojom::blink::DeviceBoundSessionAccessPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionAccess::DataView input,
    ::network::mojom::blink::DeviceBoundSessionAccessPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionAccessPtr result(::network::mojom::blink::DeviceBoundSessionAccess::New());
  
      if (success && !input.ReadAccessType(&result->access_type))
        success = false;
      if (success && !input.ReadSessionKey(&result->session_key))
        success = false;
      if (success && !input.ReadCookies(&result->cookies))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionWithUsage::DataView, ::network::mojom::blink::DeviceBoundSessionWithUsagePtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionWithUsage::DataView input,
    ::network::mojom::blink::DeviceBoundSessionWithUsagePtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionWithUsagePtr result(::network::mojom::blink::DeviceBoundSessionWithUsage::New());
  
      if (success && !input.ReadSessionKey(&result->session_key))
        success = false;
      if (success && !input.ReadUsage(&result->usage))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionScopeSpecification::DataView, ::network::mojom::blink::DeviceBoundSessionScopeSpecificationPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionScopeSpecification::DataView input,
    ::network::mojom::blink::DeviceBoundSessionScopeSpecificationPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionScopeSpecificationPtr result(::network::mojom::blink::DeviceBoundSessionScopeSpecification::New());
  
      if (success && !input.ReadType(&result->type))
        success = false;
      if (success && !input.ReadDomain(&result->domain))
        success = false;
      if (success && !input.ReadPath(&result->path))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionScope::DataView, ::network::mojom::blink::DeviceBoundSessionScopePtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionScope::DataView input,
    ::network::mojom::blink::DeviceBoundSessionScopePtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionScopePtr result(::network::mojom::blink::DeviceBoundSessionScope::New());
  
      if (success)
        result->include_site = input.include_site();
      if (success && !input.ReadSpecifications(&result->specifications))
        success = false;
      if (success && !input.ReadOrigin(&result->origin))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionCredential::DataView, ::network::mojom::blink::DeviceBoundSessionCredentialPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionCredential::DataView input,
    ::network::mojom::blink::DeviceBoundSessionCredentialPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionCredentialPtr result(::network::mojom::blink::DeviceBoundSessionCredential::New());
  
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success && !input.ReadAttributes(&result->attributes))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionParams::DataView, ::network::mojom::blink::DeviceBoundSessionParamsPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionParams::DataView input,
    ::network::mojom::blink::DeviceBoundSessionParamsPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionParamsPtr result(::network::mojom::blink::DeviceBoundSessionParams::New());
  
      if (success && !input.ReadSessionId(&result->session_id))
        success = false;
      if (success && !input.ReadFetcherUrl(&result->fetcher_url))
        success = false;
      if (success && !input.ReadRefreshUrl(&result->refresh_url))
        success = false;
      if (success && !input.ReadScope(&result->scope))
        success = false;
      if (success && !input.ReadCredentials(&result->credentials))
        success = false;
      if (success && !input.ReadAllowedRefreshInitiators(&result->allowed_refresh_initiators))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionCookieCravingDisplay::DataView, ::network::mojom::blink::DeviceBoundSessionCookieCravingDisplayPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionCookieCravingDisplay::DataView input,
    ::network::mojom::blink::DeviceBoundSessionCookieCravingDisplayPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionCookieCravingDisplayPtr result(::network::mojom::blink::DeviceBoundSessionCookieCravingDisplay::New());
  
      if (success && !input.ReadName(&result->name))
        success = false;
      if (success && !input.ReadDomain(&result->domain))
        success = false;
      if (success && !input.ReadPath(&result->path))
        success = false;
      if (success)
        result->secure = input.secure();
      if (success)
        result->http_only = input.http_only();
      if (success && !input.ReadSameSite(&result->same_site))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionUrlRuleDisplay::DataView, ::network::mojom::blink::DeviceBoundSessionUrlRuleDisplayPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionUrlRuleDisplay::DataView input,
    ::network::mojom::blink::DeviceBoundSessionUrlRuleDisplayPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionUrlRuleDisplayPtr result(::network::mojom::blink::DeviceBoundSessionUrlRuleDisplay::New());
  
      if (success && !input.ReadRuleType(&result->rule_type))
        success = false;
      if (success && !input.ReadHostPattern(&result->host_pattern))
        success = false;
      if (success && !input.ReadPathPrefix(&result->path_prefix))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionInclusionRulesDisplay::DataView, ::network::mojom::blink::DeviceBoundSessionInclusionRulesDisplayPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionInclusionRulesDisplay::DataView input,
    ::network::mojom::blink::DeviceBoundSessionInclusionRulesDisplayPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionInclusionRulesDisplayPtr result(::network::mojom::blink::DeviceBoundSessionInclusionRulesDisplay::New());
  
      if (success && !input.ReadOrigin(&result->origin))
        success = false;
      if (success)
        result->include_site = input.include_site();
      if (success && !input.ReadUrlRules(&result->url_rules))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionDisplay::DataView, ::network::mojom::blink::DeviceBoundSessionDisplayPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionDisplay::DataView input,
    ::network::mojom::blink::DeviceBoundSessionDisplayPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionDisplayPtr result(::network::mojom::blink::DeviceBoundSessionDisplay::New());
  
      if (success && !input.ReadKey(&result->key))
        success = false;
      if (success && !input.ReadRefreshUrl(&result->refresh_url))
        success = false;
      if (success && !input.ReadInclusionRules(&result->inclusion_rules))
        success = false;
      if (success && !input.ReadCookieCravings(&result->cookie_cravings))
        success = false;
      if (success && !input.ReadExpiryDate(&result->expiry_date))
        success = false;
      if (success && !input.ReadCachedChallenge(&result->cached_challenge))
        success = false;
      if (success && !input.ReadAllowedRefreshInitiators(&result->allowed_refresh_initiators))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionFailedRequest::DataView, ::network::mojom::blink::DeviceBoundSessionFailedRequestPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionFailedRequest::DataView input,
    ::network::mojom::blink::DeviceBoundSessionFailedRequestPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionFailedRequestPtr result(::network::mojom::blink::DeviceBoundSessionFailedRequest::New());
  
      if (success && !input.ReadRequestUrl(&result->request_url))
        success = false;
      if (success) {
        result->net_error = input.net_error();
      }
      if (success) {
        result->response_error = input.response_error();
      }
      if (success && !input.ReadResponseErrorBody(&result->response_error_body))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionCreationDetails::DataView, ::network::mojom::blink::DeviceBoundSessionCreationDetailsPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionCreationDetails::DataView input,
    ::network::mojom::blink::DeviceBoundSessionCreationDetailsPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionCreationDetailsPtr result(::network::mojom::blink::DeviceBoundSessionCreationDetails::New());
  
      if (success && !input.ReadFetchError(&result->fetch_error))
        success = false;
      if (success && !input.ReadNewSessionDisplay(&result->new_session_display))
        success = false;
      if (success && !input.ReadFailedRequest(&result->failed_request))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionRefreshDetails::DataView, ::network::mojom::blink::DeviceBoundSessionRefreshDetailsPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionRefreshDetails::DataView input,
    ::network::mojom::blink::DeviceBoundSessionRefreshDetailsPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionRefreshDetailsPtr result(::network::mojom::blink::DeviceBoundSessionRefreshDetails::New());
  
      if (success && !input.ReadRefreshResult(&result->refresh_result))
        success = false;
      if (success && !input.ReadFetchError(&result->fetch_error)) {
        success = false;
      }
      if (success && !input.ReadNewSessionDisplay(&result->new_session_display))
        success = false;
      if (success)
        result->was_fully_proactive_refresh = input.was_fully_proactive_refresh();
      if (success && !input.ReadFailedRequest(&result->failed_request))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionTerminationDetails::DataView, ::network::mojom::blink::DeviceBoundSessionTerminationDetailsPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionTerminationDetails::DataView input,
    ::network::mojom::blink::DeviceBoundSessionTerminationDetailsPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionTerminationDetailsPtr result(::network::mojom::blink::DeviceBoundSessionTerminationDetails::New());
  
      if (success && !input.ReadDeletionReason(&result->deletion_reason))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionChallengeDetails::DataView, ::network::mojom::blink::DeviceBoundSessionChallengeDetailsPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionChallengeDetails::DataView input,
    ::network::mojom::blink::DeviceBoundSessionChallengeDetailsPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionChallengeDetailsPtr result(::network::mojom::blink::DeviceBoundSessionChallengeDetails::New());
  
      if (success && !input.ReadChallengeResult(&result->challenge_result))
        success = false;
      if (success && !input.ReadChallenge(&result->challenge))
        success = false;
  *output = std::move(result);
  return success;
}


// static
bool StructTraits<::network::mojom::blink::DeviceBoundSessionEvent::DataView, ::network::mojom::blink::DeviceBoundSessionEventPtr>::Read(
    ::network::mojom::blink::DeviceBoundSessionEvent::DataView input,
    ::network::mojom::blink::DeviceBoundSessionEventPtr* output) {
  bool success = true;
  ::network::mojom::blink::DeviceBoundSessionEventPtr result(::network::mojom::blink::DeviceBoundSessionEvent::New());
  
      if (success && !input.ReadEventId(&result->event_id))
        success = false;
      if (success && !input.ReadSite(&result->site))
        success = false;
      if (success && !input.ReadSessionId(&result->session_id))
        success = false;
      if (success)
        result->succeeded = input.succeeded();
      if (success && !input.ReadEventTypeDetails(&result->event_type_details))
        success = false;
  *output = std::move(result);
  return success;
}

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

  switch (input.tag()) {
    case Tag::kCreation: {
      ::network::mojom::blink::DeviceBoundSessionCreationDetailsPtr result_creation{};
      if (!input.ReadCreation(&result_creation))
        return false;

      *output = UnionType::NewCreation(
          std::move(result_creation));
      break;
    }
    case Tag::kRefresh: {
      ::network::mojom::blink::DeviceBoundSessionRefreshDetailsPtr result_refresh{};
      if (!input.ReadRefresh(&result_refresh))
        return false;

      *output = UnionType::NewRefresh(
          std::move(result_refresh));
      break;
    }
    case Tag::kTermination: {
      ::network::mojom::blink::DeviceBoundSessionTerminationDetailsPtr result_termination{};
      if (!input.ReadTermination(&result_termination))
        return false;

      *output = UnionType::NewTermination(
          std::move(result_termination));
      break;
    }
    case Tag::kChallenge: {
      ::network::mojom::blink::DeviceBoundSessionChallengeDetailsPtr result_challenge{};
      if (!input.ReadChallenge(&result_challenge))
        return false;

      *output = UnionType::NewChallenge(
          std::move(result_challenge));
      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 network::mojom::blink {


void DeviceBoundSessionManagerInterceptorForTesting::GetAllSessions(GetAllSessionsCallback callback) {
  GetForwardingInterface()->GetAllSessions(std::move(callback));
}
void DeviceBoundSessionManagerInterceptorForTesting::DeleteSession(DeviceBoundSessionDeletionReason reason, DeviceBoundSessionKeyPtr session) {
  GetForwardingInterface()->DeleteSession(
    std::move(reason)
    , 
    std::move(session)
    );
}
void DeviceBoundSessionManagerInterceptorForTesting::DeleteAllSessions(DeviceBoundSessionDeletionReason reason, std::optional<::base::Time> created_after_time, std::optional<::base::Time> created_before_time, ::network::mojom::blink::ClearDataFilterPtr filter, DeleteAllSessionsCallback callback) {
  GetForwardingInterface()->DeleteAllSessions(
    std::move(reason)
    , 
    std::move(created_after_time)
    , 
    std::move(created_before_time)
    , 
    std::move(filter)
    , std::move(callback));
}
void DeviceBoundSessionManagerInterceptorForTesting::AddObserver(const ::blink::KURL& url, ::mojo::PendingRemote<DeviceBoundSessionAccessObserver> observer) {
  GetForwardingInterface()->AddObserver(
    std::move(url)
    , 
    std::move(observer)
    );
}
void DeviceBoundSessionManagerInterceptorForTesting::AddEventObserver(::mojo::PendingRemote<DeviceBoundSessionEventObserver> observer) {
  GetForwardingInterface()->AddEventObserver(
    std::move(observer)
    );
}
void DeviceBoundSessionManagerInterceptorForTesting::CreateBoundSessions(::blink::Vector<DeviceBoundSessionParamsPtr> params, const ::blink::Vector<uint8_t>& wrapped_key, const ::blink::Vector<::net::CanonicalCookie>& cookies_to_set, ::network::mojom::blink::CookieOptionsPtr cookie_options, CreateBoundSessionsCallback callback) {
  GetForwardingInterface()->CreateBoundSessions(
    std::move(params)
    , 
    std::move(wrapped_key)
    , 
    std::move(cookies_to_set)
    , 
    std::move(cookie_options)
    , std::move(callback));
}
void DeviceBoundSessionManagerInterceptorForTesting::PrewarmSessionsForUrl(const ::blink::KURL& url, PrewarmSessionsForUrlCallback callback) {
  GetForwardingInterface()->PrewarmSessionsForUrl(
    std::move(url)
    , std::move(callback));
}
DeviceBoundSessionManagerAsyncWaiter::DeviceBoundSessionManagerAsyncWaiter(
    DeviceBoundSessionManager* proxy) : proxy_(proxy) {}

DeviceBoundSessionManagerAsyncWaiter::~DeviceBoundSessionManagerAsyncWaiter() = default;


void DeviceBoundSessionManagerAsyncWaiter::GetAllSessions(
    ::blink::Vector<DeviceBoundSessionKeyPtr>* out_sessions) {
  base::RunLoop loop;
  proxy_->GetAllSessions(
      base::BindOnce(
          [](base::RunLoop* loop,
             ::blink::Vector<DeviceBoundSessionKeyPtr>* out_sessions
,
             ::blink::Vector<DeviceBoundSessionKeyPtr> sessions) {*out_sessions = std::move(sessions);
            loop->Quit();
          },
          &loop,
          out_sessions));
  loop.Run();
}

::blink::Vector<DeviceBoundSessionKeyPtr> DeviceBoundSessionManagerAsyncWaiter::GetAllSessions(
    ) {
  ::blink::Vector<DeviceBoundSessionKeyPtr> async_wait_result;
  GetAllSessions(&async_wait_result);
  return async_wait_result;
}

void DeviceBoundSessionManagerAsyncWaiter::DeleteAllSessions(
    DeviceBoundSessionDeletionReason reason, std::optional<::base::Time> created_after_time, std::optional<::base::Time> created_before_time, ::network::mojom::blink::ClearDataFilterPtr filter) {
  base::RunLoop loop;
  proxy_->DeleteAllSessions(
      std::move(reason),
      std::move(created_after_time),
      std::move(created_before_time),
      std::move(filter),
      base::BindOnce(
          [](base::RunLoop* loop) {
            loop->Quit();
          },
          &loop));
  loop.Run();
}



void DeviceBoundSessionManagerAsyncWaiter::CreateBoundSessions(
    ::blink::Vector<DeviceBoundSessionParamsPtr> params, const ::blink::Vector<uint8_t>& wrapped_key, const ::blink::Vector<::net::CanonicalCookie>& cookies_to_set, ::network::mojom::blink::CookieOptionsPtr cookie_options, ::blink::Vector<DeviceBoundSessionError>* out_session_results, ::blink::Vector<::net::CookieInclusionStatus>* out_cookie_results) {
  base::RunLoop loop;
  proxy_->CreateBoundSessions(
      std::move(params),
      std::move(wrapped_key),
      std::move(cookies_to_set),
      std::move(cookie_options),
      base::BindOnce(
          [](base::RunLoop* loop,
             ::blink::Vector<DeviceBoundSessionError>* out_session_results
,
             ::blink::Vector<::net::CookieInclusionStatus>* out_cookie_results
,
             const ::blink::Vector<DeviceBoundSessionError>& session_results,
             ::blink::Vector<::net::CookieInclusionStatus> cookie_results) {*out_session_results = std::move(session_results);*out_cookie_results = std::move(cookie_results);
            loop->Quit();
          },
          &loop,
          out_session_results,
          out_cookie_results));
  loop.Run();
}



void DeviceBoundSessionManagerAsyncWaiter::PrewarmSessionsForUrl(
    const ::blink::KURL& url, ::blink::Vector<DeviceBoundSessionRefreshResult>* out_results, std::optional<::base::Time>* out_earliest_next_refresh_time) {
  base::RunLoop loop;
  proxy_->PrewarmSessionsForUrl(
      std::move(url),
      base::BindOnce(
          [](base::RunLoop* loop,
             ::blink::Vector<DeviceBoundSessionRefreshResult>* out_results
,
             std::optional<::base::Time>* out_earliest_next_refresh_time
,
             const ::blink::Vector<DeviceBoundSessionRefreshResult>& results,
             std::optional<::base::Time> earliest_next_refresh_time) {*out_results = std::move(results);*out_earliest_next_refresh_time = std::move(earliest_next_refresh_time);
            loop->Quit();
          },
          &loop,
          out_results,
          out_earliest_next_refresh_time));
  loop.Run();
}






void DeviceBoundSessionAccessObserverInterceptorForTesting::OnDeviceBoundSessionAccessed(DeviceBoundSessionAccessPtr access) {
  GetForwardingInterface()->OnDeviceBoundSessionAccessed(
    std::move(access)
    );
}
void DeviceBoundSessionAccessObserverInterceptorForTesting::Clone(::mojo::PendingReceiver<DeviceBoundSessionAccessObserver> observer) {
  GetForwardingInterface()->Clone(
    std::move(observer)
    );
}
DeviceBoundSessionAccessObserverAsyncWaiter::DeviceBoundSessionAccessObserverAsyncWaiter(
    DeviceBoundSessionAccessObserver* proxy) : proxy_(proxy) {}

DeviceBoundSessionAccessObserverAsyncWaiter::~DeviceBoundSessionAccessObserverAsyncWaiter() = default;





void DeviceBoundSessionEventObserverInterceptorForTesting::OnDeviceBoundSessionEventReceived(DeviceBoundSessionEventPtr event) {
  GetForwardingInterface()->OnDeviceBoundSessionEventReceived(
    std::move(event)
    );
}
void DeviceBoundSessionEventObserverInterceptorForTesting::AddDeviceBoundSessionDisplays(::blink::Vector<DeviceBoundSessionDisplayPtr> session_displays) {
  GetForwardingInterface()->AddDeviceBoundSessionDisplays(
    std::move(session_displays)
    );
}
DeviceBoundSessionEventObserverAsyncWaiter::DeviceBoundSessionEventObserverAsyncWaiter(
    DeviceBoundSessionEventObserver* proxy) : proxy_(proxy) {}

DeviceBoundSessionEventObserverAsyncWaiter::~DeviceBoundSessionEventObserverAsyncWaiter() = default;







}  // network::mojom::blink


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